[JAVA 19] 자바 가변 배열 ( Collection / 컬렉션) ① List

3. 특징

1) List

(1) ' 순서 ' 가 보존된다.

(2) ' 중복 ' 이 허용된다.

① Generic

② Enhanced Loop ( 강화된 반복분 )

③ Boxing ( AutoBoxing / UnBoxing )

---

import java.util.*;        // * = 모든 것을 임폴트 한다.
 
class ListS1{              // List Study 1
    
    Vector v = new Vector();  // 제네릭을 사용하지 않았다.
 
    void in(){
        v.add(" 봄 ");     // List 계열은 배열변수.add(); 로 저장한다.
        v.add(" 여름 ");
        v.add(" 가을 ");
        v.add(" 겨울 ");
        v.add(" 여름 ");   // 여름을 중복 시켜 보았다.
    }
 
    void out(){
        for(int i=0 ; i < v.size() ; i++){    // v.size() 는 배열변수.length() 와 의미가 같다.
            Object obj = v.get(i);            // get(); 데이터 가지고 오기
            String season = (String)obj;
            System.out.println(" v.get( " + i + " ) : " + season);
        }
    }
    
    public static void main(String[] args){
        ListS1 ls1 = new ListS1();
        ls1.in();
        ls1.out();
    }
}

Note : ListS1.java uses unchecked or unsafe operations.

     ListS1.java 는 확인되지 않았거나 안전하지 않은 작동입니다.

Note : Recompile with -Xlint : unchecked for details.

     자세한 내용은 -Xlint:unchecked 으로 다시 컴파일 하세요.

라는 메세지가 출력이 되어도 컴파일은 되었고, 실행도 됩니다.

( 제네릭 Gneric은 밑에 내용에서 다루겠습니다. )

출력에서 알 수 있는 내용으로

입력한 순서대로 출력이 되고, 중복이 허용되어서 저장이 됩니다.

-Xlint : unchecked 가 신경 쓰인다면,

javac -Xlint : unchecked 파일이름.java 하면 상세 내용을 알 수 있습니다.

warning : [unchecked] unchecked call to add(E) as a member of the raw type Vector

경고 : [확인되지않음] 원시 Vector 타입의 일원(멤버)으로 add(E) 에 대한 미확인 호출

where E is a type-variable:

여기서 E 는 타입-변수 입니다.

E extends Object declared in class Vector

E 는 Vector 클래서에서 선언된 Object 를 상속받습니다.

(이 역시 Generic 에 대한 내용으로 밑에서 설명하겠습니다.)

---

① Generic

import java.util.*;
 
class ListS2{
    
    Vector<String> v = new Vector<String>();    // Generic
                                                // jdk 5.0(=1.5이상)
    void in(){
        v.add(" 봄 ");
        v.add(" 여름 ");
        v.add(" 가을 ");
        v.add(" 겨울 ");
        v.add(" 여름 ");
    }
 
    void out(){
        for(int i=0 ; i < v.size() ; i++){
            /*Object obj = v.get(i);            // Generic
              String season = (String)obj;*/
            String season = v.get(i);
            System.out.println(" v.get( " + i + " ) : " + season);
        }
    }
    
    public static void main(String[] args){
        ListS2 ls2 = new ListS2();
        ls2.in();
        ls2.out();
    }
}

내용상으로는 위에와 같은 내용의 로직이다.

Generic 을 이용하여 Note : 메세지도 나오지 않게 되었다.

Generic 제네릭이란 ?

클래스나 메소드에 자료형을 매개변수 형식으로 사용할 수 있는 기능입니다.

SUN (자바가 오라클에 들어가기전) 에서는 jdk5.0(=1.5) 버전 이상에서는

컬렉션 프레임워크 사용시에 제네릭( Generic / 포괄적인 ) 을 권장하고 있습니다.

그래서 Generic 은 왜 좋을까??

1) 제네릭은 동적으로 타입이 정해지지 않는다.

   즉 , 컴파일시에 타입이 정해지기 때문에 보다 안전하게 프로그래밍 할 수 있다.

2) 그렇기에 타입 충돌 문제를 방지 할 수 있다.

3) 결국 프로그래밍중에 타입 캐스팅 (= 형변환 ) 절차가 필요없고,

ClassCastException 을 방지 할 수 있다.

( Exception 에 대해서는 나중에 설명하겠습니다. )

---

② Enhanced Loop ( 강화된 반복분 )

import java.util.*;
 
class ListS3{
    
    Vector<String> v = new Vector<String>();
                                                
    void in(){
        v.add(" 봄 ");
        v.add(" 여름 ");
        v.add(" 가을 ");
        v.add(" 겨울 ");
        v.add(" 여름 ");
    }
 
    void out1(){
        for(int i=0 ; i < v.size() ; i++){
            String season = v.get(i);
            System.out.println(" season : " + season);
        }
    }
 
    void out2(){
        for(String season : v){  // Enhanced Loop(jdk5.0 이상) , void out1() 과 같은 내용이다.
            System.out.println(" season : " + season);
        }
    }
 
    int is[] = {1 , 2 , 3 , 4 , 5};
 
    void out3(){
        for(int data : is){            // 고정 배열에서도 사용 가능하다.
            System.out.println(" data : " + data);
        }
    }
    
    public static void main(String[] args){
        ListS3 ls3 = new ListS3();
        ls3.in();
        ls3.out1();
        System.out.println("");
        ls3.out2();
        System.out.println("");
        ls3.out3();
    }
}

저번에 포스팅 했던 제어문 - 반복문에서 했던 

for(초기식 ; 조건식 ; 증감식){} 보다 훨씬더 간결하게 표현 할 수 있다.

---

