[Java/Short] 배열/리스트 중복제거 방법 : 전체, 인접한 요소 중복 제거

해당 글에서는 배열/리스트에서 중복된 요소들을 제거하기 위한 방법으로 전체에서 중복요소를 제거하는 방법과 인접한 상태에서의 중복된 요소를 제거하는 방법에 대해서 공유합니다.

 

1) 배열/리스트 순서관계 없이 중복요소 제거

---

💡 배열/리스트 순서관계 없이 중복요소 제거

- 해당 방법은 배열/리스트에서 순서관계 없이 중복된 요소를 제거하고 하나로 재구성 하는 방법입니다.

 

1. 배열(Array)의 중복된 값 지우기

---

1.1. Stream의 중복된 값 지우는 방법 : distinct

int[] arr = {1, 2, 3, 3, 4, 4, 5};
arr = Arrays.stream(arr).distinct().toArray(); // [1, 2, 3, 4, 5]

int[] arr = {1, 1, 3, 3, 0, 1, 1, 3, 3, 3, 8}; 
int[] newArr = Arrays.stream(arr).distinct().toArray(); // [1, 3, 0, 8]

 

 

 

1.2. Set을 이용한 값을 지우기 방법 : Set()

/*
 * Set을 이용한 배열의 중복 제거
 */
int[] arr = {1, 2, 3, 3, 4, 4, 5};

/// 1. HashSet을 선언합니다.
Set<Integer> intHashSet1 = new HashSet<>();

// 2. HashSet에 값을 순차적으로 넣습니다.
for (int i : arr) {
    intHashSet1.add(i);
}
// 3. 새로운 배열을 구성합니다.
int[] remakeArr = new int[intHashSet1.size()];

// 4. HashSet을 다시 구현함
int index = 0;
for (int i : intHashSet1) {
    remakeArr[index++] = i;
}                           // [1, 2, 3, 4, 5]

 

 

 

1.3. Set + Stream을 이용한 방법

int[] arr = {1, 1, 3, 3, 0, 1, 1};

List<Integer> arrList = Arrays.stream(arr).boxed().collect(Collectors.toList());

Set<Integer> arrSet = new HashSet<>(arrList);

int[] newArr = arrSet.stream().mapToInt(Integer::intValue).toArray(); // [1, 3, 0]

 

 

 

1.4. ArrayList와 Contains를 이용한 방법 : ArrayList & Contains

/*
 * ArrayList()와 Contain 메서드로 중복된 값 제거
 */
int[] arr2 = {1, 2, 2, 3, 4, 4, 5};
List<Integer> list = new ArrayList<>();

for (int i : arr2) {
    if (!list.contains(i)) {
        list.add(i);
    }
}

int[] remakeArr2 = new int[list.size()];
int index2 = 0;

for (int i : list) {
    remakeArr2[index2++] = i;
}

 

 

 

 

2. 리스트(List)의 중복된 값 지우기

---

2.1. Stream의 중복된 값 지우는 방법 : distinct

List<Integer> arrList = Arrays.asList(1, 2, 3, 3, 4, 4, 5);

arrList = arrList.stream().distinct().collect(Collectors.toList()); // [1, 2, 3, 4, 5]

 

 

 

2.2. Set을 이용한 값을 지우기 방법 : Set()

💡 리스트에서 중복된 값을 제거하려면, Set을 활용하여 중복된 값을 제거한 후, ArrayList로 다시 변환하면 됩니다.

/*
 * 리스트의 중복된 값을 제거합니다.
 */
List<String> strList = new ArrayList<>(Arrays.asList("value1", "value2", "value1"));
Set<String> set = new HashSet<>(strList);
List<String> newStrList = new ArrayList<>(set);//  ["value2", "value1"]

 

 

 

2.3. ArrayList와 Contains를 이용한 방법 : ArrayList & Contains

💡 리스트에서 중복된 값을 제거하려면 List.contains() 함수를 중복된 값을 확인하고 배열을 재구성하는 형태로 사용을 합니다.

/*
 * 2. ArrayList()와 Contain 메서드로 중복된 값 제거
 */
