Arrays 클래스

Array를 다루기 위한 메소드 제공

import java.util.Arrays;

asList

배열을 리스트로 변환

• 변환된 리스트 핸들링 시 원본 배열에도 영향 (원소 추가 및 삭제 불가)
• 원본 배열에 영향이 없게 하려면 List 객체 생성과 동시에 초기화

		/* asList : Array를 List로 변환 */
		String[] strArr1 = {"aaa", "bbb", "ccc"};
		String[] strArr2 = {"aaa", "bbb", "ccc"};
		
		List<String> strList1 = new ArrayList<String>();
		strList1 = Arrays.asList(strArr1);
		
		// 1. List 클래스의 메소드 사용 가능
		int index1 = strList1.indexOf("aaa");		// 0
		int index2 = strList1.indexOf("ddd");		// -1
		
		// 2. 변환된 List 핸들링 시 배열에도 영향이 있음
		strList1.set(0, "AAA");		// [AAA, bbb, ccc]
		//strList1.remove(1);		// UnsupportedOperationException
		//strList1.add("ddd");		// UnsupportedOperationException
		// > asList 메소드로 변환된 List는 원소가 추가되거나 삭제될 수 없음
		
		// 3. 원 배열에 영향이 없게 하려면 List 객체를 생성과 동시에 초기화
		List<String> strList2 = new ArrayList<String>(Arrays.asList(strArr2));
		
		strList2.set(0, "AAA");		// [AAA, bbb, ccc]
		strList2.remove(1);			// [AAA, ccc]
		strList2.add("ddd");		// [AAA, ccc, ddd]
				
		System.out.println(strList1.toString());		// [AAA, bbb, ccc]
		System.out.println(Arrays.toString(strArr1));	// [AAA, bbb, ccc]
		
		System.out.println(strList2.toString());		// [AAA, ccc, ddd]
		System.out.println(Arrays.toString(strArr2));	// [aaa, bbb, ccc]

toString, deepToString

배열의 element를 반환

• 1차원 배열은 toString, 다차원 배열은 deepToString 사용
• 다차원 배열에 toString 사용 시 주소값 반환

		/* toString, deepToString : Array의 element를 반환 */
		
		// 1. toString
		String[] strArr1 = {"aaa", "bbb", "ccc"};
		
		System.out.println(Arrays.toString(strArr1));		// [aaa, bbb, ccc]
		
		// 2. deepToString
		String[][] strArr2 = {{"aaa", "bbb", "ccc"}, {"ddd", "eee", "fff"}};
		
		System.out.println(Arrays.toString(strArr2));		// [[Ljava.lang.String;@74a10858, [Ljava.lang.String;@23fe1d71]
		System.out.println(Arrays.deepToString(strArr2));	// [[aaa, bbb, ccc], [ddd, eee, fff]]

equals, deepEquals

배열의 비교

• 1차원 배열은 equals, 다차원 배열은 deepEquals 사용
• 다차원 배열에 equals 사용시 false

		/* equals, deepEquals : Array의 비교 */
		
		// 1. equals
		int[] intArr1 = {1, 2, 3};
		int[] intArr2 = new int[] {1, 2, 3};
		
		System.out.println(Arrays.equals(intArr1, intArr2));	// true
		
		// 2. deepEquals
		int[][] intArr3 = {{1, 2, 3}, {4, 5, 6}};
		int[][] intArr4 = new int[][] {{1, 2, 3}, {4, 5, 6}};
		
		System.out.println(Arrays.equals(intArr3, intArr4));		// false
		System.out.println(Arrays.deepEquals(intArr3, intArr4));	// true

copyOf, copyOfRange

배열의 복사

