[Java] 자주 사용하는 패턴 -1 : 배열/리스트 조작

해당 글에서는 Java에서 자주 사용하는 패턴 중 배열과 리스트 조작을 위한 패턴에 대해서 알아봅니다. 개인적으로 간단하고 사용하기 간단한 패턴만 선택하였습니다.

 

 

1) 배열 /리스트 간 변환 패턴 : Arrays.asList, stream().boxed().collect(), toList()

---

💡  배열 /리스트 조작 패턴 : Array → ArrayList, ArrayList → Array 변환

- 배열을 리스트로 전환하거나 리스트를 배열로 변환하는것을 활용하는 패턴입니다.
- 배열과 리스트 간의 캐스팅을 통하여 각각의 기능을 사용하고 활용할 수 있습니다.

 
 

💡 Array → List 사용 문법

1. 문자열 배열 → 문자열 리스트
- asList, for문

2. 문자열 리스트 → 문자열 배열
- stream().boxed().collect()


💡 List → Array 사용 문법

1. 정수 배열 → 정수 리스트
- toArray()

2. 정수 리스트 → 정수 배열
stream().mapToInt().toArray(), for문

/**
 * Array -> ArrayList, ArrayList -> Array 변환
 *
 * @return
 */
@GetMapping("/1")
public ResponseEntity<ApiResponse<?>> question01() {
    String answer = "";

    /**
     * Array -> List
     */
    // 1. 문자열 배열을 문자열 리스트로 변형 : asList , for문
    String[] strArr = {"one", "two", "three", "four", "five"};
    List<String> strList = Arrays.asList(strArr);
    System.out.println("strList :: " + strList);

    // 2. 정수 배열을 정수 리스트로 변형 : stream().boxed().collect
    int[] intArr = {1, 2, 3, 4, 5};
    List<Integer> integerList = Arrays.stream(intArr).boxed().collect(Collectors.toList());
    System.out.println("integerList : " + integerList);

    /**
     * List -> Array
     */
    // 1. 문자열 리스트에서 문자열 배열로 변형 : toArray();
    String[] strArr2 = strList.toArray(new String[strList.size()]);
    System.out.println("strArr2 :: " + Arrays.toString(strArr2));

    // 2.1. 숫자 리스트에서 숫자 배열로 변형 : stream().mapToInt().toArray();
    int[] intArr2 = integerList.stream().mapToInt(Integer::intValue).toArray();
    
    // 2.2. 숫자 리스트에서 숫자 배열로 변형 : for문
    int[] intArr3 = new int[integerList.size()];
    for (int i = 0; i < integerList.size(); i++) {
        intArr3[i] = integerList.get(i);
    }
    System.out.println("intArr2 : " + Arrays.toString(intArr2));
    System.out.println("intArr3 : " + Arrays.toString(intArr3));

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 
 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

[Java/Short] Array <-> ArrayList 변환 방법

[Java/Short] 문자열 배열 <-> 정수 배열 변환 방법

 
 
 
 
 

2) 문자열을 배열/리스트로 변환 패턴 : 문자열 ↔ 배열 : Split, toCharArray()

---

💡 문자열을 배열 혹은 리스트로 변환 패턴 : 문자열 ↔ 배열

- 문자열 혹은 정수를 문자열 배열로 변환하기 위한 패턴으로 변환된 배열에 대해 조작하는 패턴입니다.

 
 
 

💡 문자열/숫자를 배열/리스트로 변환하는 패턴

1. 문자열을 문자 배열로 변환 사용 문법

- String.split(””)


2. 숫자를 숫자 배열로 변환 사용 문법

- String.valueOf().split("")String.toCharArray()

/**
 * 문자열 혹은 정수를 배열로 변환
 *
 * @return
 */
@GetMapping("/2")
public ResponseEntity<ApiResponse<?>> question02() {

    /**
     * String -> String [] / int -> String[]
     */
    // 1. 문자열 -> 문자열 배열로 변환 : String.split("")
    String answer = "";
    String strItem = "one two three four five";
    String[] strArr = strItem.split(" ");
    System.out.println("strArr :: " + Arrays.toString(strArr));

    // 2. 정수 -> 정수 배열로 변환 : String.valueOf().split("")
    int intItem = 12345;
    String[] parseStrArr = String.valueOf(intItem).split("");
    int[] intArr = new int[parseStrArr.length];
    for (int i = 0; i < parseStrArr.length; i++) {
        intArr[i] = Integer.parseInt(parseStrArr[i]);
    }
    System.out.println("intArr :: " + Arrays.toString(intArr));

    /**
     * int -> String[] : String.toCharArray();
     */
    // 2. 정수 -> 정수 배열로 변환 :
    int intItem2 = 12345;
    char[] charArr = String.valueOf(intItem2).toCharArray();
    int[] intArr2 = new int[charArr.length];

    for (int i = 0; i < charArr.length; i++) {
        intArr2[i] = charArr[i];
    }
    System.out.println("intArr2 :: " + Arrays.toString(intArr2));

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

 

[Java/Short] 문자열을 배열로 변환 방법 : String to String[], char[]

 
 
 
 
 
 

3) 배열/리스트의 특정 요소의 개수를 배열/리스트로 재 구성 패턴 : copyOfRange / subList

