Java, 자료구조별 주요 Class와 Method

※ 자료구조들의 기본 메서드(추가, 제거 등)는 생략. (유용한 메서드 위주로)

1. Array

1) 정렬 (1차원)

- Arrays.sort(arr)

import java.util.Arrays;
import java.util.Collections;
int[] arr = new int[5];

• java.util.Arrays 클래스 사용
• inPlace, 즉 정렬된 배열을 반환하는 것이 아닌 arr 안에서 정렬.
• PrimitiveType 배열은 오름차순만을 제공, 내림차순은 Wrapper Class로 변환 후 가능.
• Integer같은 Wrapper "Class" 배열은 Comparator.reverseOrder()를 통해 내림차순 정렬 가능
• Arrays.stream(tem).sorted().toArray() 와 같은 역할 (얘는 정렬된 배열을 반환). but, Arrays.sort(arr)이 더 빠름

// 오름차순
int[] arr = {1,9,2,0,7,3};
int[] arr1 = Arrays.copyOf(arr, arr.length);
Arrays.sort(arr1);
System.out.println("오름차순: "+Arrays.toString(arr1));

//내림차순
int[] arr2 = Arrays.copyOf(arr1,arr1.length);
Integer[] new_arr2 = Arrays.stream(arr2).boxed().toArray(Integer[]::new); // Warrper Class로 변환
Arrays.sort(new_arr2, Collections.reverseOrder()); // 내림차순 적용
System.out.println("내림차순: "+Arrays.toString(new_arr2));

 

[OUTPUT]

오름차순: [0, 1, 2, 3, 7, 9]

내림차순: [9, 7, 3, 2, 1, 0]

 

- list.sort()

import java.util.ArrayList;
import java.util.Collections;
ArrayList<Integer> list = new ArrayList<>();

• ArrayList<E>, LinkedList<E> 와 같은 Class List들은 바로 sort()를 통해 정렬 가능
• 오름차순 : list.sort(Comparator.naturalOrder()) / 내림차순 : list.sort(Comparator.reverseOrder())

for(int i : arr) list.add(i);
list.sort(Comparator.naturalOrder()); // 정방향 -> 오름차순
System.out.println("오름차순: "+list);
list.sort(Comparator.reverseOrder()); // 역방향 -> 내림차순
System.out.println("내림차순: "+list);

[OUTPUT]

오름차순: [0, 1, 2, 3, 7, 9]

내림차순: [9, 7, 3, 2, 1, 0]

 

 

2) 정렬 (2차원)

- Arrays.sort(arr, ... )

import java.util.Arrays;
import java.util.Collections;
int[][] arr = new int[6][2];

• java.util.Arrays 클래스 사용
• Comparator 인터페이스의 compare 메서드를 Overriding 하여 직접 구현 필요
• 람다식으로도 표현 가능

int[][] arr = {{0,1},{1,6},{2,3},{3,2},{4,0},{5,9}};

// 오름차순
Arrays.sort(arr, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
        return o1[1] - o2[1];
    }
});
System.out.print("오름차순: ");
Arrays.stream(arr).forEach(i->System.out.print(Arrays.toString(i)+" "));
System.out.println();

// 내림차순 (람다식으로 표현)
Arrays.sort(arr,((o1, o2) -> (o1[1]-o2[1])*-1));
System.out.print("내림차순: ");
Arrays.stream(arr).forEach(i->System.out.print(Arrays.toString(i)+" "));

[OUTPUT]

오름차순 : [4, 0] [0, 1] [3, 2] [2, 3] [1, 6] [5, 9] 
내림차순 : [5, 9] [1, 6] [2, 3] [3, 2] [0, 1] [4, 0]

 

3) 복사

- Arrays.copyOf(arr, length) / Arrays.copyOfRange(arr, from, to)

import java.util.Arrays;
int[] arr = {1,2,3,4,5};

• java.util.Arrays 클래스 사용
• copyOf는 지정된 길이만큼만 처음부터 복사하여 반환
• copyOfRange는 지정된 인덱스의 범위로 복사하여 반환
• copy 없이 할당만 한다면 복사되지 않고 주소를 공유하게 됨 -> 원소를 교체하면 그대로 반영
• 2차원 배열은 각 배열에 접근하여 깊은 복사 필요

int[] arr = {1,2,3,4,5};
int[] arr2 = arr; // 주소 공유
int[] c_arr = Arrays.copyOf(arr, arr.length); // == arr.clone();
int[] c_range_arr = Arrays.copyOfRange(arr,1,3); // index 1 부터 2까지 복사

