12장 Collection FrameWork Generics

for문 연습하기

1.

ArrayList<String> fruits = new ArrayList<>();

fruits.add("Apple"); fruits.add("Banana"); fruits.add("Orange");

for (String fruit : fruits)

{

System.out.println(fruit);

// Apple // Banana // Orange

}

 

2.

int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers)

{ System.out.println(number); }

 

3.

String message = "Hello, world!";

for (char ch : message.toCharArray())

{ System.out.println(ch); }

 

4.

int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

for (int[] row : matrix) {

for (int element : row) {

System.out.println(element);

} }

 

4.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {

System.out.println(name);

}

 

 

컬렉션 : 요소 객체들의 저장소

컬렉션 프레임웍의 인터페이스

인터페이스와 클래스                                                                          

Collection <E>			Map<K,V>
Set<E>	List<E>	Queue<E>
HashSet<E>	ArrayList<E> Vector<E>    Stack<E>    LinkedList<E>	LinkedList<E>	HashMap<K,V>

 

컬렉션의 요소는 객체만 가능 

컬렉션의 제네릭 기법으로 구현됨

지네릭스: 특정타입만을 다루지않고 여러종류의 타입으로 변신할 수 있도록 클래스나 메소드를 일반화시키는 기법
컴파일시 타입을 체크해주는 기능
객체의 타입안정성을 높이고 형변환의 번거로움을 줄여줌
ClassCastException 방지
컴파일에러가 실행시 발생하는 에러보다 더 낫다, 런타임 방
String str = null;
String str ="";  // 빈문자열 nullpointerException덜 발생하려고

Object[] objArr = null;
Objecgt [] objArr = new Object[0]; // 길이가 0인 배열

타입 변수 : 지네릭 클래스를 작성할때 Object 타입대신 타입변수 E / T를 선언해서 사용
객체 생성시 타입 변수 E 대신 실제 타입 Tv를 지정대입
ArrayList<Tv> tvList = new ArrayList<Tv>();

public class MyClass<T>
{
T val;
void set(T a){
val = a;
}

T get(){
return val;
}
}

MyClass<String> s = new MyClass<String>();
s.set("hello");
System.out.println(s.get());

class Box <T> {}   // 지네릭 클래스 선언
Box:  원시 타입
T : 타입 (매개)변수

Box <T> : 지네릭 클래스

Box <String> b = new Box <String> ();

String: 매개변수화된 타입, 대입된 타입

Box<String> : 지네릭 타입 호출

1. 참조변수와 생성자의 대입된 타입은 일치해야한다

ArrayList<Tv> list = new ArrayList<Tv>();

2. 지네릭 클래스간 다형성은 성립한다.
       List <Tv> list = new ArrayList<Tv>();

 

3. 매개변수의 다형성도 성립한다.
ArrayList<Product> list = new ArrayList<Product>();

boolean add(E e){ }
list.add(new Product()); //Product와
list.add(new Tv()); //그 자손 객체 가능
list.add(new Audio());

E get(int index){}

Product p = list.get(0);

Tv t = (Tv) list.get(1);//이건 형변환 해주기

4. 제네릭 클래스 또는 인터페이스의 배열을 허용하지않는다

5. 제네릭 타입의 배열도 허용하지않는다

Object로 배열생성후 실제 사용할때 타입캐스팅

 

6. static<T> void toStack(T[] a, GStack<T> gs)

 

Stack<E> 클래스

Stack<E> myStack = new Stack<E> ();

Boolean empty()         //스택이 비었는

E peek()                    //맨위 저장된 객체 반환

E pop()                     //삭제

E push(E item)         //추가  push(String item) System.out.println(a.push("55")); // 55

int search(E item)     //못찾으면 -1 배열의 위치가 0이아닌 1부터 시작 System.out.println(a); //[1st, 2nd, 5th] System.out.println(a.search("1st")); //3 System.out.println(a.search("2nd"));//2 System.out.println(a.search("5th")); //1 스택의 맨위에 있으므로

 

Vector<E> 클래스 - 순서 있음 중복 있음 List<E> 구현