---

 💡 배열/리스트의 특정 요소만 배열/리스트로 재 구성 패턴 : copyOfRange / subList

- 배열/리스트 중 특정 요소들만으로 구성된 배열이나 리스트를 구성하기 위한 패턴입니다.

 
 
 

💡 배열의 특정 요소만 복사하여 구성 사용 문법

- Arrays.copyOfRange()


💡리스트의 특정 요소만 복사하여 구성 사용 문법

- List.subList()

/**
 * 배열/리스트 내에서 특정 요소만 배열/리스트로 구성 방법 패턴
 *
 * @return
 */
@GetMapping("/3")
public ResponseEntity<ApiResponse<?>> question03() {

    /**
     * int[] -> int[] (특정 요소만 구성)
     */
    int[] intArr = {1, 2, 3, 4, 5, 6, 7, 8};
    int k = 3;          // 묶으려는 요소

    List<Integer> sumList = new ArrayList<>();
    for (int i = 0; i < intArr.length; i++) {
        // n ~ n + k 까지의 배열을 재구성합니다.
        int KArr[] = Arrays.copyOfRange(intArr, i, i + k);
        // 재구성한 배열의 요소의 합계를 구합니다.
        sumList.add(Arrays.stream(KArr).sum());
    }

    // 3개의 요소 중에서 가장 값이 큰 값
    int maxValue = Collections.max(sumList);
    System.out.println("maxValue :: " + maxValue); // maxValue :: 21

    /**
     * List<String> -> List<String> (특정 요소만 구성)
     */

    List<String> strList = Arrays.asList("apple", "banana", "mongo", "apple", "banana", "cherry");
    int h = 2;
    List<String> sumStrList = new ArrayList<>();
    for (int i = 0; i < strList.size(); i++) {
        if (i <= strList.size() - h) {
            // n ~ n + h 까지의 리스트를 재구성합니다.
            List<String> hList = strList.subList(i, i + h);
            // 재구성한 리스트를 하나의 문자열로 합칩니다.
            String joinStr = String.join("-", hList);
            sumStrList.add(joinStr);
        }
    }
    System.out.println("sumStrList :: " + sumStrList); // sumStrList :: [apple-banana, banana-mongo, mongo-apple, apple-banana, banana-cherry]

    String answer = "";
    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

 

[Java/Short] 배열/리스트의 요소를 원하는 개수만큼 재 구성 방법

 
 
 

4) 배열 혹은 리스트 정렬 패턴 : Sorting

---

💡 배열 혹은 리스트 정렬 패턴 : Sorting

- 배열이나 리스트 내의 요소들을 오름차순/내림차순으로 정렬을 하는 패턴입니다.

 

💡 정수 배열의 오름차순 사용 문법

- Arrays.sort();

💡 정수 배열의 내림차순 사용 문법

- for문을 이용(제일간단)
- Stream을 이용(속도가 매우 느림)
- Array.stream()를 이용(배열을 사용하다 리스트를 사용하려는 경우)


💡 문자열 배열의 오름차순 사용 문법

- Arrays.sort()

💡 문자열 배열의 내림차순 사용 문법

- Arrays.sort(Array, Collections.reverseOrder())



💡 리스트의 오름차순 사용 문법(정수, 문자열)

- Collections.sort(List)

💡 리스트의 내림차순 사용 문법(정수, 문자열)

- Collections.sort(List, Collections.reverseOrder()); 

/**
 * 배열 혹은 리스트 정렬 패턴
 *
 * @return
 */
