Collection Framework => ArrayList / HashSet / HashMap

[ Collection FrameWork ] List / Set / Map

< ArrayList >
- index 저장순서
- 중복데이터 그대로 여러번 저장

ArrayList<> list = new ArrayList( );
[저장]
.add( value );
.add(new A( )); 타입제한 X

.insertAt( 1, "java" ) => 1번 인덱스에 java 넣고, 나머지는 뒤로 밀려남

[수정]
.set( 1, "nojava" ) => 1번 인덱스 value 바꿔치기

[삭제]
.remove( index ); => 1번 인덱스 value 삭제

[조회]
.size; => elements 개수 // 배열은 .length;

[포함여부조회]
.contains( value ) => list 에 value 존재하는지 Boolean반환

[포함위치 조회]
.indexOf( value ) => list 에서 value 가 몇번째 index에 존재하는지 index 반환 (없으면 -1 반환)

[포함데이터 조회]
.get( index ); => 해당 index 의 value 값 가져오기 => "Object" 로 리턴됨

< 출력 >
(1) for 반복문 ( index 사용 )
for (int i = 0; i < list.size(); i++) {
System.out.println( list.get(i)); }

=>for문으로 Arraylist 뽑을때는 list.get(i) 한걸로 뽑아야함

(2) foreach
for(Object A : list) {sout( A ); }

- foreach 일때는 그냥 list객체 자체로 뽑음
- Object 타입변수로 모든 데이터타입 넣을 수 있고, 뽑을 때도 그냥 바로 뽑힘

< 모든 데이터Type - Object 에 담기 > Generic(X)

=> 다양한 Type 의 데이터들을 다 넣고 뽑을 수 있음!!
숫자, 문자, 객체 다 List 나 Set 에 담아놓고
뽑을때 foreach( Object A : list ) { sout ( A ) }
하면 데이터타입별로 다 출력가능 ( 객체는 toString 으로 뽑기 )

주의 : Generic 없으면 return 값 Object 로만 받아진다.

( +참고 )
특정 Type의 메소드를 사용하고 싶으면 (String.toUpperCase 같은거)
Object => 특정Type으로 강제형변환해서 사용 ((String)A).toUpperCase
그럴경우, 강제형변환이 안되는 elements 에 대해서 if else 로 오류 잡아주고 사용
if( X instanceof Y ){ sout(((String)A).toUpperCase); }
else { 원래대로 그냥 sout (A) 출력만 } ) 잘안씀


< Generic 사용 - 하나의 Type으로 제한 > 많이사용!
- 그 Type만 넣을수 있고, 그 타입으로만 뽑을 수 있음
- 그 Type의 메소드 편하게 사용 가능


(3) Iterator
Iterator iterator = list.iterator( );
while( iterator.hasNext( )){
sout ( iterator.next( )); }


< HashSet > 집합!
- 저장 순서가 없다. (랜덤순서)
- 중복데이터 무시한다. ( 집합 )
HashSet<> set = new HashSet( );

set.add ( value ); 추가
set.remove( value ); 삭제
set.isEmpty( ); => 비었습니까? (Boolean)
set.contains( value ); => value 존재 합니까? (Boolean)

A.addAll(B); - 합집합
A.removeAll(B); - 여집합
A.retainAll(B); - 교집합
A.clear( ); - 싹비우기

< Set 출력하기 >
- 인덱스 (순서) 가 없기 때문에, for문으론 못뽑는다.
(1) foreach
(2) Iterator


< HashSet 정렬 Sort 해서 출력하기 >

1. ArrayList 로 담기 - Collections.sort
List<Integer> sorting = new ArrayList( hashSet ) ; // 생성자로 바로 Set을 담을 수 있다.
Collections.sort( sorting ) ; // 정렬
foreach 로 뽑기

2. TreeSet 로 담기
TreeSet<Integer> sorting = new TreeSet( );
sorting.addAll( hashSet );
foreach 로 뽑기

3. LinkedHashSet 사용 => 똑같은데 출력이 순서대로(오름차순) 된다!



< HashMap >
- 저장하는 순서 없음
- 저장구조 ( key, value )
- 중복된 value 는 가능, (key는 유일)

HashMap< keyType , valueType > map = new HashMap( ); // Generic이 Key, Value 타입 2개다.
(HashMap<Integer, String> map = new HashMap( );)

[저장]
.put( "key" , value ); //map만 특이하게 put // list 나 set은 get //
[수정]
.put( "key" , value ); // 오버라이딩/재할당 => 수정
[삭제]
.remove( "key" );
[조회]
.get( "key" ); => Object 타입으로 value 반환
.containsKey( A ) => map이 A라는 key값을 가졌는가 Boolean
.containsValue( A ) => map이 A라는 value 값을 가졌는가 Boolean
.keySet( ); => key값들만 조회 ( Set으로 반환 )

< Map 출력하기 >
(1) foreach
(2) Iterator

[1] Value 값만 뽑으면 될 때 => .values( ) 활용
- HashMap 은 parameter 가 두개라 골라서 뽑아야한다
- key 값이랑 value 가 있으니까, values 를 담겠다.
for(Object o : map.values()){sout( o );}

Iterator it = (map.values( )).iterator( );
while(it.hasNext()){sout(it.next());}

[2] Key 값 + Value 값 으로 뽑을 때 => KeySet( ) 활용

Set keySet = map.keySet();
for (Object ob : keySet ) {
System.out.println("key : " +ob+ ", value : "+ map.get(ob));
} //map.get( )에 keySet으로 받은 키를 직접 집어넣어서 value 가져오기

[3] value 가 '배열' 인 Map 출력하기
- < Generic > 으로 value 타입이 배열임을 명시해준다.
=> 그래야 Key값으로 get( ) 한 데이터를 배열Type 으로 받아서 저장해둘 수 있다.

Set<String> key_name = phone.keySet();

- .keySet( ) 사용해서
key값으로 뽑은 value 들은 Generic 에서 배열 타입으로 정해뒀기 때문에, 배열로 받을 수 있다.
( Generic 설정 안해두면 Object 로만 받을 수 있다. )
- 이렇게 Generic 을 이용해 만든 value 가 담긴 배열을
다시 foreach 문 등을 이용해 뽑아내면 완성

for ( String keySet : key_name ) {
    String[] list = phone.get(keySet);
    System.out.print(keySet +" - ");
    for (String A : list) {
        System.out.print( A + " "); }
}

=> Map 에 value 값으로 배열이 담겼을 때,

for (String[] ss: phone.values()
     ) {
    System.out.println(ss);
}

이렇게 배열을 바로 뽑아내려하면 배열도 객체인지라 객체주소값만 출력된다.
그러므로,
1. key 값으로 value 뽑아둔 list 만들고
2. 그 list를 반복문등으로 뽑아내는 과정이 필요하다.