13. List 인터페이스 (ArrayList)

- ArrayList

• 저장순서 유지
• 중복 허용

- 재네릭을 지정하지 않은 경우

package chap13;

import java.util.ArrayList;

public class Sample01 {
	/*
		List인터페이스 : ArrayList
		저장순서 유지, 중복 허용
	*/
	
	public static void main(String[] args) {
		// 재네릭을 지정하지 않으면 모든 자료를 추가할 수 있음
		ArrayList list = new ArrayList();
		boolean add = list.add(5);
		System.out.println("객체 추가 : " + add);
		list.add(5);
		list.add(2);
		list.add(1);
		list.add(3);
		list.add("abc");
		System.out.println(list);
		
		// 재네릭 타입을 지정하지 않으면 Object 타입으로 받아온다.
		Object object = list.get(3);
		int idx0 = (int) list.get(0); // 타입캐스팅 필요
		int idx1 = (int) list.get(1); // 타입캐스팅 필요
		System.out.println(idx0 + idx1);
	}
}


값
객체 추가 : true
[5, 5, 2, 1, 3, abc]
10

 

 

- 재네릭을 지정한 경우

• ArrayList<E> 타입이 결정 되지않은 상태인데,
• E에 타입을 정하면 그때 타입이 결정된다.

package chap13;

import java.util.ArrayList;

public class Sample02 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("자바");
		list.add("오라클");
		list.add("JSP");
		list.add("스프링");
		list.add("통합구현");
		System.out.println(list);
		
		// 컬렉션의 크기
		System.out.println("컬렉션의 크기 : " + list.size());
		
		// 재네릭 타입을 지정하면 지정된 타입으로 받아온다.
		// 타입캐스팅 불필요
		String str = list.get(0);
//		list.add('a'); // 지정하지 않은 타입은 에러가 난다.
//		list.add(10);
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}

값
[자바, 오라클, JSP, 스프링, 통합구현]
컬렉션의 크기 : 5
자바
오라클
JSP
스프링
통합구현

 

 

 

- list.add 지정해서 값 나타내기

package chap13;

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

public class Sample03 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple");
		list.add("kiwi");
		list.add("grape");
		list.add("banana");
		list.add("orange");
		
		System.out.println(list);
		// [apple, kiwi, grape, banana, orange]
		
		// 지정된 위치 값 추가
		list.add(2, "MELON");
		System.out.println(list);
		// [apple, kiwi, MELON, grape, banana, orange]

		// 지정된 위치 값 수정
		list.set(0, "사과");
		System.out.println(list);
		// [사과, kiwi, MELON, grape, banana, orange]
	}
}

값
[apple, kiwi, grape, banana, orange]
[apple, kiwi, MELON, grape, banana, orange]
[사과, kiwi, MELON, grape, banana, orange]

 

 

- 삭제하기

package chap13;

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

public class Sample04 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple");
		list.add("kiwi");
		list.add("grape");
		list.add("banana");
		list.add("orange");
		
		// 인덱스 번호로 삭제
		list.remove(1); // kiwi 삭제
		System.out.println(list);
		
		// 지정한 객체 삭제
		list.remove("apple");
		System.out.println(list);
		
		// 리스트가 비어있나?
		System.out.println(list.isEmpty());
		
		// 리스트의 모든 객체 삭제
		list.clear();
		System.out.println(list.isEmpty());
		System.out.println(list);
	}
}

값
[apple, grape, banana, orange]

[grape, banana, orange]

false

true

[]

 

 

- remove 유의 사항

package chap13;

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

public class Sample05 {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
	
		list.remove(1); // 인덱스 번호로 인식
		System.out.println(list);
		
//		list.remove(new Integer(3)); // deprecated 
		list.remove(Integer.valueOf(3));
		System.out.println(list);
	}
}

값
[1, 3, 4, 5]
[1, 4, 5]

 

 

 

- enum 사용했을때

package sec01;

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

import sec01.Apple.Color;