@GetMapping("/4")
public ResponseEntity<ApiResponse<?>> question04() {
    String answer = "";

    /**
     * int[] Sorting
     */
    int[] intArr = {1, 2, 3, 4, 5};

    // 1. 오름차순 정렬 : Arrays 함수 사용
    Arrays.sort(intArr);

    // 2.1. 내림차순 정렬-1 : for문
    int[] swapArr = new int[intArr.length];
    for (int i = 0; i < intArr.length; i++) {
        swapArr[i] = intArr[intArr.length - 1 - i];
    }

    // 2.2. 내림차순 정렬-2 : Stream을 이용하여 변경 (속도가 매우느릴것으로 예상)
    Integer[] integerArr = Arrays.stream(intArr).boxed().toArray(Integer[]::new);
    Arrays.sort(integerArr, Collections.reverseOrder());
    int[] swiftArr = Arrays.stream(integerArr).mapToInt(Integer::intValue).toArray();

    // 2.3. 내림차순 정렬-3 : 배열 -> 리스트로 전환하여 이후 작업을 수행하는 경우
    List<Integer> integeList = Arrays.stream(intArr).boxed().collect(Collectors.toList());
    Collections.sort(integeList, Collections.reverseOrder());

    /**
     * String[] Sorting
     */
    String[] strArr = {"one", "two", "three", "four", "five"};

    // 내림차순 정렬
    Arrays.sort(strArr);

    // 오름차순 정렬
    Arrays.sort(strArr, Collections.reverseOrder());

    /**
     * ArrayList Sorting
     */
    List<String> strList = Arrays.asList("one", "two", "three", "four", "five");
    List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);

    // 오름차순
    Collections.sort(strList);
    Collections.sort(intList);

    // 내림차순
    Collections.sort(strList, Collections.reverseOrder());
    Collections.sort(intList, Collections.reverseOrder());

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 
 
 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

[Java/Short] Array, ArrayList 정렬(Sort) 방법

 
 
 
 
 

5) Counting 배열 구성 패턴

---

💡 Counting 배열 구성 패턴

- 빈 배열에 각각 요소의 개수별로 Counting 하여 재구성하는 배열의 패턴입니다.

/**
 * Counting 배열
 *
 * @return
 */
@GetMapping("/5")
public ResponseEntity<ApiResponse<?>> question05() {
    String answer = "";

    /**
     * int[] -> (Counting) -> int[] :
     */

    int[] arr1 = {1, 3, 2, 5, 4, 5, 2, 9};
    int maxItem = Arrays.stream(arr1).max().getAsInt();
    int[] countingArr = new int[maxItem + 1];

    for (int i = 0; i < arr1.length; i++) {
        for (int j = 0; j < countingArr.length; j++) {
            if (arr1[i] == j) countingArr[j] += 1;
        }
    }
    // 0 ~ 9까지의 Counting
    System.out.println("Counting Arr ::" + Arrays.toString(countingArr));       // Counting Arr ::[0, 1, 2, 1, 1, 2, 0, 0, 0, 1]
    System.out.println("5의 개수 " + countingArr[5]);                             // 5의 개수 2
    System.out.println("9의 개수 " + countingArr[9]);                             // 9의 개수 1

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

[Java/Short] 카운트 Array/Map 구현방법: Counting Array, Counting Map

 
 
 
 
 

6) 배열/리스트 내의 중복 제거 패턴

---

💡 배열/리스트 내의 중복 제거 패턴

배열/리스트 내에 중복되는 요소들에 대해 중복을 제거하고 한 개의 요소만 남기는 패턴입니다.

 
 

💡 정수/문자열 배열의 중복 제거 사용 문법

- Arrays.stream().distinct().toArray()
- HashSet(순서보장X)
- LinkedHashSet(순서보장O)


💡 정수/문자열 리스트 중복 제거 방법

- List.stream().distinct().collect(Collectors.toList())
- HashSet(순서보장X)
- LinkedHashSet(순서보장O)

/**
 * 배열 내의 중복되는 요소 제거
 *
 * @return
 */
@GetMapping("/6")
public ResponseEntity<ApiResponse<?>> question06() {
    String answer = "";

    /**
     * int[], String[] 중복 제거
     */
    // 1. int[] 중복 제거
    int[] intArr = {1, 2, 3, 4, 5, 6, 4, 3, 2, 4, 6, 8, 9};
    int[] renewArr = Arrays.stream(intArr).distinct().toArray();
    System.out.println("int[] 중복 제거 :: " + Arrays.toString(renewArr));      // int[] 중복 제거 :: [1, 2, 3, 4, 5, 6, 8, 9]

    // 2. String[] 중복 제거
    String[] strArr = {"1", "4", "5", "6", "8", "1", "2", "4", "9", "11"};
    Set<String> hashSetStrArr = new HashSet<>(Arrays.asList(strArr));
    System.out.println("String[] 중복 제거 ::" + hashSetStrArr);                // String[] 중복 제거 ::[11, 1, 2, 4, 5, 6, 8, 9]

    /**
     * List<Integer>, List<String> 중복 제거
     */
    // 1. List<Integer> 중복제거
    List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 4, 3, 2, 4, 6, 8, 9);
    intList = intList.stream().distinct().collect(Collectors.toList());
    System.out.println("List<Integer> 중복 제거 :: " + intList);                // List<Integer> 중복 제거 :: [1, 2, 3, 4, 5, 6, 8, 9]

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

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 
 
 

