JAVA-컬렉션 프레임워크-List

22 Feb 2021

🔷컬렉션 프레임워크

- 자료구조를 사용해 객체들을 효율적으로 관리할 수 있도록 인터페이스와 구현 클래스를 java.util 패키지에서 제공
- 프레임워크 : 사용방법을 정해놓은 라이브러니
- 주요인터페이스: List, Set, Map 컬렉션
🔸 collection : 자료구조, 디자인 패턴 ![컬렉션](https://user-images.githubusercontent.com/65608960/108650209-63d1a480-7502-11eb-9794-421962b6eb09.JPG)

✔ List 컬렉션

- 객체를 인덱스로 관리
- 저장용량이 자동으로 증가하면서 객체 저장 시 자동 인덱스 부여
- 추가,삭제, 검색 위한 다양한 메소드 제공
- 객체 자체를 저장하는 것이 아닌 객체 번지 참조(null도 저장가능)

Lsit

❗ 가장 많이사용하는 List : ArrayList

E : the type of elements in this list => 참조형 자료형을 적으면 된다

  // 제네릭스(Generics) : 타입(참조 자료형) 인자
  // <E> : Element(요소) => String
  // List<String> list = new ArrayList<String>(); // (O)
     List<String> list = new ArrayList<>(); // (O)
  // List<> list = new ArrayList<>(); // (X)
  // List<> list = new ArrayList<String>(); // (X)

💢 List 생성 및 요소 출력,요소 추가.삭제

코드

  package com.javateam.jse;

  import java.util.ArrayList;
  import java.util.List;

  public class JavaEx44 {

      public static void main(String[] args) {
            
          //List list = new ArrayList(); // 리스트 객체 생성(선언) , 리스트 : 인터페이스 
            
          // 제네릭스(Generics) : 타입(참조 자료형) 인자
          // <E> : Element(요소) => String
          // ex) String arr[] = new String[10];
          // List<String> list = new ArrayList<String>(); // (O)
          List<String> list = new ArrayList<>(); // (O)
          //List<? extends String> list = new ArrayList<>(); // 경우에 맞게 적용(O)
          //List<?> list = new ArrayList<>(); // 경우에 맞게 적용(O)
          // List<> list = new ArrayList<>(); // (X)
          // List<> list = new ArrayList<String>(); // (X)


          // 요소(element) 추가
          // list.add(1); // (X) 요소 => String 이므로 
          // list.add(1.0); // (X) 요소 => String 이므로 
          // list.add(1+""); // (O) 요소 => String 변환(casting)
          // 요소의 중복을 허용한다
          // 가변 배열
          list.add("멩");
          list.add("배현");
          list.add("만두");
          list.add("뚱보");
          list.add("뗀");
          list.add("무민");
          list.add("코끼리");
          list.add("달팽이"); // 중복
          list.add("달팽이"); // 중복
          list.add("밍키");
            
          System.out.print("리스트 전체 요소 : ");
          for(String s : list) {
          System.out.print(s + ", ");
          }System.out.println();
          System.out.println("리스트의 크기 (길이) : " + list.size()); 		
          System.out.println("리스트의 첫번째 요소 : "+ list.get(0));	
          System.out.println("리스트의 두번째 요소 : "+ list.get(1));		
          System.out.println("리스트의 마지막 요소 : "+list.get(list.size()-1));
            
          // 요소의 삭제	
          list.remove(1); // 인덱스로 삭제
            
          System.out.println("요소 삭제 후 리스트의 크기 (길이) : " + list.size());
          System.out.println("요소 삭제 후 리스트의 두번째 요소 : "+ list.get(1));
            
          list.remove("달팽이"); // 중복된 요소 삭제시 1개만 삭제됨	
          System.out.println("요소 '달팽이'삭제 후 리스트의 크기 (길이) : " + list.size());

          // List의 요소 전체 삭제 => 리스트 객체 삭제가 아니라 "요소" 삭제 => add로 다시 요소 넣을수 있다
          list.clear();
          System.out.println("요소 전체 삭제 후 리스트의 크기(길이) : " + list.size());
            
          list.add("달퐁이");
          System.out.println("요소 '달퐁이' 추가 후 리스트의 크기(길이) : " + list.size());
            
      }

  }

▶ List 생성 및 요소 출력,요소 추가.삭제 정리

- 요소 추가 : .add(문자열);
- 요소 삭제 : .remove(인덱스);
- List의 요소 전체 삭제 : .clear(); => 리스트 객체 삭제가 아니라 "요소" 삭제

▶ 위 코드 결과창 (Console) List_1

💢 List 전체 요소 출력(나열)

코드

      package com.javateam.jse;

      import java.util.ArrayList;
      import java.util.Iterator;
      import java.util.List;

      public class JavaEx45 {

          public static void main(String[] args) {
                
                
              List<String> list = new ArrayList<>(); // (O)
            
              list.add("멩");
              list.add("배현");
              list.add("만두");
              list.add("뚱보");
              list.add("뗀");
              list.add("무민");
              list.add("코끼리");
              list.add("달팽이"); 
              list.add("달팽이"); 
              list.add("밍키");
                
              // 리스트 요소 전체 나열 1) 
              // for 문 이용
      //		for(int i=0; i<list.size(); i++) {
      //			System.out.print(list.get(i) + ", ");
      //		}
                
              // 리스트 요소 전체 나열 2) 
              // iterator(반복자) 패턴 방식 : 다음 요소 검색 방식
              // for-each문 사용
      //		for(String s : list) {
      //			System.out.print(s + ", ");
      //		}
                
              // 리스트 요소 전체 나열 3) 
              // iterator(반복자) 패턴 방식 : 다음 요소 검색 방식  (오리지널)
      //		Iterator<String> it = list.iterator();
                
              // while문 이용
      //		while(it.hasNext()) {
      //			System.out.print(it.next() + ", ");
      //		}
                
              // for문 이용 => ; 꼭 붙혀야 한다 
      //		for(;it.hasNext();) {
      //			System.out.print(it.next() + ", ");
      //		}
                
              // 리스트 요소 전체 나열 4) 
              // forEach => 함수형  프로그래밍(람다(lambda)대수 프로그래밍 방식)
      //		list.forEach(x->System.out.print(x + ", ")); // (O)
                
              list.forEach(System.out::print); // (O) 위보다 간결하게 but 띄어쓰기 못한다 => 기본인자만 사용가능
              list.forEach(System.out::println); // (O)
              // list.forEach(System.out::println("A")); // (X) (추가되는)인자 쓰면 안된다
          }

      }

▶ List 전체 요소 출력(나열) 방법 정리

- 1) for 문 이용
- 2) for-each문 사용 (iterator(반복자) 패턴 방식 : 다음 요소 검색 방식)
- 3) iterator(반복자) 패턴 방식 : 다음 요소 검색 방식  (오리지널)
        - while문 이용
        - for문 이용
