Java 05. 컬렉션 ( Collection )

(1) Data Structure , 가변배열

 

(2) 같은 타입의 '참조형'데이터 '저장소'로써 그 크기가 변하는 '객체'

 

(3) 기본형은 래퍼클래스( wrapper class ) 로 형변환 해야 컬렉션안에 넣을 수 있다.

     1) 래퍼클래스 종류:

          <1> byte -> Byte

          <2> char -> Character

          <3> short -> Short

          <4> int -> Integer

          <5> long -> Long

          <6> float -> Float

          <7> double -> Double

          <8> boolean -> Boolean

 

(4) 컬렉션 종류
     1)          java.util.Collection
                 |             |
         java.util.List    java.util.Set
                    |                   |
        ArrayList, Vector,...      TreeSet, SortedSet,...


     2)           java.util.Map
                     |
               Hashtable, HashMap,...

 

(5) 컬렉션의 특징
     1) List 
          <1> 순서를 보존 O
          <2> 중복을 허용 O

     2) Set ( 비유: 수학에서의 집합 )
          <1> 순서를 보존 X
          <2> 중복을 허용 X

     3) Map ( 비유: 수학에서의 1대1 대응 )
          <1> key와 value값으로 저장
          <2> 순서를 보존 X
          <3> value는 중복 O
          <4> key는 중복 X
               ( key가 중복된다면 value는 새로운 값으로 덮어씀 )

 

(6) 제네릭( Generic )

     1) 컬렉션에 넣는 타입을 제한한다.

          ex) List<Integer>, Map<String, Long> 등등...

 

     2) 장점: 

          <1> 컬렉션에 제네릭을 사용하지 않으면, 모든 데이터가 Object 타입으로 들어가기 때문에

                 만약에 String 타입과 Integer 타입이 같이 들어가게 되버리면, 나중에 형변환할 때 오류가 발생하게 된다.

                 그럴때 타입을 제한해두면 오류를 컴파일 시점에  잡을 수 있게 된다는 장점이 있다.

          

          <2> 제네릭을 사용하면 데이터가 Object 타입이 아니라 지정한 타입으로 들어가게 되므로, 꺼내서 사용할 때

                 형변환 할 필요가 없어진다. 

 

(7) 오토박싱 ( AutoBoxing ) 과 오토언박싱 ( AutoUnBoxing )

     1) 기본형 데이터를  래퍼클래스 타입에 넣을 때 자동으로 형변환 해주는 기능이다. 

          ex) 박싱: Integer i = new Integer(10);

               언박싱: int j = i.intValue();

 

               오토박싱: Integer i = 10;

               오토언박싱: int j = i;

 

(8) 향상된 For 문( 인핸스드 포 루프: Enhanced For Loop )

     1) 배열

          ex) String[] strs = {"a", "b", "c"};

               for(String str: strs) {}

 

     2) List & Set

          ex) List<String> list = new ArrayList<>();

               list.add("a");

               for(Strung i: list) {}

 

     3) Map

          ex1) Enhanced Loop

              Map<Double, String> ht = new Hashtable<>();

              ht.put(1.1, "aaa"); 

              Set keys = ht.keySet();
              for(Object keyObj : keys){
                   Double key = (Double)keyObj;
                   Object valueObj = ht.get(key);
                   String value = (String)valueObj;
                   System.out.println("key: " + key + ", value: "+ value);
              }

 

          ex2) Generic + Enhanced Loop

              Map<Double, String> ht = new Hashtable<>();

              ht.put(1.1, "aaa"); 

              Set<Double> keys = ht.keySet();
              for(Double key : keys){
                   String value = ht.get(key);
                   System.out.println("key: " + key + ", value: "+ value);
              }

 

(9) 이터레이터( Iterator )

     1) List

          ex1) Iterator 

               List<String> list = new ArrayList<>();

               list.add("a");

               Iterator iter = ts.iterator();
               while(iter.hasNext()){
                    Object obj = iter.next();
                    String str = (String)obj;
                    System.out.println("str: " + str);
               }

             

          ex2) Generic + Iterator 

               List<String> list = new ArrayList<>();

               list.add("a");

               Iterator<String> iter = ts.iterator();
               while(iter.hasNext()){
                    String str = iter.next();
                    System.out.println("str: " + str);
               }

 

     2) Set

          ex) Iterator

               Set<String> ts = new TreeSet<>();

               ts.add("a");

               //Iterator iter = ts.iterator();

               Iterator iter = ts.descendingIterator(); // Set 에만 있는 기능 ( 내림차순 정렬 )
                while(iter.hasNext()){
                     Object obj = iter.next();
                     String str = (String)obj;
                     System.out.println("str: " + str);
                }

 

          ex2) Generic + Iterator 

               Set<String> ts = new TreeSet<>();

               ts.add("a");

               //Iterator<String> iter = ts.iterator();

               Iterator<String> iter = ts.descendingIterator();

               while(iter.hasNext()){
                    String str = iter.next();
                    System.out.println("str: " + str);
               }

 

     3) Map

          ex1) Iterator

              Map<Double, String> ht = new Hashtable<>();

              ht.put(1.1, "aaa"); 

              Set keys = ht.keySet();

              Iterator iter = keys .iterator();
              while(iter.hasNext()){
                   Object keyObj = iter.next();

                   Double key = (Double)keyObj;
                   Object valueObj = ht.get(key);
                   String value = (String)valueObj;
                   System.out.println("key: " + key + ", value: "+ value);
              }

 

          ex2) Generic + Iterator

              Map<Double, String> ht = new Hashtable<>();

              ht.put(1.1, "aaa"); 

              Set<Double> keys = ht.keySet();

              Iterator<Double> iter = keys .iterator();
              while(iter.hasNext()){
                   Double key = iter.next();

                   String value = ht.get(key);
                   System.out.println("key: " + key + ", value: "+ value);
              }

 

(10) 이뉴머레이션( Enumeration )

     1) List & Set

          ex1) Enumeration 

               List<String> list = new ArrayList<>();

               list.add("a");

               Enumeration e = ts.elements();
               while(e.hasMoreElements()){
                    Object obj = e.nextElement();
                    String str = (String)obj;
                    System.out.println("str: " + str);
               }

             

          ex2) Generic + Enumeration 

               List<String> list = new ArrayList<>();

               list.add("a");

               Enumeration<String> e = ts.elements();
               while(iter.hasNext()){
                    String str = e.nextElement();
                    System.out.println("str: " + str);
               }

 

     2) Map

          ex1) Enumeration 

              Map<Double, String> ht = new Hashtable<>();

              ht.put(1.1, "aaa"); 

              Enumeration e = ht.keys();
              while(e.hasMoreElements()){
                   Object keyObj = e.nextElement();

                   Double key = (Double)keyObj;
                   Object valueObj = ht.get(key);
                   String value = (String)valueObj;
                   System.out.println("key: " + key + ", value: "+ value);
              }

 

          ex2) Generic + Enumeration 

              Map<Double, String> ht = new Hashtable<>();

              ht.put(1.1, "aaa"); 

              Enumeration<Double> e = ht.keys();
              while(e.hasMoreElements()){

                   Double key = e.nextElement();
                   String value = ht.get(key);
                   System.out.println("key: " + key + ", value: "+ value);
              }