FileInputStream fis = null;

• 파일을 읽어오기에 앞서 선언해둔 stream에 null값을 넣지 않으면 close() 메소드를 사용할 때 오류가 난다.
• 이해가 안 가면 외우기..!

try {
	fis = new FileInputStream("input.txt");
	int i;
	while((i=fis.read()) != -1) {
		System.out.print((char)i);
	}
	System.out.println();
}

• i는 fis.read()값을 가지고, i가 -1이 아닐 때 while문을 돌려 파일을 읽어온다.

 catch (FileNotFoundException e) {
	System.out.println("FileInputException 예외 발생");
	e.printStackTrace();	// 위치 추적
}

• 해당 코드는 오류가 난다.
• 위의 fis.read()의 예외처리를 하지 않았기 때문인데, 이것을 해결하기 위해서 catch를 하나 더 만들어도 되지만 러프하게 처리해도 되는 경우에는 이미 만들어둔 catch의 FileNotFoundException을 Exception으로 바꾸면 해결이 된다. ( Exception이 FileNotFoundException의 조상타입이라 가능한 방법이다.)
• 밑에 고친 코드를 올려놓았다.

// 고친 코드
 catch (Exception e) {
	System.out.println("Exception 예외 발생");
	e.printStackTrace();	// 위치 추적
}

finally {
	try {
		fis.close();
	} catch (IOException e) {
		System.out.println(e);	// 원칙: e.getMessage()
		e.printStackTrace();
	}
}
System.out.println("continue");

• 코드가 try에서 멈추든, catch에서 멈추든 무조건 실행되는 구간, finally
• fis.close()를 넣고, 마찬가지로 실행되지 않을 수 있기 때문에 예외처리를 해준다.

char ch1='A'; char ch2='B';
Writer out=new FileWriter("hyper.txt");
out.write(ch1);
out.write(ch2);
out.close();

• char 변수에 각 각 A, B를 담아 두 개 선언한다. (유니코드를 사용하기 때문에 2byte씩 가지고 있다.)
• FileWriter을 통해 파일을 생성한다.
• 파일 안에 적을 내용을 write(스트림)를 통해 전송한다.
• 할 일이 끝났다면 close를 통해 닫아준다.
• 해당 클래스가 들어있는 자바 패키지 파일을 보면 이 텍스트 파일이 생겨난 것을 확인할 수 있다.

• 개행 뜻: 강제 줄 바꿈
• 개행은 newLine 메소드의 호출을 통해서 이뤄진다. 이렇듯 \n이 아닌 newLine 메소드 호출을 통해서 개행을 구분하는 이유는 시스템에 따라서 개행을 표현하는 방법이 다르기 때문이다.

// 문자열 출력을 위한 스트림의 구성
BufferedWriter out = new BufferedWriter(new FileWriter("String.txt"));
out.write("박지성 - 메시 멈추게 하는데 집중하겠다.");
out.newLine();
out.write("팀이 승리하는 것을 돕기 위해 최선을 다하겠다.");
out.newLine();
out.write("환상적인 결승전이 될 것이다.");
out.newLine();
out.write("기사 제보 및 보도자료");
out.newLine();
out.write("press@goodnews.co.kr");
out.close();
System.out.println("기사 입력 완료.");

• 빠른 출력을 위해 BufferedWriter을 사용 (필터)
• newLine()으로 줄바꿈
• 쓰기가 끝났다면 close를 통해 닫아준다.

// 문자열 입력을 위한 스트림의 구성
BufferedReader in = new BufferedReader(new FileReader("String.txt"));
String str;
while (true) {
	str = in.readLine();
	if (str == null)
		break;
	System.out.println(str);
}
in.close();

• 빠른 읽기를 위해 BufferedReader을 사용 (필터)
• readLine() 호출 시 개행 정보는 문자열의 구분자로 사용되고 버려지므로, 문자열 출력 후 개행을 위해서는 println을 사용해야 한다.
• 읽기가 끝났다면 close를 통해 닫아준다.