- 4) forEach => 함수형  프로그래밍(람다(lambda)대수 프로그래밍 방식) 이용
        - 띄어쓰기 못한다 => 기본인자만 사용가능

💢 배열 => 리스트(List)로 치환

코드

package com.javateam.jse;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class JavaEx46 {

	public static void main(String[] args) {
		
		// 배열 초기화
		String home[] = { "멩", "배현", "만두", "뚱보", "뗀", "무민", "코끼리", "달팽이", "달팽이", "밍키"};
		List<String> list = new ArrayList<>(); // (O)		
		// List<String> list = new LinkedList<>(); // 삽입/삭제가 많은 리스트 만들 때 
		
	
//		// 배열 => 리스트(List)로 치환
//		list = Arrays.asList(home);		
		
		// 배열을 리스트로 치환했을 때 바로 요소 추가 할 경우 예외가 발생한다
		// java.lang.UnsupportedOperationException 예외 발생
		// list.add("뿡뿡"); 
		
		// 배열을 리스트로 치환했을 때 요소 추가방법 
		// list.addAll(home); // (X) 컬렉션이 아니기 때문에 에러
		list.addAll(Arrays.asList(home)); // (O)
		list.add("뿌웅");
		list.set(2, "뿡빵"); // set : 선택한 인덱스에 요소 삽입
		
		// 주의) ArrayList는 (중간)삽입(끼어들기)/삭제시에는 성능이
		// LinkedList에 비해 떨어진다 => 삽입/삭제 빈번한 리스트(ex: 음악순위,영화순위 등) 
		// => LinkedList 권장 (삽입/삭제가 많은 리스트에 최적화(전문화))	
		
		list.forEach(e->System.out.print(e + " ")); // (O)
		
	}

}