③ Boxing ( AutoBoxing / UnBoxing )

import java.util.*;
 
class ListS4{
    
    Vector<Integer> v = new Vector<Integer>();
 
    void in(){                     // JVM이 자동으로 해준다. ↓
        v.add(10);                 // AutoBoxing (jdk5.0 이상)
        v.add(new Integer(20));    // int a = 20 → new Interger(a)
        v.add(new Integer(30));    // ← Boxing 개발자가 직접 해야한다.
    }                              // 현재는 할 필요 없다.
 
    void out1(){
        for(Integer it : v){
            int a = it.intValue(); // jdk5.0미만에서는 직접 했었다.
            int b = a;             // UnBoxing (jdk5.0 이상)
            System.out.println("1. b : " + b);
        }
    }
 
    void out2(){
        for(int b : v){            // UnBoxing (jdk5.0 이상)
            System.out.println("2. b : " + b);
        }
    }
 
    public static void main(String[] args){
        ListS4 ls4 = new ListS4();
        ls4.in();
        ls4.out1();
        System.out.println("");
        ls4.out2();
    }
}

Note: ListS4.java uses or overrides a deprecated API.

참고 : ListS4.java는 더 이상 사용되지 않는 API를 사용하거나 재정의합니다.

Note: Recompile with -Xlint:deprecation for details.

참고 : 자세한 내용은 -Xlint:deprecation 으로 다시 컴파일 하세요.

위의 제네릭 부분과 마찬가지로

Note : ~ 라는 메세지가 출력이 되어도 컴파일은 되었고, 실행도 됩니다.

하지만 또 왜 그런지 궁금 하겠죠??

아니라면 건너 뛰어 주시구요.

저는 궁금하기 때문에 찾아 보았습니다.

javac -Xlint:deprecation 파일이름.java 로 컴파일 해봅시다.

warning : [deprecation] Integer(int) in Integer has been deprecated

경고 : [반대 / 항의] Integer(int) 가 더 이상 사용되지 않고 있습니다.

deprecated :  중요도가 떨어져 더 이상 사용되지 않고 앞으로는 사라지게 될

v.add(new Integer(숫자));

jdk5.0 (=1.5) 이상에서는 더 이상 사용되지 않다고 합니다.

그렇다면 위에 있는 로직을 현재 사용되고 있는 형식으로 바꾸어 주어야 겠습니다.

import java.util.*;
 
class ListS4_2{
    
    Vector<Integer> v = new Vector<Integer>();
 
    void in(){
        v.add(10);           // AutoBoxing (jdk5.0 이상)
        v.add(20);           // int a = 20 → new Interger(a)
        v.add(30);
    }
 
    void out1(){
        for(Integer it : v){
            //int a = it.intValue(); jdk5.0미만에서는 직접 했었다.
            int b = it;              // UnBoxing (jdk5.0 이상)
            System.out.println("1. b : " + b);
        }
    }
 
    void out2(){
        for(int b : v){              // UnBoxing (jdk5.0 이상)
            System.out.println("2. b : " + b);
        }
    }
 
    public static void main(String[] args){
        ListS4_2 ls4 = new ListS4_2();
        ls4.in();
        ls4.out1();
        System.out.println("");
        ls4.out2();
    }
}

그래서 AutoBoxing 과 UnBoxing 은 무엇이냐?

1) AutoBoxing (오토박싱)   

- 상자를 자동으로 꾸리다.

- 기본형(Primitive) 타입의 변수를 ' Wrapper Class ' 로 바꾸어 주는 것.

(1. Wrapper Class 는 나중에 하겠습니다. 

죄송합니다. 연동되어 있는게 많으니 설명하는 것도 일이네요 ; - ; )

(2. 기본형(Primitive) 타입에는 8가지가 있는 것을 지난번 포스팅에서 다루었습니다.)

(3. 그렇다면 ' Wrapper Class ' ( 랩퍼클래스 / 래퍼클래스)에도 8가지가 있겠군요!!)

- char만 유일하게 String으로 박싱이 안된다.

2) UnBoxing (언박싱)

- 상자에서 내용물을 꺼낸다.

- ' Wrapper Class ' 타입의 값을 기본형(Primitive) 타입으로 바꾸어 주는 것.

그래도 아직 감이 안잡힐까봐, 한번 로직을 작성해 보았습니다.

이해가 가시나요? 복습을 하시다 보면 감이 오실 겁니다.

④ remove / clear ( 제거 / 삭제 / 깨끗 )

import java.util.*;
 
class ListS5{
    
    Vector<Integer> v = new Vector<Integer>();// 가변배열 Vector (1)선언 + (2)생성
    int is[] = {1 , 2 , 3 , 4 , 5};           // 고정배열 Array  (1)선언 + (2)생성 + (3)초기화
    
    void in(){
        for(int i : is){
            v.add(i);                         // 가변배열 Vector (3)초기화
        }
    }
 
    void out1(){
        v.remove(2); // 2번 자리에 있는 배열의 내용을 삭제한다. 0 1 2 이기 때문에 3이 사라진다.
        for(int i : v){
            System.out.println("1. i : " + i);
        }
    }
 
    void out2(){
        v.clear();        // 배열 안에 있는 모든 내용을 삭제한다.
        v.add(10);        // 그리고 새로 2개를 추가하였다.
        v.add(20);
        for(int i : v){
            System.out.println("2. i : " + i);
        }
    }
 
    public static void main(String[] args){
        ListS5 ls5 = new ListS5();
        ls5.in();
        ls5.out1();
        System.out.println("");
        ls5.out2();
    }
}

remove 를 이용하면 , 배열 안의 하나의 값을 지우고,

clear 을 이용하면 , 배열 안의 모든 값을 지웁니다.