java 자바 제네릭 컬렉션 클래스 2

컬렉션 클래스(자바에서는 다양한 자료구조를 컬렉션이라는 클래스로 제공한다)

 

Collection 계층의 인터페이스들

 

Collection 인터페이스는 Set과 List 등을 대표합니다. Collection에서 정의된 공통적인 메서드들은 Collection을 상속받은 하위 인터페이스들이 일반적으로 가지는 메서드들을 대부분 정의하고 있기 때문에 하위 인터페이스의 유형과 상관없이 다목적으로 생성자를 이용하여 초기화할 수 있습니다. 프로그래머는 이러한 성질을 이용하여 하위 인터페이스 타입에 대해 자유로운 작업 가능합니다.

 

-> 컬렉션 인터페이스의 주요 메소드

 

     add()                       //요소 추가 성공시 true 반환

     contains(Object o)   //해당객체가 컬렉션 클래스에 포함되어 있으면  true 그렇지 않으면 false

     isEmpty()                //컬렉션이 비었는지를 반환

     iterator()                 //Iterator 인터페이스를 얻어냄

     remove(Object o)    //요소 삭제 성공시 true반환

     removeAll()            //요소 전체 삭제

     size()                    //요소가 몇개 들었는지를 반환

     toArray(T[]  a)        //컬렉션에 들어있는 요소를 객체 배열로 바꿈

 

 

 

ps.컬렉션 클래스들은 Object형으로 요소를 저장한다.

 

ps. 컬렉션 인터페이스는 배열처럼 데이터를 여러개 저장할수 있는데 배열과 차이점은  서로 다른
      형태의 자료를 요소로 가질수 있다는 점이다 

      또 하나의 특징은 기억공간이 실행시에 자동 증가 될수 있다는 점이다.

 

      컬렉션 인터페이스는 Set과 List로 나뉘는데 

      Set => 순서가 없는 집합으로 중복을 허용하지 않는다.

      List => 순서가 있는 집합으로 중복을 허용한다.

 

 

 

Set 인터페이스

순서가 없는 집합으로 중복을 허용하지 않는다.

Set 인터페이스를 구현한 클래스로는  HashSet을 제공합니다. 

 

                         hashset => 중복되지 않은 값을 가지고 싶을때 사용

                         treeset  =>            ''                  ''                       트리셋은 정렬이 가능하다.
                                         (대문자가 소문자보다 우선순위)

ex1) HashSet()
import java.util.*;

 

class Test{

     public  static  void  main(String[]  args){

            Set  set  = new  HashSet();   //해쉬 셋 객체 생성   ==  HashSet  set  = new  HashSet();

           
            set.add("하나");       //해쉬 셋 객체에 요소를 추가한다. (다양한 형태들이 저장될수 있다.)
            set.add(2);

            set.add(3.42);

            set.add("five");           

            System.out.println("요소의 개수=" + set.size());   //요소의 개수를 출력한다.

            System.out.println("set 객체의 값은=" + set);      //해쉬셋 객체 요소들을 출력한다.

 

     }

}


ex2) 경고가 안나게끔 제네릭표현을 사용하였다.<String>...

import java.util.*;
import static java.lang.System.out;

public class HashSetEx1 {
     public static void main(String args[]) {
            String[] str = {"Java","Beans","Java","XML"};
            HashSet<String> hs1 = new HashSet<String>();
            HashSet<String> hs2 = new HashSet<String>();
            for (String n : str){
                  if (!hs1.add(n)) hs2.add(n);       
               //중복을 허용하지 않기 때문에 2번째 java에서 조건을 만족하게 되고 그 값이 저장된다.
            }
  

            out.println("hs1 : " + hs1);                // XML,Beans,Java  결과가 나타난다. (중복허용X)
            hs1.removeAll(hs2); 
            out.println("hs1 : " + hs1);                // XML,Beans  결과가 나타난다.  
            out.println("hs2 : " + hs2);                // Java  결과가 나타난다.
    }
}

 

ex3) treeset 예제

 

import java.util.*;
   class TreeSetEx2  {
      public static void main(String[] args)  {
      TreeSet set = new TreeSet();
      int[] score = {85, 95, 50, 35, 45, 65, 10, 100};
      for(int i=0; i < score.length; i++)
            set.add(new Integer(score[i]));
      System.out.println("50보다 작은 값 :" + set.headSet(new Integer(50)));    
      //조건에 만족하는 데이타를 표시하는 정렬한다. (대문자>소문자)
      System.out.println("50보다 큰 값 :"  + set.tailSet(new Integer(50)));
   }
}

 

 

 

 

List 인터페이스 : ArrayList, Stack, Vector, LinkedList가 있다.