▶ 배열 => 리스트(List)로 치환 정리

- 배열을 리스트로 치환했을 때 바로 요소 추가 할 경우 예외가 발생한다
- 배열을 리스트로 치환했을 때 요소 추가방법 
    1) .addAll(Arrays.asList(리스트)) 처리 후 
    2) .add(요소) , .set(인덱스,요소) 이용하여 추가 
- 주의) ArrayList는 (중간)삽입(끼어들기)/삭제시에는 성능이 inkedList에 비해 떨어진다 
    => 삽입/삭제 빈번한 리스트(ex: 음악순위,영화순위 등) => LinkedList 권장 (삽입/삭제가 많은 리스트에 최적화(전문화))

💢 리스트(List) 정렬

코드

  package com.javateam.jse;

  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;

  public class JavaEx47 {

      public static void main(String[] args) {
            
          // 배열 초기화
          String home[] = { "멩", "배현", "만두", "뚱보", "뗀", "무민", "코끼리", "달팽이", "달팽이", "밍키"};
          List<String> list = new ArrayList<>(); // (O)		
            
          list.addAll(Arrays.asList(home)); // (O)
          list.add("뿌웅");
          list.set(2, "뿡빵"); // set : 선택한 인덱스에 요소 삽입
            
          // 정렬(sorting,ordering) 
            
          // list.sort(Comparator.naturalOrder()); // since java 1.8
          // 자연 정렬(오름차순(ascending)정렬) : 코드순(ex.UTF-8)으로 정렬
            
          // list.sort(Comparator.reverseOrder()); // since java 1.8
          // 내림차순(desending) 정렬 : 코드 역순 정렬
            
          // 옛날 방식 : Collections 사용 => 호환성이 좋다
          // Collections.sort(list); // 오름차순 정렬
            
          // 익명클래스 compareTo 사용		
  //		Collections.sort(list, new Comparator<String>() { 
  //
  //			@Override
  //			public int compare(String o1, String o2) {
  //				// return o1.compareTo(o2); // 오름차순
  //				return o2.compareTo(o1); // 내림차순
  //			}			
  //		});
                    
          // list.forEach(e->System.out.print(e + " ")); // (O)
            
          // 리스트 -> 스트림으로 치환 : 더이상 리스트가 아니다
          //list.stream().sorted().forEach(e->System.out.print(e + " ")); // 오름차순
          // list.stream().sorted(Comparator.reverseOrder()).forEach(e->System.out.print(e + " "));
          // 내림차순
            
            
          // compareTo : 원래는 익명 클래스 but 한줄로 작성
          //list.sort((x1,x2)->x1.compareTo(x2)); // 오름차순
          list.sort((x1,x2)->x2.compareTo(x1)); // 내림차순
          list.forEach(x->System.out.print(x + " ")); 
      }

  }

▶ 리스트(List) 정렬 정리