File file = new File("C:\\myJava\\java");

if(file.exists() == false) {

• file.exists() == false는 file이 없다는 뜻이다.
• isDirectory() == ture는 file이 폴더라면 이라는 뜻이다.

//	file.mkdir();	// 최하위 폴더 생성(중요!!)
	file.mkdirs();	// 상위폴더까지 생성
	System.out.println("존재하지 않습니다. 폴더를 생성합니다.");
}

• mkdir()은 최하위 폴더만 생성하고, mkdirs()는 상위 폴더까지 생성한다.

• 익명 함수
• 장점
  1. 코드의 간결성: 복잡한 코드를 극단적으로 줄일 수 있다.
  2. 지연연산 수행: 지연연상을 수행함으로 불필요한 연산을 최소화할 수 있다. (아직 모르겠음!)
  3. 병렬처리 가능: 멀티스레드를 사용하여 병렬처리를 할 수 있다.
• 단점
  1. 람다를 사용하면서 만든 무명함수는 1회성으로, 재사용이 불가능하다.
  2. 람다식의 호출이 까다롭다.
  3. 람다를 남발하면 오히려 가독성이 떨어져 코드가 지저분해질 수 있다.
• 함수형 인터페이스: 추상 메소드가 오직 1개여야만 한다.

package ex1;

@FunctionalInterface
interface Add{
	public int add(int x, int y);
}

public class LambdaTest1 {
	public static void main(String[] args) {
		Add addInst = (x, y) -> {System.out.print(x+"+"+y+"="); return x+y;};
		
		System.out.println(addInst.add(1,2));
	}
}

@FunctionalInterface
interface Add{
	public int add(int x, int y);
}

• 한 클래스 내에서 퍼블릭 클래스 위나 아래에 인터페이스를 하나 생성하고, 추상 메소드를 하나 만든다.
• 인터페이스 위의 @FunctionalInterface는 함수형 인터페이스에 메소드가 하나인지 하나이상인지 검사해준다.

public class LambdaTest1 {
	public static void main(String[] args) {
		Add addInst = (x, y) -> {System.out.print(x+"+"+y+"="); return x+y;};
		//Add addInst = (x, y) -> {return x+y;};
		//Add addInst = (x, y) -> x+y;
		
		System.out.println(addInst.add(1,2));
	}
}

• 해당 코드는 람다식을 이용하여 인터페이스를 구현한 코드다.
• (x, y)는 매개변수, 중괄호{} 안에 있는 코드는 실행할 코드다.
• 실행코드가 두 문장 이상이거나 return이 들어가 있다면 중괄호{}를 써줘야 한다. 만약, 실행 코드가 한 문장이고, return도 없다면 중괄호{} 없이 작성해도 된다.

// 1
new Add() {
	@Override
	public int add(int x, int y) {
		return x+y;
	}
};

//2
Add addInst = new Add() {
	public int add(int x, int y) {
		return x+y;
	}
};

• 1, 2 모두 위의 람다식과 같은 코드

package ex3;

public class LambdaTest2 {
	public static void main(String[] args) {
		MyNumber mN = (x, y) -> x>y ? x:y;
		System.out.println("Max="+mN.getMax(10,20));
	}
}

@FunctionalInterface
interface MyNumber {
	public int getMax(int x, int y);
}

• 해당 코드는 삼항연산자를 이용해 람다식으로 두 수 중 최대값을 반환하는 것을 구현한 코드다.
• (x, y) ⬅️ 매개변수
• x>y ? x:y ⬅️ 실행코드 (삼항연산자)