=> 순서가 있는 집합으로 중복을 허용한다.

 

메소드-> 
      indexOf(Object o)  //전달인자로 준 객체를 앞에서부터 찾아 해당 위치를 반환, 못찾으면 -1반환

      lastIndex(Object o)  //객체를 마지막 위치부터 찾음

      get(int index)       // 위치의 객체를 반환

      set(int index,E element)   //index위치의 요소를 element로 주어진 객체를 대체한다.

      add(int index,E element)  //index위치에 element로 주어진 객체를 저장한다. 
                                             해당 위치의 객체는 뒤로 밀려난다.

      remove(int index)             //index 위치의 객체를 지운다.

 

 

ArrayList클래스
: 자바에서 배열은 생성할 당시에 정한 배열의 길이를 늘이거나 줄일수 없습니다.
 하지만 ArrayList 클래스는 원소가 가득차게되면 자동을로 저장영역을 늘려줍니다.(가변길이의 배열)
 ,원하는 요소를 인덱스로 접근할수 있다.

 

ex) 

import  java.util.*;

class test{

     public static void main(String[] args){

          List  list  = new ArrayList();      // == ArrayList  list  = new ArrayList();  객체 생성

          list.add("하나");

          list.add("2");

          list.add("3.42");

          list.add("five");

          for(int i=0; i<list.size(); i++) { System.out.println(i+"번째 요소는=" + list.get(i)); }

     }

}

 

 

 

Iterator 인터페이스 
=> List와 Set을 범용적으로 읽어낼 수 있는 인터페이스로 컬렉션을 순차적으로 출력할 때 사용
    합니다.  (list에서 for문말고 반복자(iterator)를 이용하여 원소에 접근할수있다)

    주요메소드: boolean hasNext()   -> 요소가 있으면 true반환, 없으면 false반환

                                    E  next()  ->요소를 얻어낸다.

ex)

import  java.util.*;

import com.sun.xml.internal.ws.developer.MemberSubmissionEndpointReference.Elements;
class test{
     public static void main(String[] args){
          List  list  = new ArrayList();           // == ArrayList  list  = new ArrayList();  객체 생성
          list.add("하나");
          list.add("2");
          list.add("3.42");
          list.add("five");
         
          //for(int i=0; i<list.size(); i++) { System.out.println(i+"번째 요소는=" + list.get(i)); }
         
          Iterator elements= list.listIterator();
          while(elements.hasNext()){               //요소가 있다면
           System.out.println(elements.next()); // 요소를 얻어내어 출력
          }
     }
    }
    

 

 

Vector 클래스 
=> ArrayList와 유사하다. 원소가 가득차면 자동적으로 저장 영역을 늘려주는 가변 배열입니다.

    검색과 삭제가 용의하다 
: 매소드 indexof(찾을인자) -> 앞에서부터 해당위치를 찾아 반환, 못찾으면 -1 반환

           contains(해당인자) -> 포함여부확인

           remove(해당인자) -> 해당인자 삭제

                            

ex)

import  java.util.*;

import com.sun.xml.internal.ws.developer.MemberSubmissionEndpointReference.Elements;
class test{
     public static void main(String[] args){

      Vector vec = new Vector(4,3); //4개의 요소를 저장할수 있는 벡터 객채 생성 3개씩 증가
      System.out.println("벡터의 크기는 " + vec.size());
      System.out.println("벡터의 용량은 " + vec.capacity());
     
      for(int i=0;i<5;i++){
       vec.add(i*10);
      }
      System.out.println("벡터의 크기는 " + vec.size());
      System.out.println("벡터의 용량은 " + vec.capacity());
      System.out.println("첫번째요소 " + vec.firstElement());
      System.out.println("두번째요소" + vec.get(1));
      System.out.println("마지막 요소 " + vec.lastElement());
     
      for(int i=0;i<vec.size();i++){
       System.out.println("저장된요소는 " + vec.get(i));
      }
    }
    
}

                         

 

Enumeration 인터페이스 
=> 컬렉션 인터페이스로 구현한 클래스 안에 저장된 객체를 쉽게 꺼낼수 있다

 

ex)

import  java.util.*;

class test{
     public static void main(String[] args){

      Vector vec = new Vector();
      for(int i=0;i<5;i++){
       vec.add(new Integer(i*10));
      }
      Enumeration enu = vec.elements();          //벡터요소들에 대한 Enumeration 객체를 반환
      while(enu.hasMoreElements()){              //벡터에 요소가 있으면
      System.out.println(enu.nextElement());  //요소를 얻어낸다.
      }
    }
    
}

 

 

Stack 클래스 => LIFO

                

ex)

import  java.util.*;

