일반적인 하나의 코드로 다양한 자료형을 처리하는 기법을 살펴봅시다. 제 7 장 제네릭과 컬렉션

학습 목표 2 제네릭이란? 컬렉션의 개념 Vector<E>, ArrayList<E>, HashMap<K,V> 활용 Iterator<E> 활용 사용자 제네릭 클래스 만들기

제네릭이란? 제네릭 프로그래밍(generic programming) 일반적인 코드를 작성하고 이 코드를 다양한 타입의 객체에 대하 여 재사용하는 프로그래밍 기법 제네릭은 컬렉션 라이브러리에 많이 사용

기존의 방법 일반적인 객체를 처리하려면 Object 참조 변수를 사용 예제로 하나의 데이터를 저장하는 Store 클래스를 살펴 보자.

기존의 방법(코드) 문제점 발생!!

제네릭을 이용한 버전 문자열을 저장하려면 다음과 같이 선언 정수를 저장하려면 다음과 같이 선언 C++의 템플릿(template)과 유사 문자열을 저장하려면 다음과 같이 선언 Store<String> store = new Store<String>(); 정수를 저장하려면 다음과 같이 선언 Store<Integer> store = new Store<Integer>();

제네릭 버전의 사용 // Casting 불필요

중간 점검 문제 왜 데이터를 Object 참조형 변수에 저장하는 것이 위험할 수 있는가? 2. Store 객체에 Rectangle 객체를 저장하도록 제네릭을 이용하여 생성하여 보 라. Store<Rectangle> store = new Store<Rectangle>(); 3. 타입 매개 변수 T를 가지는 Point 클래스를 정의하여 보라. Point 클래스는 2 차원 공간에서 점을 나타낸다. Class Point<T> { T x; T y; … }

제네릭 메소드(Generic Method) 메소드에서도 타입 매개 변수를 사용하여서 제네릭 메 소드를 정의할 수 있다. 타입 매개 변수의 범위가 메소드 내부로 제한된다. 반환형 매개변수 배열의 마지막 원소를 반환하는 메소드

제네릭 메소드의 사용 String[] language= { "C++", "C#", "JAVA" }; String last = Array.<String>getLast(language);// last는 “JAVA" 또는 String last = Array.getLast(language); // last는 “JAVA"

컬렉션(collection)의 개념 컬렉션 컬렉션은 요소(element)라고 불리는 가변 개수의 객체들의 모음 객체들의 컨테이너라고도 불림 컬렉션 클래스 사례 Vector, ArrayList, Hashtable, LinkedList, HashMap, HashSet, Stack java.util 패키지에서 제공 다양한 객체들을 삽입, 삭제, 검색 등 관리하는데 사용됨

컬렉션(collection) java.util 패키지에서 제공 컬렉션 배열과 컬렉션의 개념 차이 12 컬렉션 요소(element)라고 불리는 가변 개수의 객체들의 저장소 객체들의 컨테이너라고도 불림 요소의 개수에 따라 크기 자동 조절 요소의 삽입, 삭제에 따른 요소의 위치 자동 이동 고정 크기의 배열을 다루는 어려움 해소 다양한 객체들의 삽입, 삭제, 검색 등의 관리 용이 java.util 패키지에서 제공 배열과 컬렉션의 개념 차이

컬렉션 자바 인터페이스와 클래스 인터페이스 클래스 Collection<E> Map<K, V> 13 Collection<E> Map<K, V> Set<E> List<E> Queue<E> 인터페이스 클래스 HashSet<E> ArrayList<E> Vector<E> LinkedList<E> HashMap<K, V> Stack<E>

컬렉션 자바 인터페이스와 클래스

컬렉션과 제네릭 컬렉션은 제네릭(generics) 기법으로 구현됨 컬렉션의 요소는 객체만 가능 제네릭 15 컬렉션은 제네릭(generics) 기법으로 구현됨 컬렉션의 요소는 객체만 가능 기본적으로 int, char, double 등의 기본 타입 사용 불가 JDK 1.5부터 자동 박싱/언박싱 기능으로 기본 타입 사용 가능 제네릭 특정 타입만 다루지 않고, 여러 종류의 타입으로 변신할 수 있도 록 클래스나 메소드를 일반화시키는 기법 <E>, <K>, <V> : 타입 매개 변수 요소 타입을 일반화한 타입 제네릭 클래스 사례 제네릭 벡터 : Vector<E> E에 특정 타입으로 구체화 정수만 다루는 벡터 Vector<Integer> 문자열만 다루는 벡터 Vector<String>

Stack<Integer> 제네릭의 기본 개념 16 JDK 1.5에서 도입(2004년 기점) 모든 종류의 데이터 타입을 다룰 수 있도록 일반화된 타입 매개 변수로 클래스나 메소드를 작성하는 기법 C++의 템플릿(template)과 동일 정수만 저장 정수 스택 ... void push(Integer element) { ... } Integer pop() { ... } 20 -345 class Stack<E> { ... void push(E element) { ... } E pop() { ... } } 123 Stack<Integer> 10 ... void push(String element) { ... } String pop() { ... } Stack<String> “Good” “C#” 제네릭 스택 특정 타입으로 구체화 “C++” “Java” 문자열 스택 문자열만 저장

제네릭 Stack<E> 클래스의 JDK 매뉴얼 17

콜렉션 인터페이스가 제공하는 메소드

List 인터페이스 List 인터페이스 - 순서를 가지는 원소들의 모임 - 중복된 원소가 허용된다. - 위치 인덱스를 사용하여 원소에 접근한다. (0부터 시작) 구현한 클래스 종류 - ArrayList: 리스트를 배열로 구현 - LinkedList: 리스트를 연결리스트로 구현 - Vector: 멀티쓰레드 환경에서 동기화가 지원됨

Vector<E> Vector<E>의 특성 java.util.Vector Collection List 20 Vector<E>의 특성 java.util.Vector <E>에서 E 대신 요소로 사용할 특정 타입으로 구체화 여러 객체들을 삽입, 삭제, 검색하는 컨테이너 클래스 배열의 길이 제한 극복 원소의 개수가 넘쳐나면 자동으로 길이 조절 Vector에 삽입 가능한 것 객체, null 기본 타입은 박싱/언박싱으로 Wrapper 객체로 만들어 저장 Vector에 객체 삽입  add 벡터의 맨 뒤에 객체 추가. : 공간이 모자라면 자동 늘림 벡터 중간에 객체 삽입 : 삽입된 뒤의 객체는 뒤로 하나씩 이동 Vector에서 객체 삭제  remove 임의의 위치에 있는 객체 삭제 가능 : 객체 삭제 후 자동 자리 이동 Vector

Vector<Integer> 컬렉션 내부 구성 21 Vector<Integer> v = new Vector<Integer>(6); add()를 이용하여 요소를 삽입하고 get()을 이용하여 요소를 검색합니다

타입 매개 변수 사용하지 않는 경우 경고 발생 22 Vector로만 사용하면 경고 발생 Vector<Integer>나 Vector<String> 등 타입 매개 변수를 사용하여야 함