public class Sample06 {
	public static void main(String[] args) {
		List<Apple> apples = new ArrayList<Apple>();
		apples.add(new Apple(Color.RED));
		apples.add(new Apple(Color.RED));
		apples.add(new Apple(Color.RED));
		apples.add(new Apple(Color.RED));
		System.out.println(apples);
		
		apples.remove(new Apple(Color.RED));
		System.out.println(apples);
	}
}

class Apple {
	public enum Color{RED, BLUE, GREEN, YELLO}
	
	Color color;
	
	public Apple(Color color) {
		this.color = color;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Apple other = (Apple) obj;
		return color == other.color;
	}

	@Override
	public int hashCode() {
		return Objects.hash(color);
	}

	@Override
	public String toString() {
		return "Apple [color=" + color + "]";
	}
	
}

값
[Apple [color=RED], Apple [color=RED], Apple [color=RED], Apple [color=RED]]
[Apple [color=RED], Apple [color=RED], Apple [color=RED]]

equals를 오버라이딩 해주기전엔 삭제가 안되지만,

equals를 오버라이딩 해주면 삭제 됨.

 

 

 

- addAll()

package sec02;

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

public class Sample01 {
	public static void main(String[] args) {
		List<String> list1 = new ArrayList<String>();
		list1.add("zz");
		list1.add("cc");
		list1.add("bb");
		System.out.println(list1);

		List<String> list2 = new ArrayList<String>();
		list2.add("11");
		list2.add("22");
		list2.add("33");
		System.out.println(list2);
		
		// list1에 매개값으로 주어진 컬렉션의 모든 요소 추가
		// 매개변수 타입 : Collection (List, Set)
		// Collection<? extends E>
		// ? : 와일드 카드, 타입파라미터로 무엇이든 전달할 수 있다.
		// E : String 타입으로 결정된다.
		// Collection<? extends String>
		// 와일드 카드로 전달할 수 있는 타입변수는 String 또는 String상속(구현)타입
		
		list1.addAll(list2);
		System.out.println(list1);
		
		// Collection<? extends Number>
		// Collection<Number> : ok
		// Collection<Integer> : ok
		// Collection<Double> : ok
		// Collection<String> : 컴파일 에러
		
		// 원하는 인덱스 위치에 요소 추가
		List<String> list3 = new ArrayList<String>();
		list3.add("가");
		list3.add("나");
		list1.addAll(2, list3);
		System.out.println(list1);
		
	}
}

값
[zz, cc, bb]
[11, 22, 33]
[zz, cc, bb, 11, 22, 33]
[zz, cc, 가, 나, bb, 11, 22, 33]

 

 

- removeAll()

공통요소들 다 뺀다.

package sec02;

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

public class Sample02 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>(List.of("a", "b", "c", "b", "e"));
		List<String> param = new ArrayList<String>(List.of("b", "c", "k"));
		
		System.out.println(list);
		System.out.println(param);
		
		list.removeAll(param);
		System.out.println(list);
	}
}

값
[a, b, c, b, e]
[b, c, k]

[a, e]

 

 

 

- retainAll()

공통요소만 남긴다

package sec02;

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

public class Sample03 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>(List.of("a", "b", "c", "d", "e"));
		List<String> param = new ArrayList<String>( List.of("z", "b", "f", "c"));
		
		list.retainAll(param);
		System.out.println(list);
	}
}

값
[b, c]

 

 

- indexOf()

왼쪽에서부터 검색

 

- lastIndexOf

오른쪽에서부터 검색

 

- contains()

포함여부

package sec02;

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

public class Sample04 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple");
		list.add("kiwi");
		list.add("grape");
		list.add("banana");
		list.add("apple");
		list.add("orange");
		
		System.out.println(list);
		
		// 지정된 객체의 인덱스 반환 : 해당 객체가 없으면 -1 반환
		int idx1 = list.indexOf("apple"); // 0 왼쪽 -> 오른쪽 최초 발견 인덱스 반환
		System.out.println(idx1);
		
		int idx2 = list.indexOf("melon"); // -1
		System.out.println(idx2);
		
		int idx3 = list.lastIndexOf("apple"); // 오른쪽 -> 왼쪽
		System.out.println(idx3);
		
		// contains() 객체가 포함되어 있는지 여부
		if(list.contains("apple")) {
			System.out.println("사과가 포함되어 있음");
		}
		
		if(list.contains("melon")) {
			System.out.println("멜론이 포함되어 있음");
		} else {
			System.out.println("멜론을 포함하지 않음");
		}
	}
}