- 정렬(sorting,ordering) 사용
- 오름차순(ascending)정렬 : .sort(Comparator.naturalOrder()); 사용
- 내림차순(desending) 정렬 : .sort(Comparator.reverseOrder()); 사용
❗ 옛날 방식 : Collections 사용 => 호환성이 좋다
- 오름차순 정렬 : Collections.sort(리스트); 사용
- 익명클래스 compareTo 사용	
❗ 리스트 -> 스트림으로 치환 : 더이상 리스트가 아니다
- 오름차순 : .stream().sorted() 사용
- 내림차순 : .stream().sorted(Comparator.reverseOrder()) 사용

💢 리스트(List) 요소 존재 여부 확인

코드

  package com.javateam.jse;

  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;

  public class JavaEx48 {

      public static void main(String[] args) {
            
          // 배열 초기화
          String home[] = { "멩", "배현", "만두", "뚱보", "뗀", "무민", "코끼리", "달팽이", "달팽이", "밍키"};
          List<String> list = new ArrayList<>(); // (O)		
            
          list.addAll(Arrays.asList(home)); // (O)
            
          // 요소 존재 여부 확인 contains => 띄어쓰기 제거해야한다 -> trim() 사용
          //System.out.println("요소 존재 여부 :" + list.contains("배현".trim()));
            
          // 요소가 위치하고있는 인덱스 번호 출력 : indexOf => 중복된 요소가 있을경우 앞에 위치한 요소의번호 출력된다
          //System.out.println("특정 요소의 index : " + list.indexOf("만두"));
          //System.out.println("중복된 요소의 index : " + list.indexOf("달팽이"));
            
            
          // 리스트의 요소 존재 여부 확인 : isEmpty() => true or false 로 반환
          //list.clear();		
          //System.out.println("리스트 요소 존재 여부 : " + list.isEmpty());
            
          // 중복된 요소의 마지막 인덱스 반환 : lastIndexOf
          //System.out.println("(중복)특정 요소의 마지막 요소의 index :  " + list.lastIndexOf("달팽이"));
            
          // listIterator() : 리스트 요소 나열 ,정렬 X
          // list.listIterator();
            
          // 리스트 요소 역순 나열,정렬 X
  //		ListIterator<String> lit = list.listIterator(list.size());
  //		while(lit.hasPrevious()) {
  //			System.out.print(lit.previous()+ " ");
  //		}
            
          // subList : 요소 일부분 추출 -> 마지막 인덱스 요소는 제외 하고 출력된다
          // 주의) toIndex =>미포함(기본값)
          //list.subList(0, 3).forEach(x->System.out.print(x + " "));
            
          // 리스트(List) => 배열로 치환
          // 방법 1) object배열 생성 하여 치환
  //		Object  otherHome[] = new Object[list.size()];
  //		otherHome = list.toArray();
  //		System.out.println("otherHome 첫번째 요소 : " + otherHome[0]);
  //		for(Object s : otherHome) {
  //			System.out.print( s + " ");
  //		}
            
          // 방법 2) String배열 생성 하여 치환
          String otherHome[] = new String[list.size()];
          otherHome = list.toArray(otherHome);
          for(String s : otherHome) {
              System.out.print(s + " ");
          }
      }

  }

▶ 리스트(List) 요소 존재 여부 확인 정리

- .contains("요소".trim())); : contains => 띄어쓰기 제거해야한다 -> trim() 사용 
- .indexOf("요소") : 요소가 위치하고있는 인덱스 번호 출력 , 중복된 요소가 있을경우 앞에 위치한 요소의번호 출력된다
- .isEmpty() : 리스트의 요소 존재 여부 확인 => true or false 로 반환
- .lastIndexOf("중복요소") : 중복된 요소의 마지막 인덱스 반환 
- .listIterator(list.size()) : 리스트 요소 나열 ,정렬 X
- subList(시작인덱스, 마지막인덱스) : 요소 일부분 추출 -> 마지막 인덱스 요소는 제외 하고 출력된다
- 리스트(List) => 배열로 치환
    1) object배열 생성 하여 치환
    2)String배열 생성 하여 치환