Vector 클래스의 생성자 벡터 클래스 생성자. ① public Vector() 기본 생성자. 벡터객체는 가득 차 있을 경우 요소 추가 시마다 증가 한다. 벡터 객체의 기본 용량은 객체 10개이며, 가득 찬 상태에서 객체가 추가될 때마다 크기를 두 배로 증가시킨다. ② public Vector(int initialCapacity) 초기 용량(initialCapacity)만큼의 공간을 가진 벡터객체를 생성한다. 저장공간이 부족할 경우 초기 용량 만큼 증가한다.  ③ public Vector(int intialCapacity, int capacityIncrement) 초기 용량 만큼의 공간을 가진 벡터객체를 생성하되, 저장공간이 다 차게 되면 용량 증가치 만큼 늘어나게 된다.

Vector<E> 클래스의 주요 메소드 24

25 25

26

컬렉션과 자동 박싱/언박싱 JDK 1.5 이전 JDK 1.5부터 27 JDK 1.5 이전 기본 타입 데이터를 Wrapper 클래스를 이용하여 객체로 만들어 사용 컬렉션으로부터 요소를 얻어올 때, Wrapper 클래스로 캐스팅 필요 JDK 1.5부터 자동 박싱/언박싱이 작동하여 기본 타입 값 사용 가능 제네릭의 타입 매개 변수를 기본 타입으로 구체화할 수는 없음 Vector<Integer> v = new Vector<Integer>(); v.add(new Integer(4)); Integer n = (Integer)v.get(0); int k = n.intValue(); // k = 4 Vector<Integer> v = new Vector<Integer> (); v.add(4); // 4 → new Integer(4)로 자동 박싱 int k = v.get(0); // Integer 타입이 int 타입으로 자동 언박싱, k = 4 Vector<int> v = new Vector<int> (); // 오류