class test{
     public static void main(String[] args){

      Stack sta = new Stack();
      sta.push("자료1");                //스택에 객체를 추가한다.
      sta.push("자료2");
      sta.push("자료3");
     
      while(!sta.isEmpty()){            //현재 스택이 비어있지 않으면
       System.out.println(sta.pop()); // 스택에 저장되 객체를 꺼내온다.
      }
    
     } 
}

 

결과:

자료3
자료2
자료1

 

 

linkedlist 클래스 => Queue인터페이스를 구현함, FIFO

 

ex)

import  java.util.*;

class test{
     public static void main(String[] args){

      LinkedList ll = new LinkedList();
      ll.offer("자료1");                //큐에 객체를 추가한다.
      ll.offer("자료2");
      ll.offer("자료3");
     
      while(ll.peek()!=null){            //현재 큐가  비어있지 않으면
       System.out.println(ll.poll()); // 큐에서 데이타를 꺼내온다.
      }
    
     }  
}

 

결과:

자료1
자료2
자료3

 

 

 

Hashtable 클래스
=> Map 인터페이스를 구현한 클래스, (키,객체)쌍으로 데이타를 저장 관리함, 키를 통해 검색

메서드: put(key,value) 해쉬테이블에 저장

          Object get(Object key): key로 주어진 값을 이용하여 데이터를 검색한다.

          remove(Object key) key로 해당데이타 삭제한다.

          void clear() 해쉬테이블에 들어있는 키와 해당 객체를 모두 삭제한다.

          Enumeration keys() 해쉬테이블의 키 요소들에 대한 Enumeration객체 반환

ex)

 

import  java.util.*;

class test{
     public static void main(String[] args){

      Hashtable ht = new Hashtable();
      ht.put("키1","데이타a");                //해쉬테이블에 키/데이타를 입력한다.
      ht.put("키2","데이타b");
      ht.put("키3","데이타c");
     
     String v=(String)ht.get("키1");         //키를 이용하여 해쉬테이블의 값을 얻는다.
     if(v!=null){
      System.out.println("키1자료는:"+v);
     }
    
     Enumeration enu = ht.keys();           //해쉬테이블의 키 요소들에 대한 Enumeration 객체 반환
     while(enu.hasMoreElements()){          //키요소가 있으면
      Object k= enu.nextElement();       //키 요소를 얻어낸다.
      Object vv=ht.get(k);               //키요소로 주어진 값을 이용하여 데이터를 검색한다.
      System.out.println(k+":"+vv);      //키요소와 데이타를 출력한다.
     }
     
     }
    
}
    

 

 

 

제네릭 

: Generics는 컬렉션(자료구조) 즉, 객체들을 저장(수집)하는 구조적인 성격을 보강하기 위해 제공
   되는 것이다. 간단히 예를 들자면 컵이라는 특정 객체가 있다. 이 컵은 물만 담을 수 있는 물컵,
   또는 이 컵은 주스만 담을 수 있는 주스 컵! 이렇게 상징적인 것이 바로 Generics다!

 

제네릭의 필요성 

: JDK5.0에 프로그래머가 특정 컬렉션(자료구조)에 원하는 객체 타입을 명시하여 실행하기 전에
  컴파일단계에서 확인하여 지정된 객체가  아니면 절대 저장이 불가능하게 할 수 있다. 

  (이전 버전까지는 반드시 실행하여 컬렉션(자료구조)에 있는 자원들을 하나씩 검출하여 확인할
  수 밖에 없었다.)

 

   컬렉션 클래스들은 Object형으로 요소를 저장한다.

   별도의 형 변환(Casting)이 필요 없이 <>사이에 선언하였던 객체자료 형으로 검출되어 편리하다.

 

ex)  백터와 같은 컬렉션 객체는 다양한 원소로 저장될수 있다. add메서드의 전달인자가 모든 
       객체의 최상위 클래스인 Object형으로 정의되어 있기때문에  다양한 원소를 add메서드로 
       추가할수 있고 Object형으로 관리된다.

       이로 인해 편리한점도 있지만 불편한점도 있다. 예제를 통해 살펴보자
            