💢 리스트(List) 요소 혼합

코드

  package com.javateam.jse;

  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;

  public class JavaEx49 {

      public static void main(String[] args) {
            
          // 배열 초기화
          String home[] = { "멩", "배현", "만두", "뚱보", "뗀", "무민", "코끼리", "달팽이", "달팽이", "밍키"};
          List<String> list = new ArrayList<>(); // (O)		
          list.addAll(Arrays.asList(home)); // (O)
            
            
          // shuffle() : 출력 할때 마다 배열의 요소를 무작위로 혼합한다 
          Collections.shuffle(list);		
          list.forEach(x->System.out.print(x+ " "));			
      }
  }

▶ 리스트(List) 요소 혼합 정리

- Collections.shuffle(리스트) : shuffle() : 출력 할때 마다 배열의 요소를 무작위로 혼합한다 

💢 리스트(List) 중복 배제,특정조건 검색

코드

  package com.javateam.jse;

  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;

  public class JavaEx50 {

      public static void main(String[] args) {
            
          // 배열 초기화
          String home[] = { "멩", "배현", "만두", "뚱보", "뗀", "무민", "코끼리", "달팽이", "달팽이", "밍키"};
          List<String> list = new ArrayList<>(); // (O)		
          list.addAll(Arrays.asList(home)); // (O)
            
            
          // list -> stream 치환(~화)
          // distinct() : 중복 배제
          //list.stream().distinct().forEach(x->System.out.print(x + " "));
            
          // filter() : 특정 조건 검색
          //list.stream().distinct().filter(x->x.contains("달")).forEach(x->System.out.print(x + " "));
            
          // sorted(Comparator.reverseOrder()) : 역순 정렬
          list.stream().distinct().sorted(Comparator.reverseOrder())
                              .forEach(x->System.out.print(x + " "));

      }

  }

▶ 리스트(List) 중복 배제,특정조건 검색 정리

- list => stream 치환(~화)
    - list.stream().distinct() : distinct() : 중복 배제
    - list.stream().distinct().filter(x->x.contains("특정조건 요소")) : filter() : 특정 조건 검색

💢 Queue , Stack

코드

  package com.javateam.jse;

  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Queue;
  import java.util.Stack;

  public class JavaEx51 {

      public static void main(String[] args) {
            
          // 배열 초기화
          String home[] = { "멩", "배현", "만두", "뚱보", "뗀", "무민", "코끼리", "달팽이", "달팽이", "밍키"};
            
          Queue<String> qu = new LinkedList<>();
          qu.addAll(Arrays.asList(home));
            
          // Queue : FIFO(First In First Out)
          // 리스트의 한 쪽 끝에서는 자료가 삽입되고 다른 한 쪽에서는 자료가 삭제되는 구조
          //qu.forEach(x->System.out.print(x+ " "));
            
          System.out.println("--------------------");
            
          // Stack : LIFO(Last In First Out)
          // 자료의 삽입과 삭제가 한쪽 끝에서만 일어나는 구조
          Stack<String> st = new Stack<>();
          // st.addAll(Arrays.asList(home));
            
          // 요소를 0번 인덱스 자리에  추가
          st.push("안농");
          st.push("반가워");
            
          System.out.println("크기 : " + st.size());
          while (!st.isEmpty()) {
              System.out.print(st.pop() + " ");
          }			
      }
  }

▶ Queue , Stack 정리

- Queue : FIFO(First In First Out) : 리스트의 한 쪽 끝에서는 자료가 삽입되고 다른 한 쪽에서는 자료가 삭제되는 구조
- Stack : LIFO(Last In First Out) : 자료의 삽입과 삭제가 한쪽 끝에서만 일어나는 구조
        - .push(요소) : 요소를 0번 인덱스 자리에  추가