'IT/JAVA'에 해당되는 글 21건

 Generic 

 Autoboxing 

 Unboxing 

 List<E> : 다이아몬드연산자 사용

 <E> : 제네릭

 - E에 데이터형을 넣는데 기본

   데이터형을 사용 할수 없다.

 - 기본형대신 WrapperClass사용

 - JDK 1.5에서부터 추가된기능

   ( 입력데이터 형의 제한 )

 - JDK1.4까지는 모든 데이터입력

   ( 입력된 데이터를 꺼내서 사용할

   때 문제가 발생 )

문법)

 1)인터페이스명<데이터형> 객체명

    = new 생성자<데이터형>();

 2) 클래스명<데이터형> 객체명

    = new 생성자<데이터형>();

 - JDK 1.7부터는 생성자뒤에

   데이터형이 생략가능하다.

  JFC에 기본형 데이터형을 추가하면

  기본형데이터형에 대응되는 WrapperClass

  로 객체가 생성되어 입력되는것

 List<Integer> l=new ArrayList<Integer>();

 int i = 0 ;

 l.add( i ); --> l.add(new Integer(i));

 JDK 1.5부터 지원된다.

 기본형 데이터형을 추가 했을 때 입력되는

 WrapperClass에서 원래의 데이터형으로

 반환하는 것

 Collection 계열

 - 일차원 배열 형태

 - 가변길이형 배열

 - 데이터의 추가와 삭제가 쉽다

 - JDK1.4 까지는 객체만  저장

   JDK 1.5에서부터는 모든

   값을 저장(오토박싱)한다.

 List 

 - 중복값 저장 가능

 - 검색의 기능이 있다.

 - 데이터가 순차적으로 들어간다.

 - Interface라 객체화가 안됨

    (is a 관계 객채화필요)

 메소드

 1. 값추가 : add(값);

 2. 크기(데이터 존재하는 방의 갯수)

    : size();

 3. 값얻기 : get(int index) : E

               get(int index,E e)  : void

 4. 삭제 : remove(int index) : E

             remove(E e) : boolean

 5. 모두삭제 : clear() : void

 6. 배열로 보내기 :

    toArray(T[] a):Object[]

 ArrayList 

 - vertor의 속도를 향상

 - 동기화 되어 있지않다.  (MultiThread에서 동시 접근 가능)

 - 데이터 추가가 순차적으로 발생

 - FIFO( First In First Out ), 선입선출( Queue )

 Vertor

 - 동기화 되어 있다.

   (MultiThread에서 동시 접근 불가)

 - 데이터 추가가 순차적으로 발생

 - FIFO,  선입선출( Queue )

   ( First In First Out )

 Stack

 - is a 관계로 객체화

   않는다.

 - LIFO( Last In First Out )

 - 마지막에 들어간 값이

   먼저나온다.

 - stack은 OverFlow가

   발생한다.

 - 부모의 method는 사용

   하지않는다.

 1. 생성)

 Stack<E> stk =

 new Stack<>();

 2.값 추가)

 stk.push(E item) : E

 3.값 출력)

 stk.pop() : E

 ( 꺼낸 값은 사라진다. )

 4.비엇니?)

 stk.empty() : boolean

 LinkedList

 - 데이터 추가가 뒤가 아니라 중간 부분에서 빈번하게

   일어 날때 사용

사용법)

 * IS A 관계

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

(List < String > l = new Vertor<String>();

(List < String > l = new LinkedList<String>();

 * 자식 클래스로 만들때

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

 Vertor<String> l = new Vertor<String>();

 LinkedList<String> l = new LinkedList<String>();

 ex)

 1.선언)

 List <String> list = null;

 2.생성)

 list = new ArrayList<String>();

 3.추가)

 list.add("안녕");

 list.add("클래스");

 list.add("반장");

 3.배열내보내기 )

 String[] str = new String[list.size()];

 list.toArray(str);

 3.방의 값얻기 )

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

    System.out.println(list.get(i));

   //( i = 0 : 안녕 , i = 1 : 클래스 , i = 2 : 반장 )

 }

 4.방 삭제)

  list.remove(1); // "클래스" 삭제

  list.remove("안녕"); // 중복값이있다면 중복값의 최소인덱스

                           // 의 값만 제거한다.

 Set 

 - 중복값을 저장 불가

 - 검색의 기능이 없다.

 - 데이터가 순차적으로

   입력되지 않는다.

 - 조회기능이없어서 Iterator 사용

 HashSet 

 1.선언 + 생성)

 Set<E> set = new Set<E>();

 2.값 추가) add(E e) : boolean

 값이 순차적으로 입력되지 않는다.

 기본형을 입력하면 autoBoxing이 된다.

 3.방의크기) size():int

 4.삭제 ) remove(Object o) : boolean

 인덱스로는 삭제 할 수 없다.

 5.모두 삭제) clear() : void

 6. 배열로 복사 ) toArray(E e): E

 7. 값 얻기)

 검색기능이 없음으로 제어권을 Iteractor에게 이양한다.

 Iteractor<Set> ita = set.iteractor(); 

 while(ita.hasNext()){//방존재?

        ita.next();// 값 얻고 다음방으로 포인터를 이동

 }

 Map 계열

 - 2차원 배열로 되어있다.

 - 키와 값의 쌍으로 되어있다.

 - KOV ( Key Of Value )

 - 키는 중복될 수 없다.

 - 값은 중복될 수 있다.

 - 입력되는 키가 이전 키와

   같다면 값을 덮어쓴다.

 - 입력되는 순서대로 추가되지

   않는다.

 Hashtable

 생성시 11개 행이 자동생성된다.

 사용법)

 1) 선언

  Map<K,V> map = null;

 2) 생성

  map = new HashTalbe<K,V>();

 3) 값 할당

  map.put(키,값);

 4) 행의 크기:입력된데이터까지

  map.size():int

 5) 키가 존재하는지

  map.key:boolean

 6) 모든 키로 얻기

  map.keySet():Set

 7) 삭제

   map.remove(K): V

   map.remove(K,V): Boolean

 8) 검색

   map.get(K)

   키가 없으면 null 리턴

 공통점 : - 전체레코드의 약 75 %데이터가 채워져있을때

             가장빠른 검색을 하게된다.

            - 생성자에 행의 크기를 설정해주는게 좋다.

  HashMap

 생성시 16개 행이 자동생성된다.

 사용법)

 1) 선언

  Map<K,V> map = null;

 2) 생성

  map = new HashMap<K,V>();

 3) 값 할당

  map.put(키,값):V

 4) 행의 크기:입력된데이터까지

  map.size();

 5) 키가 존재하는지

  map.key;

 6) 모든 키로 얻기

  map.keySet():Set

 7) 삭제

   map.remove(K): V

   map.remove(K,V): Boolean

 8) 검색

   map.get(K):V

   키가 없으면 null 리턴