아래 예제는 백터 객체에 저장된 문자열을 대문자로 변환하여 출력하는 예이다.

       import java util.*;

       class  test{

             public static void main(String[] args){

                    Vector vec = new Vector();

                    vec.add("Apple");              //내부적으로 요소들을 Object형으로 관리하고 있음

                    vec.add("oRange");

 

                    String temp;

                    for(int i=0; i<vec.size();i++){

                             //temp = vec.get(i);               -> 이렇게 사용하면 에러발생한다.

                             temp = (String) vec.get(i);     // 그렇게 때문에 Ojbect형으로 관리되는 요소를
                                                                          사용할때는 다운캐스팅을 해야함

                             System.out.println(temp.toUpperCase());

                    }

             }

       }

 

 하지만 제네릭을 사용하면 다운캐스팅하지 않아도 된다.

       import java util.*;

       class  test{

             public static void main(String[] args){

                    Vector<String> vec = new Vector<String>(); 
                   //제네릭 형태로 백터객체를 생성하였기때문에

                    vec.add("Apple");                                               

                    vec.add("oRange");

 

                    String temp;

                    for(int i=0; i<vec.size();i++){

                             temp = vec.get(i);
                            // String객체에 벡터 객체의 get메서드 결과값을 저장하기 위해

                                다운캐스팅 하지 않아도 된다.

                             System.out.println(temp.toUpperCase());

                    }

             }

       }

 

 

 

제네릭은 확장for문을 사용할수 있다.

확장for문은 배열이나 컬렉션과 같이 여러개체가 모여 있는 경우에 개체의 끝을 체크하지 않고도 하나씩 차례대로 접근할 수 있도록 한다

 

   형식)  for(자료형 접근변수명 : 배열이나 컬렉션 변수명){ 반복코드 }

 

ex)  import java util.*;

       class  test{

             public static void main(String[] args){

                    Vector<String> vec = new Vector<String>();  

                    vec.add("Apple");                                               

                    vec.add("oRange");

 

                    for(String temp : vec){                         

                             System.out.println(temp.toUpperCase());

                    }

             }

       }

 

 

 

 

 

제네릭을 사용한 클래스의 작성

: 제네릭을 지원하기 위해서는 템플릿 형태의 정해지지 않은 가상의 자료형을 클래스 정의해서 정해야 한다.

  보통 1글자의 영문자 대문자를 사용한다.

 ( API에서는 전달되는 객체가 현 객체 내에서 자료형(Type)으로 쓰일 때 <T>로 유도를 하고 있으며

   만약 전달되는 객체가 현 객체 내에서 하나의 요소(Element)로 자리를 잡을 때는 <E>로

   그리고 전달되는 객체가 현 객체 내에서 Key값으로 사용될 때는 <K>로,

   만약 전달되는 객체가 현 객체 내에서 Value값으로 사용될 때 <V>로 표현하고 있다. )

 

<T>는 아직 아무것도 확정되지 않은 자료형이다 즉 객체 생성시 어떤 자료형으로도 될수 있다.

 

ex)

class Gener<T>{

     private  T member;

     public void setValue(T  value){ member = value;}

     public  T     getValue(){return member;}

}

 

class test{

    public static void main(String[] args){

         

            Gener<Integer> obj1 = new Gener<Integer>();

            obj1.setValue(10);

            System.out.println(obj1.getValue());

 

            Gener<String> obj1 = new Gener<String>();

            obj1.setValue("이것이 제네릭");

            System.out.println(obj1.getValue());

 

    }

}

 

 

 

 

와일드카드
: 제네릭으로 선언된 객체들은 상속 관계에서도 형변환이 암시적으로 이루어지지 않는다. 그래서
  와일드 카드를 사용한다.

  하나의 객체만 저장 할 수 없는 경우 사용하는 것이 와일드 카드이다.
  모든 객체를 저장하고 싶을 때 또는  특정 객체로 부터 상속 받은 객체들만 저장하고 싶을 때 사용
   되어 진다.

 

  와일드카드타입
------------------------------------------------------------------------------  
<?>
 -모든 객체자료형에 대한 배치를 의미
 
<? super 객체자료형>
 -명시된 객체자료형 또는 객체자료형의 상위 객체들의 배치를 의미
 
<? extends 객체자료형>
 -명시된 객체자료형 또는 객체자료형으로부터 상속받는 하위 객체들의 배치를 의미

------------------------------------------------------------------------------

 

ex)

 

import static java.lang.System.out;

class GenEx1{
   String msg = "GenEx1";
   public String getMsg(){ return msg;}
}

class GenEx2 extends GenEx1{
   String msg = "GenEx2";
   public String getMsg(){ return msg; }
}

class GenEx3 extends GenEx2{
   String msg = "GenEx3";
   public String getMsg(){ return msg; }
}

 

class GenericEx4<T>{

   T v;
   public GenericEx4(T n){ v = n; }
   public void set(T n){ v = n; }
   public T get(){ return v; }

   public static void main(String[] args){
      GenEx3 g3 = new GenEx3();
      GenericEx4<? super GenEx2> g4 =  new GenericEx4<GenEx1>(g3);
      GenEx3 test = (GenEx3)g4.get();
      // GenEx3 test = g4.get();//오류
      out.println("g4의 결과 : "+ test.msg+","+test.getMsg());
    }
}