💡 [참고] 순서를 보장하는 중복 제거 방식입니다. : LinkedHashSet을 이용한 방법입니다.

- 이를 이용하면 먼저 발생한 요소부터 순차적으로 구성이 되며 중복되는 데이터의 경우는 제외합니다.

/**
 * 배열 내의 중복되는 요소 제거
 *
 * @return
 */
@GetMapping("/6")
public ResponseEntity<ApiResponse<?>> question06() {
    String answer = "";

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


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

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 
 
 
 
 
 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

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

 
 
 
 

7) 배열/리스트의 최소값/최대값 찾기 패턴

---

💡 배열/리스트의 최소값/최대값 찾기 패턴

- 배열이나 리스트에서 최소값과 최대값을 찾는 패턴입니다.

 
 
 

💡 배열의 최소값/최대값 사용 문법

- Arrays.stream().max().getAsInt()
- Integer.MAX_VALUE, Integer.MIN_VALUE


💡 리스트의 최소값/최대값 사용 문법

- Collections.max(), Collections.min()

/**
 * 배열/리스트의 최소값/최대값 찾기 패턴
 *
 * @return
 */
@GetMapping("/7")
public ResponseEntity<ApiResponse<?>> question07() {
    String answer = "";

    /**
     * 배열의 최대값, 최소값
     */
    int[] arr = {1, 2, 3, 4, 5, 6, 3, 2, 4, 5, 7, 9};

    int max = Arrays.stream(arr).max().getAsInt();
    int min = Arrays.stream(arr).min().getAsInt();
    System.out.println("최소값 :: " + min + "  최대값 :: " + max);        // 최소값 :: 1  최대값 :: 9

    int minVal = Integer.MAX_VALUE;
    int maxVal = Integer.MIN_VALUE;

    for (int num : arr) {
        if (num < minVal) {
            minVal = num;
        }
        if (num > maxVal) {
            maxVal = num;
        }
    }
    System.out.println("최소값 :: " + min + "  최대값 :: " + max);        // 최소값 :: 1  최대값 :: 9

    /**
     * 리스트의 최대값, 최소값
     */
    List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 3, 2, 4, 5, 7, 9);
    int min2 = Collections.min(integerList);
    int max2 = Collections.max(integerList);
    System.out.println("최소값 :: " + min2 + "  최대값 :: " + max2);      // 최소값 :: 1  최대값 :: 9

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

 

[Java/Short] 배열/리스트 내의 최소값, 최대값 찾는 방법 : min, max

 
 
 
 

8) 배열/리스트 역순으로 재구성 패턴

---

 💡 배열/리스트 역순으로 구성 패턴

- 배열이나 리스트를 역순으로 재구성하는 패턴입니다. (sorting과 다르게 구성되어 있는 배열을 역순으로 재구성합니다)

/**
 * 배열/리스트를 역순으로 재구성 방법
 *
 * @return
 */
@GetMapping("/8")
public ResponseEntity<ApiResponse<?>> question08() {
    String answer = "";

    /**
     * 배열을 역순으로 재구성하는 방법
     */
    int[] intArr = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    int[] reverseArr = new int[intArr.length];
    for (int i = 0; i < intArr.length; i++) {
        reverseArr[i] = intArr[intArr.length - 1 - i];
    }
    System.out.println("Array 역순 :: " + Arrays.toString(reverseArr));

    /**
     * 리스트를 역순으로 재구성하는 방법
     */
    List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

    Collections.reverse(integerList);
    System.out.println("List 역순 :: " + integerList); // List 역순 :: [9, 8, 7, 6, 5, 4, 3, 2, 1]

    ApiResponse<Object> ar = ApiResponse
            .builder()
            .result(answer)
            .resultCode(SUCCESS_CODE)
            .resultMsg(SUCCESS_MSG).build();
    return new ResponseEntity<>(ar, HttpStatus.OK);
}

 

💡 [참고] 해당 패턴에 대해 더 자세히 알고 싶으시면 아래의 글을 참고하시면 도움이 됩니다.

 

[Java/Short] 배열/리스트의 요소를 역순으로 재구성 방법 : forward to reverse

 
 
 
 
 
오늘도 감사합니다. 😀