[JAVA] 배열의 합 구하기

목차

 

자바에서는 배열의 합을 구하는 여러 가지 방법이 있습니다. 전통적인 for 문, 향상된 for 문, 스트림 API, 재귀 호출, 그리고 Arrays.parallelPrefix 메서드를 사용하는 방법이 있습니다.

1. 전통적인 for 문를 사용한 합 구하기

전통적인 for 문을 사용하여 배열의 합을 구하는 방법은 직관적이고 간단합니다.

/**
 * 배열의 합을 전통적인 for 루프를 사용
 *
 * @param array 합을 구할 배열
 * @return 배열 요소들의 합
 */
public int sumUsingForLoop(int[] array) {
  int sum = 0;
  for (int i = 0; i < array.length; i++) {
    sum += array[i];
  }
  return sum;
}

단위 테스트

@Order(1)
@DisplayName("sumUsingForLoop: 배열 요소들의 합")
@Test
public void testSumUsingForLoop() {
  // Given
  int[] array = {1, 2, 3, 4, 5};

  // When
  int result = arraySum.sumUsingForLoop(array);

  // Then
  assertEquals(15, result);
}

@Order(2)
@DisplayName("sumUsingForLoop: 빈 배열 테스트")
@Test
public void testSumUsingForLoop_EmptyArray() {
  // Given
  int[] array = {};

  // When
  int result = arraySum.sumUsingForLoop(array);

  // Then
  assertEquals(0, result);
}

 

장점
- 직관적 : 이해하기 쉬운 간단한 방법입니다.

단점
- 코드 길이 : 다른 방법들에 비해 코드가 길어질 수 있습니다.

 

2. 향상된 for 문를 사용한 합 구하기

향상된 for 문을 사용하면 코드가 더 간결해집니다.

/**
 * 배열의 합을 향상된 for 루프를 사용
 *
 * @param array 합을 구할 배열
 * @return 배열 요소들의 합
 */
public int sumUsingEnhancedForLoop(int[] array) {
  int sum = 0;
  for (int num : array) {
    sum += num;
  }
  return sum;
}

단위 테스트

@Order(3)
@DisplayName("sumUsingEnhancedForLoop: 배열 요소들의 합")
@Test
public void testSumUsingEnhancedForLoop() {
  // Given
  int[] array = {1, 2, 3, 4, 5};

  // When
  int result = arraySum.sumUsingEnhancedForLoop(array);

  // Then
  assertEquals(15, result);
}

@Order(4)
@DisplayName("sumUsingEnhancedForLoop: 빈 배열 테스트")
@Test
public void testSumUsingEnhancedForLoop_EmptyArray() {
  // Given
  int[] array = {};

  // When
  int result = arraySum.sumUsingEnhancedForLoop(array);

  // Then
  assertEquals(0, result);
}

장점
- 간결함 : 코드가 더 간결해집니다.

단점
- 제어력 부족 : 전통적인 for 문과 달리 인덱스 제어나 변형은 어렵습니다.

 

3. Stream API 를 사용한 합 구하기

Java 8부터 도입된 스트림 API를 사용하면 더 간결하고 함수형 프로그래밍 스타일의 코드를 작성할 수 있습니다.

/**
 * 배열의 합을 스트림 API를 사용
 *
 * @param array 합을 구할 배열
 * @return 배열 요소들의 합
 */
public int sumUsingStreams(int[] array) {
  return Arrays.stream(array).sum();
}

단위 테스트

@Order(5)
@DisplayName("sumUsingStreams: 배열 요소들의 합")
@Test
public void testSumUsingStreams() {
  // Given
  int[] array = {1, 2, 3, 4, 5};

  // When
  int result = arraySum.sumUsingStreams(array);

  // Then
  assertEquals(15, result);
}

@Order(6)
@DisplayName("sumUsingStreams: 빈 배열 테스트")
@Test
public void testSumUsingStreams_EmptyArray() {
  // Given
  int[] array = {};

  // When
  int result = arraySum.sumUsingStreams(array);

  // Then
  assertEquals(0, result);
}

 