값
[apple, kiwi, grape, banana, apple, orange]
0
-1
4
사과가 포함되어 있음
멜론을 포함하지 않음

 

 

- clone()

clone()을 쓰기보다 객체를 하나더 만들어주자

package sec02;

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

public class Sample05 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple");
		list.add("kiwi");
		list.add("grape");
		list.add("banana");
		list.add("apple");
		list.add("orange");
		
		// list.clone(); 그냥 못쓰고 타입변환 해줘야함
		// clone()을 쓰기보다 하나더 생성하는게 낫다
		ArrayList<String> clone = (ArrayList<String>) ((ArrayList<String>)list).clone();
		System.out.println(clone);
		
		// 이 방법을 쓰자
		List<String> copy = new ArrayList<String>(list);
		System.out.println(copy);
	}
}

값
[apple, kiwi, grape, banana, apple, orange]
[apple, kiwi, grape, banana, apple, orange]

 

 

 

- subList()

• fromIndex부터 toIndex사이에 지정된 객체 리스트 반환
• toIndex는 포함되지 않는다

package sec02;

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

public class Sample06 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); //0
		list.add("kiwi"); //1
		list.add("grape"); //2
		list.add("banana"); //3
		list.add("orange"); //4
		
		List<String> subList = list.subList(1, 3);
		System.out.println(subList);
		
		List<String> subList2 = list.subList(0, list.size());
		System.out.println(subList2);
	}
}

값
[kiwi, grape]
[apple, kiwi, grape, banana, orange]

 

 

- Iterator<E>

- hasNext() [1]

다음 요소가 존재하는지의 여부

package sec02;

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

public class Sample06 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); //0
		list.add("kiwi"); //1
		list.add("grape"); //2
		list.add("banana"); //3
		list.add("orange"); //4
		
		Iterator<String> it = list.iterator();
		System.out.println(it.hasNext());
		System.out.println(it.next()); // 다음요소 : apple
		System.out.println(it.hasNext());
		System.out.println(it.next()); // 다음요소 : kiwi
		System.out.println(it.hasNext());
		System.out.println(it.next()); // 다음요소 : grape
		System.out.println(it.hasNext());
		System.out.println(it.next()); // 다음요소 : banana
		System.out.println(it.hasNext());
		System.out.println(it.next()); // 다음요소 : orange
		System.out.println(it.hasNext());
		
//		System.out.println(it.next()); 예외 발생 java.util.NoSuchElementException
	}
}

값
true
apple
true
kiwi
true
grape
true
banana
true
orange
false

hasNext() 없이 next()만 썼을 경우,

다음 요소가 없으면 예외 발생함

예외 문구 :  java.util.NoSuchElementException

 

- hasNext() [2]

 

package sec02;

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

public class Sample08 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); //0
		list.add("kiwi"); //1
		list.add("grape"); //2
		list.add("banana"); //3
		list.add("orange"); //4
		
		// 반복자 얻기
		Iterator<String> it = list.iterator();
		while (it.hasNext()) { // 반복할 요소가 있다면
			System.out.println(it.next());
		}
		
		// 1회 반복을 수행한 반복자 객체는 더 이상 반복되지 않는다.
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
		// 반복을 수행하려면 반복자를 다시 얻어야함
		it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

값
apple
kiwi
grape
banana
orange
apple
kiwi
grape
banana
orange

 

 

 

- forEachRemaining()

• 익명구현객체
• 람다식
• 메소드 참조 : 단순히 메소드에 파라미터를 전달할때만 가능

package sec02;

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