arr[2] = -1; // arr2도 같이 변경
System.out.println("arr: "+Arrays.toString(arr));
System.out.println("arr2: "+Arrays.toString(arr));
System.out.println("copied arr: "+Arrays.toString(c_arr));
System.out.println("range copied arr: "+Arrays.toString(c_range_arr));

[OUTPUT]

arr: [1, 2, -1, 4, 5]
arr2: [1, 2, -1, 4, 5]
copied arr: [1, 2, 3, 4, 5]
range copied arr: [2, 3]

 

- list.clone() / list.subList(from, to)

import java.util.ArrayList;
ArrayList<Integer> list = new ArrayList<>();

• ArrayList<E>, LinkedList<E> 와 같은 Class List들은 clone() 메서드 사용
• 2차원 배열은 각 배열에 접근하여 깊은 복사 필요 혹은 대상 객체에  cloneable 을 implement 하고, clone() 메소드를 override하여, ArrayList 안의 각각의 객체들을 clone() 해주어야 됨.
• subList() 메서드는 범위를 지정하여 복사

int[] arr = {1,4,2,5,3,6};
ArrayList<Integer> list = new ArrayList<>();
for(int i : arr) list.add(i);

ArrayList<Integer> c_list = (ArrayList<Integer>) list.clone();
ArrayList<Integer> r_c_list = new ArrayList<>(list.subList(1,4)); // 주의!
// subList는 그냥 할당하는 것이 아니라, 새로 인스턴스를 할당하면서 생성자로써 만들어줘야함

list.set(1,-1);
System.out.println(list);
System.out.println(c_list);
System.out.println(r_c_list);

[OUTPUT]

[1, -1, 2, 5, 3, 6]
[1, 4, 2, 5, 3, 6]
[4, 2, 5]

 

4) 기타

- Arrays.stream(arr)

import java.util.Arrays;
import java.util.stream.IntStream;
int[] arr = {1,4,2,6,3,8};
IntStream ist = Arrays.stream(arr);

• 최대/최솟값 찾기 : Arrays.stream(arr).max()/min().getAsInt()

  int max = Arrays.stream(arr).max().getAsInt(); // 8
  int min = Arrays.stream(arr).min().getAsInt(); // 1
  System.out.println(max + ", "+ min); // 8, 1​

• 매핑(배열의 모든 원소들에 function을 적용해주고 Stream 반환): Arrays.stream(arr).map()

  int[] arr = {1,4,2,6,3,8};
  arr = Arrays.stream(arr).map(i->i*-1).toArray();
  System.out.println(Arrays.toString(arr)); // [-1, -4, -2, -6, -3, -8]​

 

2. Set (HashSet<E>)

import java.util.HashSet;
import java.util.Iterator;
int[] arr = {1,2,3,4,5};
HashSet<Integer> set = new HashSet<>();
for(int i: arr) set.add(i);

 

1) 집합 간 비교

• 부분집합 : set1.containsAll(set2) , 반환값 : boolean
• 합집합 : set1.addAll(set2), 반환값: X, inPlace
• 교집합 : set1.retainAll(set2), 반환값: X, inPlace
• 차집합 : set1.removeAll(set2), 반환값: X, inPlace

2) 요소 접근 (iterator)

• 인덱스로 접근이 불가능하기에 iterator method 사용

  Iterator<Integer> itr = set.iterator();
  while(itr.hasNext()){
      System.out.println(itr.next());
  }

 

3. Map (HashMap<key, value>)

import java.util.HashMap;
HashMap<Integer,Integer> map = new HashMap<>();

1) 초기 Map의 value 설정 (ex: Counter) -> map.put(key), map.getOrDefault(key, defaultvalue)

int[] arr = {1,4,2,4,5,2,1,5,5,5,2};
HashMap<Integer,Integer> map = new HashMap<>();
for(int i : arr) map.put(i,map.getOrDefault(i,0) + 1);
System.out.println(map); // {1=2, 2=3, 4=2, 5=4}

2) 키와 값 확인하기 : map.keySet(), map.values() => map.entrySet() = Set<Map.Entry<K,V>>로 반환

for(Map.Entry<Integer, Integer> tem: map.entrySet()){
    System.out.println(tem.getKey() +":"+tem.getValue());
} // import Map.Entry

3) Map 정렬 : map.entrySet()을 통해 List를 만들어준 다음, 그 List를 vlaue로 정렬.

import java.util.Collections;
List<Map.Entry<Integer,Integer>> to_list = new ArrayList<>(map.entrySet());
Collections.sort(to_list,((o1, o2) -> o1.getValue() - o2.getValue()));