public class HashMapMain {
	public static void main(String[] args) {
		HashMapList mList = new HashMapList();
		Member lee = new Member(1001, "이순신");
		Member kim = new Member(1002, "김유신");
		Member kang = new Member(1003, "강감찬");
		Member hong = new Member(1004, "홍길동");
		Member hong2 = new Member(1004, "홍길동");
		Member hong3 = new Member(2008, "홍길동");
		
		mList.addMember(lee);
		mList.addMember(kim);
		mList.addMember(kang);
		mList.addMember(hong);
		mList.addMember(hong2);
		mList.addMember(hong3);
		
		mList.showAllMember();
		
		mList.removeMember(lee.getId());
		
		mList.showAllMember();
		
		
		HashMap<Integer, String> hMap = new HashMap<>();
		hMap.put(1001, "kim");
		hMap.put(1002, "kim");
		hMap.put(1003, "park");
		hMap.put(1004, "hong");
		System.out.println(hMap);
	}
}

• HashMap을 이용한 멤버 목록

public class Member {
	private int id;
	private String name;
	
	public Member(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return id+"\t"+name;
	}
}

• Member 클래스는 어제자 예제와 동일하다.

public class HashMapList

// 필드
private HashMap<Integer, Member> hashMap;

• Map <K, V>에 따라 필드를 저장한다.

// 생성자
public HashMapList() {
	this.hashMap = new HashMap<>();
}

public void addMember(Member member) {
	// 1001, new Member(1001,"강감찬")
	// 1002, new Member(1002,"홍길동")
	this.hashMap.put(member.getId(), member);
}

• 매개변수로 Member 타입으로 저장할 member를 받아온다.
• k 값에 member의 id를 넣고, v 값에 member 변수를 넣는다.

public boolean removeMember(int memberId) {
	if (hashMap.containsKey(memberId)) {
		hashMap.remove(memberId);
		return true;
	}
	System.out.println(" > 정보를 찾을 수 없습니다.");
	return false;
}

• 매개변수로 삭제할 memberId를 받아와서 Map 내부에 해당하는 key가 있으면 true 값을 반환하고, 아니라면 false 값을 반환한다.

public void showAllMember() {
	Collection<Member> mList = hashMap.values();
//	System.out.println(mList);
	for(Member mb:mList) {
		System.out.println(mb); //Member toString
	}
	System.out.println("---------------");

}

• HashMap에서 반복문 구현
• Member 타입의 임시변수 mList에 v값을 저장한다.
• foreach를 돌려 새로운 임시변수에 mList의 값을 하나씩 가져와 출력한다.
• 주석처리 된 System.out.println(mList); 라고 출력해도 되지만, 가로로 쭉 출력되는 것이 보기에 좋지 않다. (비추!)

public void showAllMember2() {	
	Iterator<Integer> ir = hashMap.keySet().iterator();
	while(ir.hasNext()) {
		int key = ir.next();
		Member m = hashMap.get(key);
		System.out.println(m);
	}
	System.out.println("---------------");
}

• Iterator을 이용한 멤버 전체 출력
• ir 값에 k값을 집어넣고, while문의 조건에 ir.hasNext를 넣어 Map의 다음 값이 있다면 true, 없다면 false를 입력받아 반복문을 돌린다.
• 임시변수에 ir.next를 통해 현재 값을 저장한다.
• Member 임시변수에 k값에 해당하는 v값을 저장하고, 출력한다.

• 자바 스트림의 큰 분류: 입력 스트림(프로그램으로 데이터를 읽어들이는 스트림), 출력 스트림(프로그램으로부터 데이터를 내보내는 스트림)
• 데이터의 입력을 위해서는 입력 스트림을, 출력을 위해서는 출력 스트림을 형성해야한다. (스트림은 인스턴스의 생성을 통해 형성된다.)

• 파일 기반의 입력 스트림 형성
  • 파일 run.exe(예시) 대상의 입력 스트림 생성(인스턴스 생성)
  • FileInputStream 클래스는 InputStream 클래스를 상속한다.