int[] arr2 = {1, 2, 2, 3, 4, 4, 5};
List<Integer> list2 = new ArrayList<>();

for (int i : arr2) {
    if (!list2.contains(i)) {
        list2.add(i);
    }
}

int[] remakeArr2 = new int[list2.size()];
int index2 = 0;

for (int i : list2) {
    remakeArr2[index2++] = i;
}

 

 

 

 

 

 

2) 배열/리스트 내에 순서를 보장하여 중복 제거

---

💡 배열/리스트 순서를 보장하여 중복 제거

- 배열/리스트 내에서 순서를 보장하여 중복을 제거하는 방법입니다.

 

 

1. 배열(Array)의 중복된 값 지우기: 순서 보장

---

String[] strArr = {"1", "4", "5", "6", "8", "1", "2", "4", "9", "11"};

Set<String> linkedHashSetStrList = new LinkedHashSet<>(Arrays.asList(strArr));
System.out.println("String[] 중복 제거(순서 보장O) :: " + linkedHashSetStrList);   // String[] 중복 제거 ::[1, 4, 5, 6, 8, 2, 9, 11]

 

 

 

2. 리스트(List)의 중복된 값 지우기: 순서 보장

---

List<String> strList = Arrays.asList("1", "4", "5", "6", "8", "1", "2", "4", "9", "11");
Set<String> linkedHashSetStrList = new LinkedHashSet<>(strList);
System.out.println("List<String> 중복 제거(순서 보장X) :: " + linkedHashSetStrList);          // List<String> 중복 제거 :: [1, 4, 5, 6, 8, 2, 9, 11]

 

 

 

 

3) 배열/리스트의 인접한 중복 요소 제외

---

💡배열/리스트의 인접한 중복 요소 제외

- 해당 방법은 배열/리스트 안에 순차적으로 순회하면서 요소간의 인접한 중복된 요소를 하나로 합치는 방법입니다.

 

1. 배열 내의 인접한 중복된 요소 값 제외 방법

---

int[] arr = {1, 1, 3, 3, 0, 1, 1, 3, 3, 3, 8};
ArrayList<Integer> uniqueList = new ArrayList<>();

// [STEP1] 배열의 이전 값(임시 초기화)
int prev = -1;

// [STEP2] 배열을 순회합니다.
for (int num : arr) {

    // [STEP3] 이전값과 같지 않으면 배열에 넣고 이전 값을 갱신합니다.
    if (num != prev) {
        uniqueList.add(num);
        prev = num;
    }
}


/*
 * [STEP3] Array(배열)의 비교를 마치고 마지막 값을 List(리스트)에 저장합니다.
 */
uniqueList.add(arr[arr.length - 1]);

/*
 * [STEP4] List(리스트)를 배열(Array)로 변환합니다.
 */
int[] uniqueArr = uniqueList.stream().mapToInt(i -> i).toArray();
log.debug("uniqueArr :: " + Arrays.toString(uniqueArr));// [1, 3, 0, 1, 3, 8]

 

 

 

 

1.2. 문자 배열 내의 중복요소 제외

---

String[] strArr = {"banana", "banana", "banana", "apple", "apple", "mango", "banana"};

List<String> strArrList = new ArrayList<>();

/*
 * [STEP1] Array(배열)을 순회하면서 n번째와 n+1번째 값을 비교하여 중복되지 않는 요소를 List(리스트)에 저장합니다.
 */
for (int i = 0; i < strArr.length - 1; i++) {
    if (!strArr[i].equals(strArr[i + 1])) {
        strArrList.add(strArr[i]);
    }
}

/*
 * [STEP2] Array(배열)의 비교를 마치고 마지막 값을 List(리스트)에 저장합니다.
 */
strArrList.add(strArr[strArr.length - 1]);

/*
 * [STEP3] List(리스트)를 배열(Array)로 변환합니다.
 */
String[] uniqueStrArr = strArrList.toArray(new String[strArrList.size()]);

log.debug("uniqueStrArr :: " + Arrays.toString(uniqueStrArr)); // [banana, apple, mango, banana]

 

 

 

 

 

 

오늘도 감사합니다. 😀