public class Sample09 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); //0
		list.add("kiwi"); //1
		list.add("grape"); //2
		list.add("banana"); //3
		list.add("orange"); //4
		
		// Consumer<? extends String>
		// String 또는 String 타입을 상속(구현)한 클래스타입
		// Consumer<? super String>
		// String 또는 String 타입의 상위클래스 또는 인터페이스
		// @FunctionalInterface : 추상메소드가 하나인 인터페이스, 람다식으로 표현할 수 있음
		Iterator<String> it = list.iterator();
		it.forEachRemaining(new Consumer<String>() {
			@Override
			public void accept(String t) {
				System.out.println(t.length());
			}
		});
		// 익명구현객체
		it = list.iterator();
		it.forEachRemaining(new Consumer<String>() {
			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		});
		
		// 람다식
		System.out.println("=============람다식============");
		it = list.iterator();
		it.forEachRemaining(t -> System.out.println(t));
		
		// 메소드 참조
		System.out.println("===========메소드 참조==========");
		it = list.iterator();
		it.forEachRemaining(System.out::println);
	}
}



값
5
4
5
6
6
apple
kiwi
grape
banana
orange
=============람다식============
apple
kiwi
grape
banana
orange
===========메소드 참조==========
apple
kiwi
grape
banana
orange

 

 

 

- 반복자 얻어서 문자열 해당하는 값 제거하기

package sec02;

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

public class Sample10 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana");
		list.add("orange");
		
		Iterator<String> it = list.iterator();
		// 문자열"e"로 끝나는 값 제거
		while (it.hasNext()) {
			if(it.next().endsWith("e")) it.remove();
		}
		System.out.println(list);
	}
}


값
[kiwi, banana]

 

 

 

- ListIterator<E>

• iterator()보다 개선됐다
• iterator()은 next()만 있는 반면 listIterator()는 뒤로도 갈 수 있다.

package sec02;

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

public class Sample11 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana");
		list.add("orange");
		
		ListIterator<String> it = list.listIterator();
		System.out.println("==========다음요소반복===========");
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
		// 만약 it.next 부분을 주석으로 막으면 실행안됨
		// 이전으로 갈 요소가 없기때문
		System.out.println("==========이전요소반복===========");
		while (it.hasPrevious()) {
			System.out.println(it.previous());
		}
		
		// nextIndex()가 위에오면 인덱스0번부터 시작
		// next()가 위에오면 인덱스1번부터 시작
		System.out.println("===========================");
		while (it.hasNext()) {
			System.out.println(it.nextIndex());
			System.out.println(it.next());
		}
		
		System.out.println("===========배열에 담기==========");
		it = list.listIterator();
		String[] strArr = new String[list.size()];
		while (it.hasNext()) {
			strArr[it.nextIndex()] = it.next();
		}
		System.out.println(Arrays.toString(strArr));
	}
}


값
==========다음요소반복===========
apple
kiwi
grape
banana
orange
==========이전요소반복===========
orange
banana
grape
kiwi
apple
===========================
0
apple
1
kiwi
2
grape
3
banana
4
orange
===========배열에 담기==========
[apple, kiwi, grape, banana, orange]

 

 

- 배열 얻기

package sec03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.IntFunction;

public class Sample01 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana");
		list.add("orange");
		
		// 이 방식으로 하지말 것
		Object[] array = list.toArray();
		System.out.println(Arrays.toString(array));
//		Object[] array2 = (String[]) list.toArray();

		// [2]
		String[] strArr = list.toArray(new String[0]);
		System.out.println(Arrays.toString(strArr));
		
		// [2]번의 방식과 다르지 않음 [2]방식으로 할것.
		String[] array2 = list.toArray(new IntFunction<String[]>() {
			@Override
			public String[] apply(int value) {
				return new String[value];
			}
		});
		System.out.println(Arrays.toString(array2));
	}
}

값
[apple, kiwi, grape, banana, orange]
[apple, kiwi, grape, banana, orange]
[apple, kiwi, grape, banana, orange]

 

 

 