장점
- 가독성 : 코드가 매우 간결하고 읽기 쉽습니다.
- 함수형 프로그래밍 : 최신 자바에서 선호되는 함수형 프로그래밍 패러다임을 활용합니다.

단점
- 성능 오버헤드 : 스트림은 약간의 성능 오버헤드를 수반하지만, 대부분의 경우 이는 무시할 수 있습니다.

 

4. 재귀 호출을 사용한 합 구하기

재귀 호출을 사용하면 반복문 없이도 합을 구할 수 있지만, 스택 오버플로우와 같은 문제가 발생할 수 있습니다.

/**
 * 배열의 합을 재귀 호출을 사용
 *
 * @param array 합을 구할 배열
 * @return 배열 요소들의 합
 */
public int sumUsingRecursion(int[] array) {
  if (array.length == 0) {
    return 0;
  }
  return sumArrayRecursive(array, array.length - 1);
}

private int sumArrayRecursive(int[] array, int index) {
  if (index == 0) {
    return array[index];
  }
  return array[index] + sumArrayRecursive(array, index - 1);
}

단위 테스트

@Order(7)
@DisplayName("sumUsingRecursion: 배열 요소들의 합")
@Test
public void testSumUsingRecursion() {
  // Given
  int[] array = {1, 2, 3, 4, 5};

  // When
  int result = arraySum.sumUsingRecursion(array);

  // Then
  assertEquals(15, result);
}

@Order(8)
@DisplayName("sumUsingRecursion: 빈 배열 테스트")
@Test
public void testSumUsingRecursion_EmptyArray() {
  // Given
  int[] array = {};

  // When
  int result = arraySum.sumUsingRecursion(array);

  // Then
  assertEquals(0, result);
}

 

장점
-  재귀적 사고 : 복잡한 문제를 쉽게 해결할 수 있습니다.

단점
- 성능 : 큰 배열에서는 성능이 떨어지며, 스택 오버플로우가 발생할 수 있습니다.

 

5.  Arrays.parallelPrefix를 사용한 합 구하기

Java 8부터 도입된 Arrays.parallelPrefix 메서드를 사용하면 병렬로 배열 요소들의 합을 구할 수 있습니다.

/**
 * 배열의 합을 Arrays.parallelPrefix 메서드를 사용
 *
 * @param array 합을 구할 배열
 * @return 배열 요소들의 합
 */
public int sumUsingParallelPrefix(int[] array) {
  if (array.length == 0) {
    return 0;
  }
  int[] copy = Arrays.copyOf(array, array.length);
  Arrays.parallelPrefix(copy, Integer::sum);
  return copy[copy.length - 1];
}

단위 테스트

@Order(9)
@DisplayName("sumUsingParallelPrefix: 배열 요소들의 합")
@Test
public void testSumUsingParallelPrefix() {
  // Given
  int[] array = {1, 2, 3, 4, 5};

  // When
  int result = arraySum.sumUsingParallelPrefix(array);

  // Then
  assertEquals(15, result);
}

@Order(10)
@DisplayName("sumUsingParallelPrefix: 빈 배열 테스트")
@Test
public void testSumUsingParallelPrefix_EmptyArray() {
  // Given
  int[] array = {};

  // When
  int result = arraySum.sumUsingParallelPrefix(array);

  // Then
  assertEquals(0, result);
}

장점
- 성능 : 병렬 처리를 통해 성능 향상을 기대할 수 있습니다.

단점

- 복잡성 : 사용법이 다소 복잡할 수 있습니다.

 

결론

결론적으로, 자바에서 배열의 합을 구하는 방법은 다양합니다. 상황에 따라 가장 적합한 방법을 선택하여 사용할 수 있습니다. 일반적으로 스트림 API는 간결성과 가독성 측면에서 많이 선호되며, 전통적인 for 문 또한 여전히 널리 사용됩니다.

소스 코드는 Github Repository- https://github.com/tychejin1218/blog/tree/main/java-collection 프로젝트를 참조하세요.