• InputStream 클래스: 바이트 단위로 데이터를 읽는 모든 입력 스트림 클래스의 최상위 클래스 (파일에 맞춰서 read 메소드 구현)
• OutputStream 클래스: 바이트 단위로 데이터를 쓰는 모든 출력 스트림 클래스의 최상위 클래스
• GDInputStream 클래스: 존재하지 않는 가상의 클래스 (장치에 맞춰서 read 메소드 구현)

• InputStream 클래스(추상화 클래스)의 대표적인 두 메소드
  • public abstract int read() throws IOException
  • public void close() throws IOException
• 입력의 대상에 적절하게 read 메소드가 정의되어 있다. 그리고 입력 대상에 따라서 입력 스트림을 의미하는 별도의 클래스가 정의되어있다.

// 파일 대상의 입력 스트림 생성
InputStream in = new FileInputStream("run.exe");
int bData = in.read();

• 오버라이딩에 의해 FileInputStream의 read 메소드 호출

• 파일 대상의 출력 스트림 형성(입출력 스트림은 대부분 쌍(pair)을 이룬다.

InputStream <-> OutputStream

FileInputStream <-> FileOutputStream

public class Ex01 {
	public static void main(String[] args) throws IOException {
		InputStream in = new FileInputStream("boss.mp4");
		OutputStream out = new FileOutputStream("bossCopy.mp4"); // 자동으로 생성된다.
		long start = System.currentTimeMillis();
		
		int copyByte = 0;
		int bData;
		while (true) {
			bData = in.read();	// 1바이트 씩 읽기
			if (bData == -1)
				break;
			out.write(bData);
			copyByte++;
		}
		in.close();
		out.close();
		// 40.199초
		
		long end = System.currentTimeMillis();
		System.out.println("파일복사 시간: "+(end-start)/1000.+"초");
		System.out.println("복사된 바이트 크기 " + copyByte);
	}
}

• InputStream in에 new FileInputStream()으로 읽어들일 파일(자바 소스와 같은 폴더에 들어있어야 함!)의 이름을 큰따옴표"" 안에 적는다.
• OutputStream out에 새로 생성할 파일의 이름을 적는다.
• copyByte라는 변수를 만들어 값을 0으로 설정하고, bData라는 변수도 선언해둔다. (변수명은 달라도 상관없다.)
• while문 조건을 true로 두고 bData에 in.read();를 통해 읽어들인 바이트 값을 저장한다. (1바이트씩 읽는다.)
• 만약 bData에 -1 값이 들어갔다면 break를 통해 while문을 종료한다.
• 조건에 충족하지 않았다면 out.write();를 통해 bData 값 만큼 출력하고, copyByte를 1씩 올린다.
• in/out 코드 모두 close() 메소드를 통해 닫아준다.
• long start/end는 시간을 재기 위한 코드 (컴퓨터마다 차이는 있겠지만 내 노트북으로는 해당 코드로 16GB 영상을 복사하는데 40.199초가 나왔다.)

InputStream in = new FileInputStream("boss.mp4");
		OutputStream out = new FileOutputStream("bossCopy.mp4");
		long start = System.currentTimeMillis();
		
		int copyByte=0;
		int readLen;
		byte buf[]=new byte[1024];
		while(true)
		{
			readLen=in.read(buf);
			if(readLen==-1)
				break;
			out.write(buf, 0, readLen);
			copyByte+=readLen;
		}
		// 0.057초
		
		long end = System.currentTimeMillis();
		System.out.println("파일복사 시간: "+(end-start)/1000.+"초");
		System.out.println("복사된 바이트 크기 " + copyByte);

• 위의 코드에서 start/end 사이의 내용만 바꾼 코드
• 전체 구조는 비슷하지만 readLen이란 변수에 in.read만큼 읽어들일때, buf를 통해 바이트[1024] 값을 담아 1024배 빠르게 읽어들일 수 있도록 한다. (이론상으로는 1024배만큼 빨라져야 한다.)
• 위의 코드가 계단을 통해 위로 올라가는 것이었다면 이 코드는 엘레베이터를 통해 위로 올라가는 느낌
• out.write에는 buf 배열 0번째 인덱스부터 readLen 바이트를 저장한다.
• copyByte는 readLen 값을 누적해서 저장한다.
• long start/end는 시간을 재기 위한 코드 (컴퓨터마다 차이는 있겠지만 내 노트북으로는 해당 코드로 16GB 영상을 복사하는데 0.057초가 나왔다.) (같은 영상인데 훨씬 빠르다!)

• 일반화
• 클래스나 메소드 내부에서 사용되는 객체의 타입 안정성을 높일 수 있다.
• 반환값에 대한 타입 변환 및 타입 검사에 들어가는 노력을 줄일 수 있다.
• 데이터 형식에 의존하지 않고, 하나의 값이 여러 다른 데이터 타입들을 가질 수 있도록 하는 방법
• 클래스 내부에서 지정하는 것이 아닌 외부에서 사용자에 의해 지정되는 것
• 클래스 자체가 아니라 클래스 내의 메소드 하나만 제네릭인 경우도 있다.
• 기본 자료형은 사용할 수 없다. (ex: int, double 등)
• ArrayList 등을 사용할 때 붙어있는 꺽새 괄호<>가 제네릭이다. (ex: ArrayList<String>)
• 타입이 정해져있지 않다면 <T>를 적는다. (템플릿의 약자) / Object로 적으면 자료형이 안정성이 떨어진다.

fct(10);
fct('A');
fct("A");

void fct(T a) { … }

• 알아서 int, char, String으로 생성된다.

ArrayList<String> list = new ArrayList<>();
//list.add(1);
list.add("1");
list.add("2");
for(String s : list) System.out.println(s);

ArrayList<Integer> listI = new ArrayList<>();
listI.add(3);
listI.add(4);
for(int s : listI) System.out.println(s);

• 제네릭 타입을 String으로 적어서 ArrayList를 문자로 채우겠다고 약속을 했는데 숫자를 넣으면 에러가 난다.
• 제네릭 타입을 Integer을 적고 안에 있는 값을 foreach int로 돌려도 값이 출력된다.
• 클래스를 타입으로 적을 수 있다.

• 다수의 데이터를 쉽고 효과적으로 처리할 수 있는 표준화된 방법을 제공하는 클래스의 집합을 의미
• 데이터를 저장하는 자료 구조와 데이터를 처리하는 알고리즘을 구조화하여 클래스로 구현해 놓은 것
• 컬렉션 프레임워크 주요 인터페이스는 List 인터페이스, Set 인터페이스, Map 인터페이스를 정의하고 있지만 List, Set 인터페이스는 Collection 인터페이스를 상속받고 Map 인터페이스는 별도 정의한다.
•  
• 컬렉션 프레임워크를 구성하는 모든 클래스는 제네릭으로 표현

• List <E>: 저장 순서 인정 / 중복값 허용 (ArrayList, LinkedList 등)
• Set <E>: 저장 순서 비인정 / 중복값 비허용 (HashSet, TreeSet) (단, 내가 만든 클래스를 타입으로 받을 경우, 중복값을 제거해주지 않으므로 직접 equals랑 HashCode를 오버라이딩해주어야 중복값을 제거할 수 있다.)
• Map <K, V>: 저장 순서 비인정 / 키: 중복값 비허용, 값: 중복값 허용 / 키(Key)와 값(Value)이 한 쌍 (HashMap, TreeMap 등)

• ArrayList<E>: 특징이 배열의 특징과 일치

장점: 데이터의 참조가 용이해서 빠른 참조가 가능하다.

단점: 저장소의 용량을 늘리는 과정에서 많은 시간이 소요되고, 데이터의 삭제에 필요한 연산과정이 매우 길다. (잦은 삽입/삭제에 오버헤드가 걸린다.)

• LinkedList<E>: 특징이 리스트의 자료구조의 특징과 일치

장점: 저장소의 용량을 늘리는 과정이 간단하고, 데이터의 삭제가 매우 간단하다.

단점: 데이터의 참조가 다소 불편하다.

ArrayList<Integer> list = new ArrayList<Integer>();
ArrayList<Integer> list2 = new ArrayList<>();
List<Integer> list3 = new ArrayList<>();
Collection<Integer> list4 = new ArrayList<>();

• 꺽새(제네릭)에 기본타입(ex: int) 불가
• 뒷 꺽새는 타입을 안 적어도 되지만 꺽새는 적어야한다.
• 부모타입인 List/Collection으로 ArrayList 생성 가능

list.add(10);
list.add(new Integer(20));
list.add(30);

• new Integer 스킵 가능

System.out.println(list.size()+"개");

• size를 통해 ArrayList 길이 출력 가능

list.remove(0);

• 첫번째 인덱스(10) 삭제

for(int s : list) {
	System.out.println(s);
}

for(Integer s : list) {
	System.out.println(s);
}

for(int i=0; i<list.size(); i++) {
	System.out.println(list.get(i));
}

• 세가지 모두 리스트 값을 출력한다.
• Integer 타입이지만 int 타입에 값을 담아서 출력하는 방법도 가능하다.

• 반복자
• 컬렉션 프레임워크(List, Set, Map, Queue)에서 값을 가져오거나 삭제할 때 사용
• list.get()으로 값을 꺼내올 수 없는 Set에서 사용할 수 있다.
• 장점

모든 컬렉션 프레임워크에 공통적으로 사용이 가능하다.  쉽게 값을 가져오거나 제거가 가능하다.

• 단점

처음부터 끝까지의 단방향 반복만 가능하다. 값을 변경하거나 추가하는 것이 불가능하고, 대량의 데이터를 제어할 때 속도가 느리다.

• 메소드

Iterator.hasNext(): 다음 값이 있으면 true, 아니면 false 값을 반환

Iterator.next(): 다음 값을 가져온다.

Iterator.remove(): next 시 가져왔던 값(현재 값)을 컬렉션에서 삭제한다. 반드시 Iterator.next() 다음에 사용!

Set<String> list = new HashSet<>();
list.add("first");
list.add("first");
list.add("third");
list.add("fourth");

• 두번째 적은 first는 중복값이므로 Set으로 만든 list에 값이 저장되지 않는다. 따라서 값은 3개만 저장된다.

Iterator<String> ir = list.iterator();
while(ir.hasNext()){
	String curStr = ir.next();
	System.out.println("curStr: "+curStr);
	if(curStr.equals("third")) {
		ir.remove();	// 반복자의 현재 요소를 삭제
	}
}

• while문의 조건에 ir.hasNext를 넣어 list에 다음 값이 있다면 true, 아니라면 false를 입력받아 반복문을 돌리거나 나간다.
• 임시변수에 ir.next를 통해 현재 값을 저장한다.
• if문의 조건에 삭제하고 싶은 값과 현재 값이 같은지 적고, 만약 맞다면 iterator의 현재 요소를 삭제하면 list에서도 삭제된다.

ir = list.iterator();
while(ir2.hasNext()){
	System.out.println(ir2.next());
}

• 다시 반복하려고 하면 ir에 새로 지정해주어야 한다.

HashSet<Person> hSet = new HashSet<Person>();
hSet.add(new Person("최순이", 10));
hSet.add(new Person("최순이", 20));
hSet.add(new Person("갑돌이", 20));
hSet.add(new Person("갑돌이", 15));
hSet.add(new Person("최순이", 20));
hSet.add(new Person("갑돌이", 20));
System.out.println("데이터 수:" + hSet.size());
Iterator<Person> itr = hSet.iterator();
while (itr.hasNext()) {
	System.out.println(itr.next());
}

• 내가 만든 클래스를 타입으로 주고 저장하면, 중복값이 제거되지 않는다. (클래스 내에서 오버라이딩 해주어야 한다.)
• Iterator을 통해 값을 출력한다.

private String name;
private int age;

public Person(String name, int age) {
	this.name = name;
	this.age = age;
}

@Override
public String toString() {
	return name + "(" + age + "세)";
}

@Override
public boolean equals(Object obj) {
	Person p = (Person)obj;
	if(this.name.equals(p.name) && this.age == p.age) {
		return true;
	}
	return false;
}
@Override
public int hashCode() {
//		return age;	// 나이가 같은 사람끼리 모아두기
//		return name.hashCode();	// 이름이 같은 사람끼리 모아두기
	return age%3 + name.hashCode();
    // 나이가 같은 사람끼리(3그룹), 이름이 같은 사람끼리 모아두기
}

@Override
public int compareTo(Person p) {
	// 이름 길이, 알파벳 순 정렬+같은 길이 스킵 안 함
	if(name.length()>p.name.length()) return 1;
	else if(name.length()<p.name.length()) return -1;
	else {
		if(name.compareTo(p.name)>0) return 1;
		else if(name.compareTo(p.name)<0) return -1;		
}

• 중복값을 제거하기 위해 equals와 hashCode를 오버라이딩했다.
• equals 메소드 오버라이딩에서 받아올 변수가 Object로 받았기 때문에 (Person)을 통해 강제형변환을 해준다. 조건문에 같은 조건을 주고, 조건을 만족하면 true를 return하고 조건을 만족하지 못하면 false를 return한다.
• Person 클래스에 implements Comparable했기 때문에 compareTo를 오버라이딩할 수 있다.

public class Main {
	public static void main(String[] args) {
		MemberArrayList mList = new MemberArrayList();
		Member lee = new Member(1001, "이순신");
		Member kim = new Member(1002, "김유신");
		Member kang = new Member(1003, "강감찬");
		Member hong = new Member(1004, "홍길동");
		Member hong2 = new Member(1004, "홍길동");
		
		mList.addMember(lee);
		mList.addMember(kim);
		mList.addMember(kang);
		mList.addMember(hong);
		mList.addMember(hong2);
		
		mList.showAllMember();
		mList.removeMember(kim.getId());
		mList.showAllMember();
	}
}

• ArrayList를 이용한 멤버 목록

public class Member {
	private int id;
	private String name;
	
	public Member(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
    
	@Override
	public String toString() {
		return id+"\t"+name;
	}
}

• Member 클래스

public class MemberArrayList {
	private ArrayList<Member> memberList;

	public MemberArrayList() {
		memberList = new ArrayList<>();
	}
	public MemberArrayList(int size) {
		memberList = new ArrayList<>(size);
	}
	
	public void addMember(Member member) {
		this.memberList.add(member);
	}
	
	public boolean removeMember(int id) {
		Iterator<Member> ir = memberList.iterator();
		while(ir.hasNext()) {
			Member member = ir.next();
			int tempId = member.getId();
			if(tempId == id) {
				memberList.remove(member);
				return true;
			}
		}
		System.out.println(id+"가 존재하지 않습니다.");
		return false; 
	}
	
	public void showAllMember() {
		System.out.println("============");
		System.out.println("id\tname");
		System.out.println("--  ----  --");
		for(Member m:memberList) {
			System.out.println(m);	// Member의 toString 생략
		}
		System.out.println("============");
		System.out.println();
	}
}

• Member 클래스를 통해 만들어낸 객체들을 저장하고, 컨트롤타워에서 명령한 메소드가 담겨있는 ArrayList 클래스
• 삭제는 Iterator을 통해 메소드를 작성했다. (독해는 위의 4. Iterator에서 적어두었다.)