예제 7-1 : 정수 값만 다루는 Vector<Integer> 28 정수 값만 다루는 제네릭 벡터를 생성하고 활용하는 사례를 보인다. 다음 코드에 대한 결과는 무엇인가? import java.util.Vector; public class VectorEx { public static void main(String[] args) { // 정수 값만 다루는 제네릭 벡터 생성 Vector<Integer> v = new Vector<Integer>(); v.add(5); // 5 삽입 // 자동 박싱 v.add(4); // 4 삽입 v.add(-1); // -1 삽입 // 벡터 중간에 삽입하기 v.add(2, 100); // 4와 -1 사이에 정수 100 삽입 System.out.println("벡터 내의 요소 객체 수 : " + v.size()); System.out.println("벡터의 현재 용량 : " + v.capacity()); // 벡터의 기본 default 크기는 10 // 모든 요소 정수 출력하기 for(int i=0; i<v.size(); i++) { int n = v.get(i); System.out.println(n); } // 벡터 속의 모든 정수 더하기 int sum = 0; for(int i=0; i<v.size(); i++) { int n = v.elementAt(i); // v.get(i) sum += n; } System.out.println("벡터에 있는 정수 합 : “ + sum); 벡터 내의 요소 객체 수 : 4 벡터의 현재 용량 : 10 5 4 100 -1 벡터에 있는 정수 합 : 108

예제 7-2 Point 클래스의 객체들만 저장하는 벡터 만들기 29 (x, y) 한 점을 추상화한 Point 클래스를 만들고 Point 클래스의 객체만 저장하는 벡터를 작성하라. public class PointVectorEx { public static void main(String[] args) { // Point 객체를 요소로만 가지는 벡터 생성 Vector<Point> v = new Vector<Point>(); // 3 개의 Point 객체 삽입 v.add(new Point(2, 3)); v.add(new Point(-5, 20)); v.add(new Point(30, -8)); // 벡터에 있는 Point 객체 모두 검색하여 출력 for(int i=0; i<v.size(); i++) { Point p = v.get(i); // 벡터에서 i 번째 Point 객체 얻어내기 System.out.println(p); // p.toString()을 이용하여 객체 p 출력 } import java.util.Vector; class Point { private int x, y; public Point(int x, int y) { this.x = x; this.y = y; } public String toString() { return "(" + x + "," + y + ")"; (2,3) (-5,20) (30,-8)

ArrayList<E> ArrayList<E>의 특성 Collection List 30 ArrayList<E>의 특성 java.util.ArrayList, 가변 크기 배열을 구현한 클래스 <E>에서 E 대신 요소로 사용할 특정 타입으로 구체화 ArrayList에 삽입 가능한 것 객체, null 기본 타입은 박싱/언박싱으로 Wrapper 객체로 만들어 저장 ArrayList에 객체 삽입/삭제 리스트의 맨 뒤에 객체 추가  add(E) 리스트의 중간에 객체 삽입  add(index, E) 임의의 위치에 있는 객체 삭제 가능  remove(index) 벡터와 달리 스레드 동기화 기능 없음 다수 스레드가 동시에 ArrayList에 접근할 때 동기화되지 않음 개발자가 스레드 동기화 코드 작성 ArrayList

ArrayList<String> 컬렉션의 내부 구성 31 ArrayList<String> = new ArrayList<String>(); add()를 이용하여 요소를 삽입하고 get()을 이용하 여 요소를 검색합니다

ArrayList<E> 클래스의 주요 메소드 32

33 33

34

예제 7-3 : ArrayList에 문자열을 달기 35 키보드로 문자열을 입력 받아 ArrayList에 삽입하고 가장 긴 이름을 출력하라. import java.util.*; public class ArrayListEx { public static void main(String[] args) { // 문자열만 삽입가능한 ArrayList 컬렉션 생성 ArrayList<String> a = new ArrayList<String>(); // 키보드로부터 4개의 이름 입력받아 ArrayList에 삽입 Scanner scanner = new Scanner(System.in); for(int i=0; i<4; i++) { System.out.print("이름을 입력하세요>>"); String s = scanner.next(); // 키보드로부터 이름 입력 a.add(s); // ArrayList 컬렉션에 삽입 } // ArrayList에 들어 있는 모든 이름 출력 for(int i=0; i<a.size(); i++) { // ArrayList의 i 번째 문자열 얻어오기 String name = a.get(i); System.out.print(name + " "); // 가장 긴 이름 출력 int longestIndex = 0; for(int i=1; i<a.size(); i++) { if(a.get(longestIndex).length() < a.get(i).length()) longestIndex = i; } System.out.println("\n가장 긴 이름은 : " + a.get(longestIndex)); 이름을 입력하세요>>Mike 이름을 입력하세요>>Jane 이름을 입력하세요>>Ashley 이름을 입력하세요>>Helen Mike Jane Ashley Helen 가장 긴 이름은 : Ashley

ArrayList 의 toArray를 통해 package collection; // ArrayList를 배열로 변환한다. import java.util.*; class ArrayListToArray {     public static void main(String args[]) {         // 배열 리스트를 만든다.          List<Integer> al = new ArrayList<Integer>();        // 배열 리스트에 요소를 추가한다 .    al.add(new Integer(1));          al.add(new Integer(2));         al.add(new Integer(3));          al.add(new Integer(4));         System.out.println("Contents of al: " + al);                   // 배열을 얻는다.          Object ia[] = al.toArray();          int sum=0;                  // 배열 요소들의 합계를 구한다.          for(int i=0; i<ia.length; i++){             sum += ((Integer) ia[i]).intValue();         }                             System.out.println("Sum is: " + sum);    }}  ArrayList 의 toArray를 통해 배열로 반환함 Contents of al: [1, 2, 3, 4]  Sum is: 10

컬렉션의 순차 검색을 위한 Iterator Iterator<E> 인터페이스 37 Iterator<E> 인터페이스 Vector<E>, ArrayList<E>, LinkedList<E>가 상속받는 인터페이스 리스트 구조의 컬렉션에서 요소의 순차 검색을 위한 메소드 포함 Iterator<E> 인터페이스 메소드 iterator() 메소드 iterator()를 호출하면 Iterator 객체 반환 Iterator 객체를 이용하여 인덱스 없이 순차적 검색 가능 Vector<Integer> v = new Vector<Integer>(); Iterator<Integer> it = v.iterator(); while(it.hasNext()) { // 모든 요소 방문 int n = it.next(); // 다음 요소 리턴 ... }

반복자(iterator) 반복자(iterator): 반복자는 컬렉션의 원소들을 하나씩 처 리하는데 사용  For-each 문이 더 편리함! Iterator 객체 생성하는 방법 Iterator e = list.iterator(); Iterator 객체 e에 정의된 3 개의 메소드 for (String each : list) { System.out.println(each); }

반복자 ListIterator List를 구현한 클래스인 ArrayList, LinkedList, Vector에만 사용 컬렉션의 원소들을 하나씩 처리하는데 사용하지만, 앞으로 검색이 가능하기도 하며 뒤로도 검색 가능 컬렉션 객체의 원소를 지니고 있는 Iterator 객체 생성하는 방법 ListIterator e2 = list.listIterator(); ListIterator 객체 e2에 정의된 주요 메소드 hasNext() next() hasPrevious(): 이전의 원소가 있는지 판단 previous(): 이전의 원소를 돌려줌

예제 7-4 : Iterator를 이용하여 Vector의 모든 요소 출력하고 합 구하기 40 Vector<Integer>로부터 Iterator를 얻어내고 벡터의 모든 정수를 출력하고 합을 구하라. import java.util.*; public class IteratorEx { public static void main(String[] args) { // 정수 값만 다루는 제네릭 벡터 생성 Vector<Integer> v = new Vector<Integer>(); v.add(5); // 5 삽입 v.add(4); // 4 삽입 v.add(-1); // -1 삽입 v.add(2, 100); // 4와 -1 사이에 정수 100 삽입 // Iterator를 이용한 모든 정수 출력하기 Iterator<Integer> it = v.iterator(); // Iterator 객체 얻기 while(it.hasNext()) { int n = it.next(); System.out.println(n); } // Iterator를 이용하여 모든 정수 더하기 int sum = 0; it = v.iterator(); // Iterator 객체 얻기 while(it.hasNext()) { int n = it.next(); // 언박싱 sum += n; } System.out.println("벡터에 있는 정수 합 : " + sum); 5 4 100 -1 벡터에 있는 정수 합 : 108

맵(Map) 사전(dictionary)과 같은 자료 구조 키(key)에 값(value)이 매핑된다.

맵(Map) Map 인터페이스의 개념 사전과 같은 자료 구조 키(key)에 값(value)이 매핑된다. 중복된 키를 가질 수 없다. 키가 제시되면 값을 돌려준다. 예 Key: 학생 객체의 학번, Value: 학생 객체 Map을 구현한 클래스 HashMap HashTable : 멀티 스레드 환경에서 동기화 지원 (cf. Vector) TreeMap 트리구조에 데이터를 정렬 만약 키들을 정렬된 순서로 돌려받을 필요가 있을 때 사용 LinkedHashMap Map에 있는 엔트리들의 연결 리스트를 유지

Map : HashMap<K, V> 클래스 데이터 저장 방법 Map<String, Student> freshman = new HashMap<String, Student>(); Student kim = new Student("20090001", "김준표", "서울 서초구"); Freshman.put("2009001", kim); 객체 추출 방법 String s = "2009001"; st = freshman.get(s); 예) HashMap<String, String> 생성, 요소 삽입, 요소 검색 키(key) 값(value) HashMap<String, String> h = new HashMap<String, String>(); h.put("apple", "사과"); // "apple" 키와 "사과" 값의 쌍을 해시맵에 삽입 String kor = h.get("apple"); // "apple" 키로 값 검색. kor는 "사과“

HashMap<String, String>의 내부 구성과 put(), get() 메소드 44 HashMap<String, String> map = new HashMap<String, String>();

HashMap<K,V>의 주요 메소드 45

46

예제 7-5 : HashMap을 이용하여 영어 단어와 한글 단어를 쌍으로 저장하고 검색하는 사례 47 영어 단어와 한글 단어를 쌍으로 HashMap에 저장하고 영어 단어로 한글 단어를 검색하는 프로그램을 작성하라. import java.util.*; public class HashMapDicEx { public static void main(String[] args) { // 영어 단어와 한글 단어의 쌍을 저장하는 HashMap 컬렉션 생성 HashMap<String, String> dic = new HashMap<String, String>(); // 3 개의 (key, value) 쌍을 dic에 저장 dic.put("baby", "아기"); // "baby"는 key, "아기"은 value dic.put("love", "사랑"); dic.put("apple", "사과"); // dic 컬렉션에 들어 있는 모든 (key, value) 쌍 출력 Set<String> keys = dic.keySet(); // key 문자열을 가진 Set 리턴 Iterator<String> it = keys.iterator(); while(it.hasNext()) { String key = it.next(); String value = dic.get(key); System.out.println("(" + key + "," + value + ")"); } // 영어 단어를 입력 받고 한글 단어 검색 Scanner scanner = new Scanner(System.in); for(int i=0; i<3; i++) { System.out.print("찾고 싶은 단어는?"); String eng = scanner.next(); System.out.println(dic.get(eng)); } (love,사랑) (apple,사과) (baby,아기) 찾고 싶은 단어는?apple 사과 찾고 싶은 단어는?babo null 찾고 싶은 단어는?love 사랑 출력된 결과는 삽입된 결과와 다르다는 점을 기억하기 바람 “babo”를 해시맵에서 찾을 수 없기 때문에 null 리턴

예제 7-6 HashMap을 이용하여 자바 과목의 점수를 기록 관리하는 코드 작성 48 HashMap을 이용하여 학생의 이름과 자바 점수를 기록 관리해보자. import java.util.*; public class HashMapScoreEx { public static void main(String[] args) { // 사용자 이름과 점수를 기록하는 HashMap 컬렉션 생성 HashMap<String, Integer> javaScore = new HashMap<String, Integer>(); // 5 개의 점수 저장 javaScore.put("한홍진", 97); javaScore.put("황기태", 34); javaScore.put("이영희", 98); javaScore.put("정원석", 70); javaScore.put("한원선", 99); System.out.println("HashMap의 요소 개수 :" + javaScore.size()); // 모든 사람의 점수 출력. // javaScore에 들어 있는 모든 (key, value) 쌍 출력 // key 문자열을 가진 집합 Set 컬렉션 리턴 Set<String> keys = javaScore.keySet(); // key 문자열을 순서대로 접근할 수 있는 Iterator 리턴 Iterator<String> it = keys.iterator(); while(it.hasNext()) { String name = it.next(); int score = javaScore.get(name); System.out.println(name + " : " + score); } HashMap의 요소 개수 :5 한원선 : 99 한홍진 : 97 황기태 : 34 이영희 : 98 정원석 : 70 출력된 결과는 삽입된 결과와 다르다는 점을 기억하기 바람

예제 7-7 HashMap을 이용한 학생 정보 저장 49 id와 전화번호로 구성되는 Student 클래스를 만들고, 이름을 ‘키’로 하고 Student 객체를 ‘값’으로 하는 해시맵을 작성하라. import java.util.*; class Student { // 학생을 표현하는 클래스 int id; String tel; public Student(int id, String tel) { this.id = id; this.tel = tel; } public class HashMapStudentEx { public static void main(String[] args) { // 학생 이름과 Student 객체를 쌍으로 저장하는 HashMap 컬렉션 생성 HashMap<String, Student> map = new HashMap<String, Student>(); // 3 명의 학생 저장 map.put("황기태", new Student(1, "010-111-1111")); map.put("한원선", new Student(2, "010-222-2222")); map.put("이영희", new Student(3, "010-333-3333")); System.out.println("HashMap의 요소 개수 :" + map.size()); // 모든 학생 출력. map에 들어 있는 모든 (key, value) 쌍 출력 // key 문자열을 가진 집합 Set 컬렉션 리턴 Set<String> names = map.keySet(); // key 문자열을 순서대로 접근할 수 있는 Iterator 리턴 Iterator<String> it = names.iterator(); while(it.hasNext()) { String name = it.next(); // 다음 키. 학생 이름 Student student = map.get(name); System.out.println(name + " : " + student.id + " " + student.tel); } HashMap의 요소 개수 :3 한원선 : 2 010-222-2222 황기태 : 1 010-111-1111 이영희 : 3 010-333-3333 출력된 결과는 삽입된 결과와 다르다는 점을 기억하기 바람

예제

Hashtable 클래스 Hashtable의 특성 Hashtable에 삽입, 검색하는 예 java.util.Hashtable Map Hashtable의 특성 java.util.Hashtable 삽입 및 검색이 빠른 특징 키(key)와 값(value) 사용 키와 값이 한쌍으로 삽입됨 키는 해쉬 테이블에 삽입되는 위치를 결정하는데 내부적으로 이용 값을 검색하기 위해서는 키를 반드시 이용함 키, 값 모두 객체만이 이용됨. 기본 데이터 타입은 사용할 수 없음 Hashtable에 삽입, 검색하는 예 Hashtable 동기화제공 Cf. HashMap Hashtable h = new Hashtable(); // Hashtable 객체 생성 h.put("apple", "사과"); // 키는 "apple"이며 값이 "사과"인 요소 삽입 String s = (String)h.get("apple"); // "apple" 키의 값을 검색. s는 "사과"

Hashtable의 내부 구성과 put(), get() 메소드 key 테이블 value 테이블 key value "love" "사랑" "apple" "사과" put(key,value) "apple" "사과" key "apple" get(key) value "baby" "아기" "사과" ?

Hashtable 클래스의 주요 메소드 메소드 설명 void clear() Hashtable의 모든 키 삭제 boolean contains(Object o) Hashtable의 어떤 키가 지정된 객체에 매핑되면 true 반환 boolean containsKey(Object key) Hashtable이 지정된 키를 포함하고 있으면 true 반환 boolean containsValue(Object value) Hashtable이 하나 이상의 키를 지정된 값에 매핑시킬 수 있으면 true 반환 Enumeration<V> elements() Hashtable의 모든 값의 enumeration 반환 V get(Object key) 지정된 키에 맵핑되는 값을 반환하거나 맵핑되는 값이 없으면 null을 반환 boolean isEmpty() Hashtable에 키가 없으면 true 반환 Enumeration<K> keys() Hashtable의 모든 키의 enumeration 반환 V put(K key, V value) Hashtable에 key를 value에 매핑 V remove(Object key) 지정된 키와 이에 매핑된 모든 값들을 Hashtable에서 삭제 int size() Hashtable이 포함하는 키의 개수 반환

예제 : Hashtable 내의 모든 값 알아내기 다음 코드에 대한 결과는 무엇인가? import java.util.*; public class HashtableEx { public static void main(String [] args) { Hashtable<String, String> h = new Hashtable<String,String>(); // 디폴트 용량 11의 Hashtable 생성 h.put("21", "홍길동"); h.put("54", "황기태"); h.put("76", "이소룡"); h.put("123", "해리슨포드"); System.out.println("Hashtable의 키 개수 : "+h.size()); // 키의 개수 Enumeration e = h.keys(); // Hashtable의 모든 키들을 얻어옴 while(e.hasMoreElements()) { String key = (String)e.nextElement(); // 키 String value = (String)h.get(key); // 키에 매핑된 값 System.out.println(key + ":" + value); } Hashtable의 키 개수 : 4 76:이소룡 123:해리슨포드 21:홍길동 54:황기태

예제 8-5 : Hashtable 검색 Scanner 클래스를 이용하여 이름, 전화번호를 입력받아 이름을 키로 하여 해시테이블에 저장하고 이름으로 전화번호를 검색하는 프로그램을 작성하라. import java.util.*; public class HashTableExample { public static void main(String[] args) { Hashtable members = new Hashtable(); Scanner sin = new Scanner(System.in); System.out.println("공백으로 분리된 이름과 전화번호 5개를 입력하십시오."); for (int i = 0; i < 5; i++) { System.out.print("이름, 전화번호 : "); String name = sin.next(); // 이름 입력 String tel = sin.next(); // 전화번호 입력 members.put(name, tel); // 이름이 키, 전화번호를 값으로 Hashtable에 저장 } System.out.println("전화번호를 검색할 이름을 입력하십시오."); String key = sin.next(); // 키인 이름 입력 String val = (String)members.get(key); // 키로 매핑된 전화번호 검색 if (val != null) System.out.println(key + "의 전화번호는 " + val + "입니다."); else System.out.println("입력하신 이름을 찾을 수 없습니다.");

LinkedList 클래스 LinkedList의 특성 java.util.LinkedList List 인터페이스를 구현한 클래스 Collection List Queue LinkedList의 특성 java.util.LinkedList List 인터페이스를 구현한 클래스 Vector, ArrayList 클래스와 매우 유사 요소 객체들은 양방향으로 연결되어 관리됨 요소 객체는 맨 앞, 맨 뒤에 추가 가능 요소 객체는 인덱스를 이용하여 중간에 삽입 가능 맨 앞이나 맨 뒤에 요소를 추가하거나 삭제할 수 있어 스택이나 큐로 사용 가능 LinkedList

LinkedList<String>의 내부 구성과 add(), get() 메소드 58 LinkedList<String> l = new LinkedList<String>();

연결리스트 Linked List 이중 연결 리스트로 구현됨 ArrayList와 사용방법 거의 동일 거의 동일한 메소드가 정의되어 있으며 효과도 동일 LinkedList 에만 추가된 메소드 addFirst(), getFirst(), removeFirst(), removeLast(), addLast(), getLast() ArrayList 를 생성할 시에는 initial capacity를 미리 지정할 수 있는 생성자가 존재하지만(default : 10) LinkedList에는 그러한 생성자가 없다. 그렇다면 ArrayList와 LinkedList 중 어느 것을 사용하는 것 이 좋은 것인가?

ArrayList vs. LinkedList 내부 구현 특징 ArrayList: 메모리에 데이터가 일렬로 붙어 있음 LinkedList: 메모리상 위치는 떨어져 있지만 포인터에 의해 연결 되어 있음 공간적인 측면 ArrayList는 10개의 공간을 initial capacity로 지닌 이후에 2배씩 늘림. 그러므로, 공간의 낭비가 어느 정도 있음 LinkedList는 실행 시 필요에 따라 새로운 원소를 위한 공간을 생 성하므로 공간이 절약됨 접근 속도 측면 (단순 읽기) ArrayList는 인덱스와 함께 원소가 저장되는 구조이기 때문에 접근이 빠름 LinkedList는 어떤 원소에 접근하기 위하여 맨 처음부터 따라가서 찾 아야 하는 어려움이 있음

ArrayList vs. LinkedList 삭제와 삽입 측면 ArrayList는 삽입시에는 오른쪽 밀림(Shift Right) 연산이 일어나고 삭제시에는 왼쪽 밀림(Shift Left) 연산이 필요하므로 효율이 좋지 않 음 LinkedList는 인접 노드의 포인터만 변경하면 되기 때문에 삭제와 삽 입 시간 면에서 유리 A B C D E 1 2 3 4 5 N

ArrayList vs. LinkedList 어떤 자료구조? 검색위주이면 ArrayList가 유리 삽입 삭제 위주라면 LinkedList가 유리 최대 데이터 수가 예측 불가라면 LinkedList가 유리

Vector, ArrayList, LinkedList???

예제

배열을 리스트로 변환하기 List를 일반 배열 자료로 변경하기 일반 배열 자료를 List로 변경하기 String[] stringArray = list.toArray(new String[list.size()]); 위에서 toArray의 파라미터로 String 타입의 비어있는 배열 객체를 넣어주어 toArray 메소드로 하여금 만들어야 할 배열의 정확한 타입 과 원소 개수를 알도록 해준다. 일반 배열 자료를 List로 변경하기 List<String> list = Arrays.asList(new String[size]); 일반적인 배열을 리스트로 변환한다. String[] stringArray = {"AAA", "BBB", "CCC", "DDD"}; List<String> list = Arrays.asList(stringArray);

집합(Set ) 집합(Set)은 원소의 중복을 허용하지 않는다. Collection Set HashSet 순서에 상관없이 원소 저장 중복을 허용하지 않음 List 계열 보다는 호출 가능 메소드의 개수가 적음 Collection 인터페이스에 정의된 정도의 메소드만 지원 대표적인 메소드 add(Object o) contains(Object o) isEmpty() remove(Object o) size() iterator() toArray(Object[] a)

Set 인터페이스를 구현하는 방법 HashSet TreeSet LinkedHashSet 해쉬 테이블과 연결 리스트를 결합한 것으로 원소들의 순서는 삽 입되었던 순서와 같다.

예제 순서가 일정하지 않다!

대량 연산 메소드 위에서 addAll, retainAll, removeAll 메소드는 원집합인 s1을 변경한다.

예제

Collections 클래스 활용 Collections 클래스 java.util 패키지에 포함 컬렉션에 대해 연산을 수행하고 결과로 컬렉션을 반환 주요 메소드 컬렉션에 포함된 요소들을 소팅하는 sort() 메소드 Collections.sort(List list) 요소의 순서를 반대로 하는 reverse() 메소드 Collections.reverse(List list) 요소들의 최대, 최소값을 찾아내는 max(), min() 메소드 특정 값을 검색하는 binarySearch() 메소드 Collections.binarySearch(List list, Object key) 자료 썪기 shuffle() 메소드 Collections.shuffle(List list, Random rnd) 모두 static 메소드

예제 7-8 : Collections 클래스의 활용 72 Collections 클래스를 활용하여 문자열 정렬, 반대로 정렬, 이진 검색 등을 실행하는 사례를 살펴보자. import java.util.*; public class CollectionsEx { static void printList(LinkedList<String> l) { Iterator<String> iterator = l.iterator(); while (iterator.hasNext()) { String e = iterator.next(); String separator; if (iterator.hasNext()) separator = "->"; else separator = "\n"; System.out.print(e+separator); } public static void main(String[] args) { LinkedList<String> myList = new LinkedList<String>(); myList.add("트랜스포머"); myList.add("스타워즈"); myList.add("매트릭스"); myList.add(0,"터미네이터"); myList.add(2,"아바타"); Collections.sort(myList); // 요소 정렬 printList(myList); // 정렬된 요소 출력 Collections.reverse(myList); // 요소의 순서를 반대로 printList(myList); // 요소 출력 int index = Collections.binarySearch(myList, "아바타") + 1; System.out.println("아바타는 " + index + "번째 요소입니다."); } static 메소드이므로 클래스 이름으로 바로 호출 소팅된 순서대로 출력 매트릭스->스타워즈->아바타->터미네이터->트랜스포머 트랜스포머->터미네이터->아바타->스타워즈->매트릭스 아바타는 3번째 요소입니다. 거꾸로 출력

Collection 클래스 Collections 클래스 사용 정렬 예제 1 import java.util.*; Sort.java import java.util.*; public class Sort { public static void main(String[] args) { String[] sample = { "i", "walk", "the", "line" }; List<String> list = Arrays.asList(sample); // 배열을 리스트로 변경 Collections.sort(list); System.out.println(list); } 역순정렬: Collections.sort(list,Collections.reverseOrder()) [i, line, the, walk]

Collection 클래스 Collections 클래스 사용 정렬 예제 2-1 기초타입, String 외 객체 SortTest.java import java.util.*; class Student implements Comparable<Student> { int number; String name; public Student(int number, String name) { this.number = number; this.name = name; } public String toString() { return name; public int compareTo(Student s) { return number - s.number; public interface Comparable<T> { public int compareTo(T o); } // java.lang.Comparable 인터페이스 public int compareTo(Student s) { return name.compareTo(s.name); } 이름으로 정렬

Collection 클래스 Collections 클래스 사용 예제 2-2 SortTest.java public class SortTest { public static void main(String[] args) { Student array[] = { new Student(20090002, "이철수"), new Student(20090001, "김철수"), new Student(20090003, "박철수") }; List<Student> list = Arrays.asList(array); Collections.sort(list); System.out.println(list); } [김철수, 이철수 , 박철수] // 번호순 이름으로!!!!

Collection 클래스 Collections 클래스 사용 : 섞기 예제 3 Shuffle.java import java.util.*; public class Shuffle { public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); for (int i = 1; i <= 10; i++) list.add(i); Collections.shuffle(list, new Random(System.currentTimeMillis())); System.out.println(list); }

Collection 클래스 : 탐색하기 Collections 클래스 사용 탐색 예제 4 Search.java import java.util.*; public class Search { public static void main(String[] args) { int key = 50; List<Integer> list = new ArrayList<Integer>(); for (int i = 0; i < 100; i++) list.add(i); int index = Collections.binarySearch(list, key); System.out.println("탐색의 반환값 =" + index); } 탐색의 반환값 =50

Collection 클래스 Collections 클래스의 다른 메소드 Object min(Collection coll), Object max(Collection coll) 컬렉션에서 최대값과 최소값을 찾는다. void reverse(List list) list 원소들의 순서를 반대로 바꾼다. void fill(List list, Object obj) list에 지정된 obj로 원소를 채운다. void copy(List dest, List src) src리스트의 원소들을 dest 리스트에 복사한다. void swap(List list, int i, int j) list의 지정된 두 위치의 원소를 바꾼다.

JDK 1.5 이전 자바의 컬렉션 문제점 삽입되는 원소 객체는 사실 모두 Object 타입이어야 함 int, double 등의 기본 타입 데이타는 직접 삽입될 수 없음 객체를 컬렉션에서 꺼내올 때 다운 캐스팅 필요 Object 타입에서 실제 클래스 타입으로의 다운 캐스팅 불편 public class VectorEx { public static void main(String [] args) { Vector v = new Vector(); v.add("Hello"); v.add(new Integer(3)); v.add(new Person()); int n = v.size(); // n은 3 for(int i=0; i<n; i++) { if(v.get(i) instanceof string) String s = (String)v.get(i); else if(v.get(i) instanceof Integer) int n = ((Integer)v.get(i)).intValue(); else if(v.get(i) instanceof person) Person p = (Person)v.get(i); } String s = v.get(i); // 컴파일 오류 Vector에 들어 있는 요소의 실제 타입으로 다운 캐스팅을 해야 하는 문제

JDK 1.5 이전 버전의 Vector 클래스의 예 JDK 1.5 이전 버전의 Vector 클래스 예제 http://download.oracle.com/javase/1.4.2/docs/api/java/util/Vector .html참조 제네릭 도입 이전에는 Object 클래스를 이용하여 모든 객체들을 참조 JDK 1.5이전 Vector는 Object를 요소로 받아 들임 3번 행의 다운 캐스팅이 반드시 필요하며 이 부분이 문제를 발생시킨 다. 컴파일러는 elementAt이 Object 타입을 반환할 것이라는 밖에는 알지 못하므로 프로그래머가 명시적으로 타입을 지정하여야 한다. 규모가 큰 프로그램의 작성 시 프로그래머가 타입을 실수로 잘못 지정 하는 경우에는 런타임에 ClassCastException이 발생 제네릭을 이용하면 컴파일러가 요소의 타입을 알 수 있어 타입 불일치 를 방지  Type safe 특성 1: Vector myVector = new Vector(); 2: myVector.add(new Integer(0)); 3: Integer x = (Integer) myVector.elementAt(0);

제네릭 만들기 제네릭 클래스와 인터페이스 클래스나 인터페이스 선언부에 일반화된 타입 추가 제네릭 클래스 레퍼런스 변수 선언 81 제네릭 클래스와 인터페이스 클래스나 인터페이스 선언부에 일반화된 타입 추가 제네릭 클래스 레퍼런스 변수 선언 public class MyClass<T> { T val; void set(T a) { val = a; } T get() { return val; 제네릭 클래스 MyClass 선언, 타입 매개 변수 T val의 타입은 T T 타입의 값 a를 val에 지정 T 타입의 값 val 리턴 MyClass<String> s; List<Integer> li; Vector<String> vs;

제네릭 객체 생성 – 구체화(specialization) 82 구체화 제네릭 타입의 클래스에 구체적인 타입을 대입하여 객체 생성 컴파일러에 의해 이루어짐 구체화된 MyClass<String>의 소스 코드 MyClass<String> s = new MyClass<String>(); // 제네릭 타입 T에 String 지정 s.set("hello"); System.out.println(s.get()); // "hello" 출력 MyClass<Integer> n = new MyClass<Integer>(); // 제네릭 타입 T에 Integer 지정 n.set(5); System.out.println(n.get()); // 숫자 5 출력 public class MyClass<T> { T val; void set(T a) { val = a; } T get() { return val; public class MyClass<String> { String val; // 변수 val의 타입은 String void set(String a) { val = a; // String 타입의 값 a를 val에 지정 } String get() { return val; // String 타입의 값 val을 리턴 T가 String 으로 구체화

구체화 오류 타입 매개 변수에 기본 타입은 사용할 수 없음 83 타입 매개 변수에 기본 타입은 사용할 수 없음 Vector<int> vi = new Vector<int>(); // 컴파일 오류. int 사용 불가 수정 Vector<Integer> vi = new Vector<Integer>(); // 정상 코드

타입 매개 변수 타입 매개 변수 ‘<‘과 ‘>’사이에 하나의 대문자를 타입 매개 변수로 사용 84 타입 매개 변수 ‘<‘과 ‘>’사이에 하나의 대문자를 타입 매개 변수로 사용 많이 사용하는 타입 매개 변수 문자 E : Element를 의미하며 컬렉션에서 요소를 표시할 때 많이 사용한 다. T : Type을 의미한다. V : Value를 의미한다. K : Key를 의미 타입 매개변수가 나타내는 타입의 객체 생성 불가 ex) T a = new T(); 타입 매개 변수는 나중에 실제 타입으로 구체화 어떤 문자도 매개 변수로 사용 가능 컴파일 오류 타입매개변수는 컴파일 때만 존재 실행시간에 타입매개변수에 대한 객체를 생성불가(예제7.9 참조)

예제 7-9 : 제네릭 스택 만들기 85 스택을 제네릭 클래스로 작성하고, String과 Integer형 스택을 사용하는 예를 보여라. class GStack<T> { int tos; Object [] stck; public GStack() { tos = 0; stck = new Object [10]; } public void push(T item) { if(tos == 10) return; stck[tos] = item; tos++; public T pop() { if(tos == 0) return null; tos--; return (T)stck[tos]; public class MyStack { public static void main(String[] args) { GStack<String> stringStack = new GStack<String>(); stringStack.push("seoul"); stringStack.push("busan"); stringStack.push("LA"); for(int n=0; n<3; n++) System.out.println(stringStack.pop()); GStack<Integer> intStack = new GStack<Integer>(); intStack.push(1); intStack.push(3); intStack.push(5); System.out.println(intStack.pop()); } LA busan seoul 5 3 1 85

제네릭과 배열 제네릭에서 배열의 제한 제네릭 클래스 또는 인터페이스의 배열을 허용하지 않음 86 제네릭에서 배열의 제한 제네릭 클래스 또는 인터페이스의 배열을 허용하지 않음 제네릭 타입의 배열 생성도 허용되지 않음 앞 예제에서는 Object 타입으로 배열 생성 후 실제 사용할 때 타입 캐스팅 타입 매개변수의 배열에 레퍼런스는 허용 GStack<Integer>[] gs = new GStack<Integer>[10]; T[] a = new T[10]; return (T)stck[tos]; // 타입 매개 변수 T타입으로 캐스팅 public void myArray(T[] a) {....}

제네릭 메소드 87 제네릭 메소드 선언 가능 제네릭 메소드를 호출할 때는 컴파일러가 메소드의 인자를 통해 이미 타입을 알고 있으므로 타입을 명시하지 않아도 됨 sa는 String[], gss는 GStack<String> 타입이므로 T를 String으로 유추 class GenericMethodEx { static <T> void toStack(T[] a, GStack<T> gs) { for (int i = 0; i < a.length; i++) { gs.push(a[i]); } String[] sa = new String[100]; GStack<String> gss = new GStack<String>(); GenericMethodEx.toStack(sa, gss); // 타입 매개 변수 T를 String 으로 유추함

예제 7-10 : 스택의 내용을 반대로 만드는 제네릭 메소드 만들기 88 예제 7-9의 GStack을 이용하여 주어진 스택의 내용을 반대로 만드는 제네릭 메소드 reverse()를 작성하라. public class GenericMethodExample { // T가 타입 매개 변수인 제네릭 메소드 public static <T> GStack<T> reverse(GStack<T> a) { GStack<T> s = new GStack<T>(); while (true) { T tmp; tmp = a.pop(); // 원래 스택에서 요소 하나를 꺼냄 if (tmp==null) // 스택이 비었음 break; else s.push(tmp); // 새 스택에 요소를 삽입 } return s; // 새 스택을 반환 public static void main(String[] args) { // Double 타입의 GStack 생성 GStack<Double> gs = new GStack<Double>(); // 5개의 요소를 스택에 push for (int i=0; i<5; i++) { gs.push(new Double(i)); } gs = reverse(gs); System.out.println(gs.pop()); 0.0 1.0 2.0 3.0 4.0

제네릭의 장점 컬렉션과 같은 컨테이너 클래스에 유연성을 해치지 않으며 type- awareness를 첨가 89 컬렉션과 같은 컨테이너 클래스에 유연성을 해치지 않으며 type- awareness를 첨가 메소드에 type-awareness 첨가 컴파일 시에 타입이 결정되어 보다 안전한 프로그래밍 가능 개발 시 다운캐스팅(타입 캐스팅) 절차 불필요 런타임 타입 충돌 문제 방지 ClassCastException 방지  무인자 자료형은 사용하면 안된다. 컴파일 타임에서 타입 안정성을 보장할수 없다. 

LAB. #1 1. 카드 게임 프로그램을 컬렉션 라이브리를 이용하여 작성하라. 카드를 나타내는 Card 클래스를 작성한다. 하나의 카드는 무늬(suit)와 숫자(number)를 가진다. 생성자, ToString 메소드 정의하라. 카드 데크를 나타내는 CardDeck 클래스를 작성하라. CardDeck은 총 52 개의 Card 객체를 저장하여야 한다. ArrayList를 사용하여 카드들을 저장하라. 생성자에서 모든 카드를 생성하라. (3) CardDeck 클래스에 카드를 섞는 메소드 shuffle()을 콜렉션 클래스의 정적메소드 shuffle()을 이용하여 정의하라. (4) CardDeck 클래스에 Deck의 처음에서 카드를 제거하여서 반환하는 메소드인 deal()을 작성하라. (5) 카드 경기자를 나타내는 Player 클래스를 구현하라. Player 클래스도 카드의 리스트를 가져야 한다.(ArrayList 사용할 것) (6) Player는 카드를 얻어서 자신의 리스트에 추가하는 메소드 getCard()를 정의하라. 또한 자신의 카드를 보여주는 showCards() 메소드를 작성하라. (7) main() 함수를 가지는 클래스 CardGame을 작성하라. CardDeck 클래스의 객체를 생성하고, Deck의 카드를 섞은 다음 Player 객체를 두 명 생성한다. 카드를 7장 씩 분배하고 각자의 카드를 화면에 표시하라.

1. 카드를 나타내는 Card 클래스를 작성한다. 하나의 카드는 무늬(suit)와 숫자(number)를 가진다 1. 카드를 나타내는 Card 클래스를 작성한다. 하나의 카드는 무늬(suit)와 숫자(number)를 가진다. 생성자, ToString 메소드 정의하라. class Card { String suit; // 무늬 String number; // 숫자 public Card(String suit, String number) { // 생성자 ________ = suit; ________ = number; } public String toString() { return _______________;

2. 카드 데크를 나타내는 CardDeck 클래스를 작성하라. CardDeck은 총 52 개의 Card 객체를 저장하여야 한다. ArrayList를 사용하여 카드들을 저장하라. 생성자에서 모든 카드를 생성하라. class CardDeck { ArrayList<Card> deck = new ___________; public CardDeck() { String[] suit = {"Clubs", "Diamond", "Hearts", "Spades"}; String[] number = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"}; for (int i = 0; i < suit.length; i++) for (int j = 0; j <number.length; j++) ________________________; } // 52장의 카드를 deck ArrayList에 add

3. CardDeck 클래스에 카드를 섞는 메소드 shuffle()을 콜렉션 클래스의 정적메소드 shuffle()을 이용하여 정의하라. 4. CardDeck 클래스에 Deck의 처음에서 카드를 제거하여서 반환하는 메소드인 deal()을 작성하라. public void shuffle () { Collections._______________; } public Card deal() { return __________________;

5. 카드 경기자를 나타내는 Player 클래스를 구현하라. Player 클래스도 카드의 리스트를 가져야 한다 5. 카드 경기자를 나타내는 Player 클래스를 구현하라. Player 클래스도 카드의 리스트를 가져야 한다.(ArrayList 사용할 것) 6. Player는 카드를 얻어서 자신의 리스트에 추가하는 메소드 getCard()를 정의하라. 또한 자신의 카드를 보여주는 showCards() 메소드를 작성하라. class Player { _________________________; // Card의 리스트 변수 list생성 public void getCard(Card card) { list._____(card); } public void showCards() { // list 출력 _________________;

7. main() 함수를 가지는 클래스 CardGame을 작성하라 7. main() 함수를 가지는 클래스 CardGame을 작성하라. CardDeck 클래스의 객체를 생성하고, Deck의 카드를 섞은 다음 Player 객체를 두 명 생성한다. 카드를 7장 씩 분배하고 각자의 카드를 화면에 표시하라. public class CardGame { public static void main(String[] args) { CardDeck deck = new CardDeck(); ___________; // deck 카드 섞기 호출 Player p1 = new Player(); Player p2 = new Player(); for (int i = 0; i < 7; i++) { _________________; // p1에게 카드 돌리기 } p1.showCards(); p2.showCards(); [Clubs : 9, Clubs : 6, Clubs : Queen, Diamond : 6, Hearts : Queen, Spades : King, Spades : 3] [Diamond : 2, Clubs : 2, Hearts : Jack, Hearts : King, Spades : 6, Clubs : 7, Hearts : Ace]

private static String getHandValue(Player hand){. if(hand private static String getHandValue(Player hand){ if(hand.isRoyalFlush() == true) return "Royal Flush"; if(hand.isStraightFlush() == true) return "Straight Flush"; if(hand.isFourOfAKind() == true) return "Four of a Kind"; if(hand.isFullHouse() == true) return "Full House"; if(hand.isFlush() == true) return "Flush"; if(hand.isStraight() == true) return "Straight"; if(hand.isThreeOfAKind() == true) return "Three of a Kind"; if(hand.isTwoPair() == true) return "Two Pair"; if(hand.isPair() == true) return "Pair"; return "Nothing"; }

import java.util.ArrayList; LAB. 2 : BankAccount 확장 ArrayList<BankAccount> accounts = new ArrayList<BankAccount>(); import java.util.ArrayList;

Big Java by Cay Horstmann import java.util.ArrayList; /** This bank contains a collection of bank accounts. */ public class Bank { Constructs a bank with no bank accounts. public Bank() accounts = new ArrayList<BankAccount>(); } Adds an account to this bank. @param a the account to add public void addAccount(BankAccount a) accounts.add(a); Bank.java Big Java by Cay Horstmann Copyright © 2008 by John Wiley & Sons. All rights reserved.

Big Java by Cay Horstmann Bank.java /** Gets the sum of the balances of all accounts in this bank. @return the total balance */ public double getTotalBalance() { double total = 0; for (BankAccount a : accounts) total = total + a.getBalance(); } return total; Big Java by Cay Horstmann Copyright © 2008 by John Wiley & Sons. All rights reserved.

Big Java by Cay Horstmann Bank.java /** Counts the number of bank account whose balance is at least a given value. @param atLeast the balance required to count an account @return the number of accounts having least the given balance */ public int count(double atLeast) { int matches = 0; for (BankAccount a : accounts) if (a.getBalance() >= atLeast) matches++; // found a match } return matches; Big Java by Cay Horstmann Copyright © 2008 by John Wiley & Sons. All rights reserved.

Big Java by Cay Horstmann Bank.java /** Finds a bank account with a given number. @param accountNumber the number to find @return the account with the given number, or null if there is no such account */ public BankAccount find(int accountNumber) { for (BankAccount a : accounts) if (a.getAccountNumber() == accountNumber) // found a match return a; } return null; // no match in the entire array list Big Java by Cay Horstmann Copyright © 2008 by John Wiley & Sons. All rights reserved.

Big Java by Cay Horstmann Bank.java /** Gets the bank account with the largest balance. @return the account with the largest balance, or null if the bank has no accounts */ public BankAccount getMaximum() { if (accounts.size() == 0) return null; BankAccount largestYet = accounts.get(0); for (int i = 1; i < accounts.size(); i++) BankAccount a = accounts.get(i); if (a.getBalance() > largestYet.getBalance()) largestYet = a; } return largestYet; Big Java by Cay Horstmann Copyright © 2008 by John Wiley & Sons. All rights reserved.

Bank.java /** Add an account to the bank. @param accountNumber the account number of this account @param initialBalance the initial balance of this account */ public void addAccount(int accountNumber, double initialBalance) { . . .// account에 add 메소드 이용하여 새 bankAccount 객체추가 } Deposit money into an account. @param accountNumber the account number @param amount the amount to be deposited public void deposit(int accountNumber, double amount) . . . // find 메소드 이용하여 BankAccount 객체 찾은 다음 deposit 호출

Bank.java /** Withdraw money from an account. @param accountNumber the account number @param amount the amount to be withrawn */ public void withdraw(int accountNumber, double amount) { . . . // find 메소드 이용하여 BankAccount 객체 찾은 다음 withdraw 호출 } Get an account balance @return the account balance public double getBalance(int accountNumber) . . . // find 메소드 이용하여 BankAccount 객체 찾은 다음 getBalance 호출 private ArrayList<BankAccount> accounts; Bank.java

BankAccount.java /** A bank account has a balance that can be changed by deposits and withdrawals. */ public class BankAccount { Constructs a bank account with a zero balance. @param anAccountNumber the account number for this account public BankAccount(int anAccountNumber) accountNumber = anAccountNumber; balance = 0; } Big Java by Cay Horstmann Copyright © 2008 by John Wiley & Sons. All rights reserved.

BankAccount.java /** Constructs a bank account with a given balance. @param anAccountNumber the account number for this account @param initialBalance the initial balance */ public BankAccount(int anAccountNumber, double initialBalance) { accountNumber = anAccountNumber; balance = initialBalance; } Gets the account number of this bank account. @return the account number public int getAccountNumber() return accountNumber;

Big Java by Cay Horstmann BankAccount.java /** Deposits money into the bank account. @param amount the amount to deposit */ public void deposit(double amount) { double newBalance = balance + amount; balance = newBalance; } Withdraws money from the bank account. @param amount the amount to withdraw public void withdraw(double amount) double newBalance = balance - amount; Big Java by Cay Horstmann Copyright © 2008 by John Wiley & Sons. All rights reserved.

/** BankAccount.java Gets the current balance of the bank account. @return the current balance */ public double getBalance() { return balance; } private int accountNumber; private double balance;

BankTester.java /** This program tests the Bank class. */ public class BankTester { public static void main(String[] args) Bank bank = new Bank(); int dannysAccount = 0; int sallysAccount = 1; int harrysAccount = 2; int jerrysAccount = 3; bank.addAccount(dannysAccount, 1000); bank.addAccount(sallysAccount, 2000); bank.addAccount(harrysAccount, 3000); bank.addAccount(jerrysAccount, 10000);

bank.deposit(dannysAccount, 200); bank.withdraw(sallysAccount, 500); bank.deposit(harrysAccount, 1000); bank.withdraw(jerrysAccount, 7000); System.out.println( "Danny's Account Balance: " + bank.getBalance(dannysAccount)); System.out.println("Expected: 1200"); "Sally's Account Balance: " + bank.getBalance(sallysAccount)); System.out.println("Expected: 1500"); "Harry's Account Balance: " + bank.getBalance(harrysAccount)); System.out.println("Expected: 4000"); "Jerry's Account Balance: " + bank.getBalance(jerrysAccount)); System.out.println("Expected: 3000"); }

Q & A