• Arrays.copyOf(원본 배열, 새로운 배열의 길이)
• Arrays.copyOfRange(원본 배열, 시작 인덱스, 끝 인덱스) (단, 끝 인덱스 이전까지 복사)

		/* copyOf, copyOfRange : 배열의 복사 */
		int[] intArr = {1, 2, 3};
		String[] strArr = {"a", "b", "c"};
		
		// 1. Arrays.copyOf(원본 배열, 새로운 배열의 길이);
		int[] intArr1 = Arrays.copyOf(intArr, 2);	// [1, 2]
		int[] intArr2 = Arrays.copyOf(intArr, 3);	// [1, 2, 3]
		int[] intArr3 = Arrays.copyOf(intArr, 4);	// [1, 2, 3, 0]
		// > 숫자형 데이터 타입의 경우 원본 배열 초과하는 길이는 0으로 초기화
		
		String[] strArr1 = Arrays.copyOf(strArr, 2);	// [a, b]
		String[] strArr2 = Arrays.copyOf(strArr, 3);	// [a, b, c]
		String[] strArr3 = Arrays.copyOf(strArr, 4);	// [a, b, c, null]
		// > 문자형 데이터 타입의 경우 원본 배열 초과하는 길이는 null로 초기화
		
		// 2. Arrays.copyOfRange(원본 배열, 시작 인덱스, 끝 인덱스); > 단, 끝 인덱스 이전까지 복사
		int[] intArr4 = Arrays.copyOfRange(intArr, 0, 3);	// [1, 2, 3]
		int[] intArr5 = Arrays.copyOfRange(intArr, 1, 3);	// [2, 3]
		int[] intArr6 = Arrays.copyOfRange(intArr, 2, 5);	// [3, 0, 0]
		
		String[] strArr4 = Arrays.copyOfRange(strArr, 0, 3);	// [a, b, c]
		String[] strArr5 = Arrays.copyOfRange(strArr, 1, 3);	// [b, c]
		String[] strArr6 = Arrays.copyOfRange(strArr, 2, 5);	// [c, null, null]

fill

배열 채우기

• Arrays.fill(채울 배열, 채울 값)

		/* fill : 배열 채우기 */
		
		int[] intArr = new int[5];
		
		Arrays.fill(intArr, 7);		// [7, 7, 7, 7, 7]

sort

배열 정렬

import java.util.Collections;
import java.util.Comparator;

		/* sort : 배열 정렬하기 */
		
		// 1. 오름차순 정렬
		int[] intArr1 = {3, 4, 2, 1, 5};
		Arrays.sort(intArr1);	// [1, 2, 3, 4, 5]
		
		// 2. 특정 인덱스 구간만 오름차순 정렬
		int[] intArr2 = {3, 4, 2, 1, 5};
		Arrays.sort(intArr2, 2, 4);		// [3, 4, 1, 2, 5]
		
		// 3. 정렬 기준 부여하기 (Wrapper 클래스만 가능)
		// 3-1. Comparator 인터페이스 내림차순 정렬
		Integer[] integerArr = {3, 4, 2, 1, 5};
		Arrays.sort(integerArr, Comparator.reverseOrder());	// [5, 4, 3, 2, 1]
		
		// 3-2. Collections 클래스 내림차순 정렬
		String[] stringArr1 = {"c", "d", "b", "a", "e"};
		Arrays.sort(stringArr1, Collections.reverseOrder());	// [e, d, c, b, a]
		
		// 3-3. Comparator 인터페이스의 compare 메소드를 Override하여 정렬 조건 부여
		String[] stringArr2 = {"Hello", "Hi", "Bye"};
		Arrays.sort(stringArr2, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.length() - o2.length();
			}
		});														// [Hi, Bye, Hello]

binarySearch

배열의 인덱스 반환

• 사용 전 Arrays.sort()를 통한 정렬이 우선되어야 함

		/* binarySearch : 배열의 인덱스 반환 */
		
		int[] intArr = {3, 4, 2, 1, 5};
		
		Arrays.sort(intArr);
		
		// Arryas.binarySearch(배열, 인덱스 찾고자 하는 값)
		Arrays.binarySearch(intArr, 2);		// 1

참고

https://mi2mic.tistory.com/189
https://ifuwanna.tistory.com/232
https://st-lab.tistory.com/243
https://bestalign.github.io/translation/top-10-mistakes-java-developers-make-1/