- 정렬

• 역순정렬 : Collections.reverse()
• reverse()는 저장 순서만 뒤집음 || reverseOrder()와 다르다
• 오름차순 : Collections.sort()

package sec03;

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

public class Sample02 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana");
		list.add("orange");
		
		// 역순정렬
		Collections.reverse(list);
		System.out.println(list);
		
		// 기본정렬 - (문자열 : 사전순), (숫자 : 오름차순)
		Collections.sort(list);
		System.out.println(list);
		
	}
}


값
[orange, banana, grape, kiwi, apple]
[apple, banana, grape, kiwi, orange]

 

 

 

- 람다식으로 정렬

package sec03;

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

public class Sample03 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("app"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana11");
		list.add("orange2222");

		// 지정된 방법으로 정렬
		// 문자열 길이 오름차순
		list.sort(new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.length() - o2.length();
			}
		});
		System.out.println(list);
		
		// 람다식으로 
		// 문자열 길이 내림차순
		list.sort((o1, o2) -> {
			return o2.length() - o1.length();
		});
		System.out.println(list);
		
		// 문자열 길이 오름차순
		// 코드가 한줄인 경우 return과 중괄호를 생략할 수 있다.
		// return을 생략하면 중괄호를 반드시 생략해야함
		list.sort((o1, o2) -> o1.length() - o2.length());
		System.out.println(list);
		
	}
}

값
[app, kiwi, grape, banana11, orange2222]
[orange2222, banana11, grape, kiwi, app]
[app, kiwi, grape, banana11, orange2222]

 

 

 

- reverseOrder()

• 문자열 : 사전역순, 숫자 : 내림차순

package sec03;

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

public class Sample04 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana");
		list.add("orange");

		// 역순정렬
		// reverse()와 다름 || reverse()는 저장 순서만 뒤집음
		// 문자열 : 사전역순, 숫자 : 내림차순
		list.sort(Collections.reverseOrder());
		System.out.println(list);
	}
}

값
[orange, kiwi, grape, banana, apple]

 

 

 

- 회전, 위치바꾸기, 임의로 섞기

• 회전 : Collections.rotate()
• 두요소 위치 바꾸기 : Collections.swap()
• 임의로 섞기 : Collections.shuffle()

package sec03;

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

public class Sample05 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("apple"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana");
		list.add("orange");
		
		System.out.println(list);
		
		// 리스트 회전 (양수 : 오른쪽 || 음수 : 왼쪽)
		Collections.rotate(list, 2);
		System.out.println(list);
		
		Collections.rotate(list, -1);
		System.out.println(list);
		
		// 두 요소의 위치바꾸기
		Collections.swap(list, 1, 4);
		System.out.println(list);
		
		// 임의로 순서 섞어줌
		Collections.shuffle(list);
		System.out.println(list);
	}
}

값
[apple, kiwi, grape, banana, orange]

[banana, orange, apple, kiwi, grape]

[orange, apple, kiwi, grape, banana]

[orange, banana, kiwi, grape, apple]

[orange, grape, kiwi, banana, apple]

 

 

 

- 최대값, 최소값

• 최대값 : Collections.max()
• 최소값 : Collections.min()
• 문자열은 사전순서

package sec03;

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

public class Sample06 {
	public static void main(String[] args) {
		List<Integer> intList = new ArrayList<Integer>();
		intList.add(10);
		intList.add(13);
		intList.add(9);
		intList.add(15);
		intList.add(11);

		// 최대값
		int max = Collections.max(intList);
		
		// 최소값
		int min = Collections.min(intList);
		
		System.out.println(max);
		System.out.println(min);
		
		
		List<String> list = new ArrayList<String>();
		list.add("apple"); 
		list.add("kiwi"); 
		list.add("grape"); 
		list.add("banana");
		list.add("orange");
		
		// 문자열 최대값, 최소값은 사전순서
		System.out.println(Collections.max(list));
		System.out.println(Collections.min(list));
		
	}
}

값
15
9
orange
apple