Generic 제네릭

프로그램이나 변수를 선언할 때 모든 변수는 자료형이 있다. 메서드에서 매개변수를 사용할 때도 자료형을 가지고 있다. 대부분은 한의 자료형으로 구현하지만, 변수나 메서드의 자료형을 필요에 따라 여러 자료형으로 바꿀 수 있다면 프로그램이 훨씬 유연할 것이다.

이와같이 어떤 값이 하나의 참조 자료형이 아닌 여러 참조 자료형을 사용할 수 있도록 프로그래밍하는 것을 제네릭 프로그래밍이라고 한다.

제네릭 프로그램은 참조자료형이 변환할 때 이에 대한 검증을 컴파일러가 하므로 안정적인 특징이 있다.

제네릭은 개발자가 의도한 타입만 저장할 수 있어 타입을 강제하는 기능이다.

public class Emp<T>{
<T> 를 사용하여 필드에 int 와 String 모두 들어갈수 있다. 
private T empno;
private String ename;

public Emp() {
}

Collection

여러개의 값을 효과적으로 관리하는 객체, 크기가 가변

→generic을 사용하여 원하는 타입을 지정할 수 있다.

먼저 배웠던 Array와 차이점이 있다.

Array

크기가 고정되어있고 같은 타입만 가능하다.

Collection

크기가 가변적이고 여러 타입 가능.

Collection 인터페이스

ArrayList

Vector → List : 순서가 있는 자료를 관리하며 중복이 허용된다.

LinkedList

이 전체를 통틀어서 컬렉션이라고 본다=> collection

HashSet

TreeSet → Set : 순서가 정해져있지 않고 중복을 허용하지 않는다.

List : 순서가 있고, 중복이 가능하다

import java.util.ArrayList; // ArrayList를 import하여 사용한다. 
import java.util.List;

public static void main(String[] args) {
List<String> list = new ArrayList<String>();

list.add("차차");
list.add("코코");
list.add("샤넬");
list.add("영수");
list.add("영자");
} 

메소드 연습

* indexOf 
list.set(list.indexOf("차차"),"라미");
prn(list);

-> list에서 차차라는 index를 찾아 라미로 바꿔준다. 

indexOf

인자로 전달된 객체가 리스트에 존재한다면 그 인덱스를 리턴한다.

만일 존재하지 않는다면 -1을 리턴한다.

set

list. set(int index, E element)

주어진 index의 객체를 element 객체로 바꾸어준다.

System.out.println(list.indexOf("샤넬")); 
//샤넬이의 인덱스번호를 호출
System.out.println(list.indexOf("차차")); 
//차차의 인덱스는 없어서 -1을 리턴한다. -> 차차를 라미로 바꿨기때문 

*endsWith : String 메소드이다. 
for(int i = 0; i<list.size();i++){
	 if(list.get(i).endsWith("수")){ //만일 수로 끝나는 인덱스값이 있다면
			list.set(i,list.get(i).replace("수","희"));
		} 
}
prn(list);

*remove 
for(int i = 0; i<list.size();i++){
	if(list.get(i).endsWith("자"){
		list.remove(i);
	}
}
prn(list);

Vector : 가변 길이의 배열 (List를 상속받는다)

자바의 배열은 고정 길이를 사용한다. 즉 배열이 한 번 생성되면 배열의 길이를 증가하거나 감소 할 수 없다. 배열의 크기를 벗어나는 인덱스에 접근하면 오류가 발생한다. 그러므로 충분한 크기의 배열로 설정해야 하는데 사용할 배열의 크기를 가늠하는 것은 사실상 어렵다. 그래서 자바에서는 동적인 길이로 여러 데이터형을 저장하기 위해 Vector 클래스를 제공한다. Vector 클래스는 가변 길이의 배열이라고 할 수 있다.

Vector 예시

public static void main(String[] args) {
	
		
		//Vector (iCa, caIn)
		// iCa 만큼 용량을 만든다. iCa를 넘어가면 cpIn 만큼 용량 증가한다. 
		Vector<Integer> v = new Vector<Integer>(10,5);
		
		System.out.println(v.size()+" : "+v.capacity());
		//capacity 용량 처음에 지정한 10 , size 는 들어온 값에 따라 달라짐 
		for (int i = 0 ; i<9; i++) {
			v.add(i);
			System.out.println(v+ " ->"+v.size()+" : "+ v.capacity());
			
			
		}
		v.add(9);
		System.out.println(v+ " ->"+v.size()+" : "+ v.capacity());
		
		v.add(10);
		System.out.println(v+ " ->"+v.size()+" : "+ v.capacity());
		v.remove(0);
		System.out.println(v+ " ->"+v.size()+" : "+ v.capacity());

향상된 for문

배열 및 걸렉션 객체를 좀 더 쉽게 처리할 목적으로 향상된 for문을 제공한다.

이 향상된 for문 에서는 반복을 실행하기 위해 카운터 변수와 증감식을 사용하지 않는다. 알아서 배열 및 컬렉션 항목의 개수만큼 반복하고, 자동적으로 for문을 빠져나갑니다..

간단한 예제

public class AdvancedForExample { 
	public static void main(String[] args) { 
		int[] s = {2, 13, 45, 65 ,45}; 
			for(int i : s) { 
			  System.out.println(i);
  } 
 } 
}

예시

public static void main(String[] args) {
		
		Vector<String> v = new Vector<String>();
		
		v.add("홍길동");
		v.add("이순신");
		v.add("김선달");
		v.add("강호동");
		v.add("유재석");
		v.add("신동엽");
		v.add("조세호");
	
		prn(v);

public static void prn(Vector<String> vector) {
		
		//향상된 for문 (foreach)
		for(String s : vector) {  // for(a: b) b는 반복가능한 객체 a는 안에있는 값을 받을 변수 
			System.out.print(s+" ");
		}
		System.out.println();
	}

Set : 순서가 없고, 중복이 불가능하다

import java.util.HashSet;
import java.util.Set;

public class MTest01Set {
	//Set : 순서 없고 중복 불가능 
	public static void main(String[] args) {
		Set<String> set = new HashSet<String>();
		
		//list 는 내가 넣어준 순서대로 1,3,5,2,4,6,8,null 이 순서대로 가지고 있음 
		//set은 자기가 편한대로 넣었다가 편한대로 출력하는거임 정렬 xx 
		set.add("1");
		set.add("3");
		set.add("5");
		set.add("2");
		set.add("4");
		set.add("6");
		set.add("7");
		//set.add(null); 
//저장은 가능하나 실행하면 nullpointexception 오류 발생 
	  set.add("3"); // 중복 안됨 
		
		for(String s : set) {
			System.out.print(s + " ");	
		}
		System.out.println();
		
		findElement(set,"3"); // Set <String> set, STring find
		deleteElement(set,"3");//Set<String> set, String delete
		
		
	}
	public static void findElement(Set<String> set, String find) {
		//for (int i= 0; i<set.size();i++) {
			//set.get(i); 순서가 없기 떄문에 get (i) 0번지 1번지 개념이 없음 
		
		for(String s : set) {
			if(s.equals(find)) { //s 의 값 null 이 있는데 아무것도 없는 값을 equals 할 수 없음 
				System.out.println(find + "찾았따 ! ! ");
				
			}		
		}
	}
	public static void deleteElement(Set<String> set, String delete) {
		for(String s : set) {
			if(s.equals(delete)) {
				set.remove(s); // 원래 remove의 리턴타입은 boolean 이라 true , flase 값이 나오는데 그냥 true 라고 가정하고, 바로 syso 
				System.out.println(delete+"지웠따!!");
				break;
			}
		}
		System.out.println(set);
	}
}

collection을 상속받는

List 는 순서가 있고 중복도 가능 ( list 안에 벡터)

Set 순서가 없고 중복도 불가능.

Iterator 콜렉션(list, set) 안에 있는 요소들을 가져오는 표준화된 방법

——————————————-

Map (콜렉션 상속은 아니기때문에 Iterator사용 불가능)

Mat<K,V> K를 통해 V가 하나 더 있음 k 안에 v값이 있음.

K랑 V안에는 참조타입 모두 들어갈 수 있음.

{112=112abc, 113=113abc, 114=114abc, 115=115abc, 111=111abc}

112key 안에 112abc value

{112=112abc, 113=113abc, 114=114abc, 115=115abc, 111=115abc}

key는 중복이 안돼고, value는 중복이 가능함

Map.Entry key 따로 value 따로 각각 가지고 올 수 있는 방법

Entry<K,V> 라는 객체들을 Set으로 관리한다.

Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
for(Entry<Integer, String> entry : entrySet) {
			System.out.printf("%d : %s\n",entry.getKey(),entry.getValue());

>> Entry를 가진 Set 이기때문에 for 문 대신에 Iterator 사용 가능 ! 

sort 정렬 메소드 안에서 사용하는 comparable, comparator

comparable : 나(this)와 다른객체(other)

비교 클래스 내부

compareTo(Object other)

Arrays.sort(kh)

public static void main(String[] args) {
		Score[] kh = new Score[3];
		kh[0] = new Score ("코코" , 78,52,100);
		kh[1] = new Score ("샤넬", 100,100,68);
		kh[2] = new Score ("가람" , 89,40,80);
 
		for(Score student : kh) { //배열을 손쉽게 나타내는 for each 문 student라는 변수에 kh 배열을 돌린것 
			System.out.println(student);
		}
		System.out.println("--------------");
		
		//클래스의 compareTo(object other)과 함께 사용된다 
		Arrays.sort(kh);  // sort정렬 메소드 안에서 배열 안에 있는 객체들을 비교해줌 
		//comparable 나와 다른 객체를 비교해준다. 
		System.out.println("--------------");
		
		for(Score student : kh) {
			System.out.println(student);
		}
	}

public class Score implements Comparable<Object>{
 블라블라블라~~ 

@Override
	public int compareTo(Object o) {

		Score other = (Score) o;
		//1이면 앞의 인자가 더 큰값 
		//0이면 같은값 
		//-1이면 뒤의 인자가 더 큰값 
		
		
		if(this.getKor()> other.getKor()){
			return 1;
		}else if(this.getKor()<other.getKor()) {
			return -1;
		}	
		//this.getKor() == other.getKor()
		return 0;
	

comparator :심판이 되어 a와 b를 비교해줌

비교 클래스 외부에 객체가 따로 만들어져야함.

compare(Object a, Object b)

collections.sort(kh,new Mysort());

List

Set

Map<K,V>

T type

K key

V value

O object