멀티쓰레드에대한 동기화 제공 thread safe , 호환성을 위해 남아있음

Vector<Integer> v = new Vector<integer>();

boolean add(E element) void add(index, E element) boolean contains(E element) //true리턴

E get(int index)   E elementAt(int index) int indexOf(E element) // element와 같은 첫번째 요소의 인덱스리턴, 없으면 -1

int capacity() int size()

void clear()  E remove (int index) void removeAllElements() boolean isEmpty()

E [] toArray()

 

컬렉션을 매개변수로 받기

public void printVector(Vector<Integer> v){

}

 

 

 

 

 

ArrayList<E> 클래스 - 순서 있음 중복 있음 List<E> 구현

멀티쓰레드에 대한 동기화를 제공하지않음 -> 외부동기화 개체나 static List Collections.synchronizedList(List list)를 사용할 수 있음

빠름 , ArrayList사용하는 것이 좋음

 

ArrayList <String> a = new ArrayList<String>();

boolean add(E element) void add(index, E element) boolean contains(E element) //true리턴 boolean addAll (Collection<? extends E> c )  //c의 모든 요소를 ArrayList 의 맨뒤에 추가

int size() capacity메소드는 없음

void clear()  E remove (int index)                         //    System.out.print(v.remove(0));//5 void removeAllElements() boolean isEmpty()

E get(int index)   E elementAt(int index) int indexOf(E element)                 // element와 같은 첫번째 요소의 인덱스리턴, 없으면 -1

E [] toArray()

 

 

컬렉션의 순차적인 검색을 위한 , 저장된 요소를 접근하는데 사용되는 인터페이스

iterator()  - Collection<E>인터페이스에 명시됨

인덱스없이 순차탐색 가능

Iterator<E> 객체에서 사용하는 method

boolean hasNext()     // 방문할 요소가 있다면 true 리

E next()                     // 다음 요소 리턴

void remove()            //마지막으로 리턴된 요소 제거

package Generics;

import java.util.Iterator;
import java.util.Vector;

public class Ex7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector<Integer> v = new Vector<>();
		v.add(5);
		v.add(-10);
		v.add(-565);
		v.add(89);
		
		/*Iterator<Integer> it = v.iterator();
		while(it.hasNext()) {
			if(it.next()<0) {
				it.remove();
			}
		}*/
		
		for(int i=0;i<v.size();i++) {
			if(v.get(i)<0) {
				v.remove(i);
			}
		}
		
		System.out.println("after"+ v);//after[5, -565, 89]
	}

}

LinkedList <E> p600

요소객체들은 양방향으로 연결되어 관리됨

 

 

HashMap<K,V> - 순서유지X  키 중복 X   값 중복 O

키 : 값을 검색하기위해 키를 사용

값 :

void clear() V remove (Object key)         // 키를 통해 요소를 삭제함 ,근데 값을 반환 boolean isEmpty()

int size() V get(Object key)                  // 키를 통해 값을 얻

V put(K key , V value)          //키값을 삽입해서 값을 반환 Set <k> keySet()                  //해쉬맵에 저장된 모든 키가 저장된 Set을 반환

boolean containsKey(Object key) boolean containsValue(Object value)

package Generics;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Ex9 {

	public static void main(String[] args) {
		// TODO Auto-generated method 
		HashMap <String, Integer> h = new HashMap<>();
		h.put("김성동", 97);
		h.put("김성동1", 971);
		h.put("김성동2", 972);
		h.put("김성동3", 976);
		h.put("김성동4", 979);
		h.put("김성동5", 927);
		System.out.println("hashmap 의 요소 개수 "+ h.size());
		
		Set<String> keys = h.keySet();  //Set을 쓰고 <> 쓰고 객체 쓰고 keySet()불러서 해쉬맵의 저장된 모든 키!!!!!
		Iterator<String> it = keys.iterator();
		
		while(it.hasNext()) {
			String name = it.next();
			int score = h.get(name);
			
			System.out.println(name+": "+score);
		}
	}

}

 

Collections 클래스

java.util 패키지

모든 메소드는 static 타입

sort

reverse

replaceAll

shuffle

binarySearch

min , max

frequency

disjoint