학습서적 : 자료구조와 함께 배우는 알고리즘 입문


자료구조 학습을 시작하기에 앞서 자료구조의 정의를 살펴보면,
자료구조는 '데이터 단위와 데이터 자체 사이의 물리적 또는 논리적 관계'를 말한다.
쉽게 말해, 자료를 효율적을 사용할 수 있도록 컴퓨터에 저장하는 방법을 말한다.


배열

배열은 같은 자료형의 변수인 구성요소가 모인 것이다.

배열 선언 방식 예시

int[] a; // 선언
a = new int[5] // 참조

int[] a = new int [5]; // 선언과 동시에 참조

여기서 배열 본체는 참조변수 a가 아닌 new로 생성한 뒷부분

배열의 요소값을 초기화하며 선언하면 생성과 동시에 각 구성 요소를 특정값으로 초기화할 수 있다.

int[] a = {1, 2, 3, 4, 5};

배열의 장점

  • 인덱스를 통해 데이터에 빠르게 접근이 가능하다.

배열의 단점

데이터 추가/삭제가 번거로움

  • 미리 최대 길이를 정해서 생성해야 함
  • 가변 길이 배열은 배열의 크기를 변경할 때마다 새로운 배열을 생성
    (데이터를 추가할 때 새로운 배열을 생성해서 기존값을 복사하고 추가값을 넣어야한다.)
  • 데이터 삭제 시, 인덱스를 유지하기 위해 빈 공간을 유지

배열값 추가하기

맨 뒤 index에 추가할 경우

// 기존 배열
int[] originalArray = {1, 2, 3, 4};

// 새로운 값
int newValue = 5;

// 새로운 배열 생성
int[] newArray = new int[originalArray.length + 1];

// 기존 배열 복사
for (int i = 0; i < originalArray.length; i++) {
    newArray[i] = originalArray[i];
}

// 새로운 값 추가
newArray[newArray.length - 1] = newValue;

중간에 추가할 경우

int[] originalArray = {1, 2, 3, 4};

// 추가할 값과 위치
int newValue = 5;
int index = 2;

// 새로운 배열 생성
int[] newArray = new int[originalArray.length + 1];

// 추가할 위치 이전까지 값 복사
for (int i = 0; i < index; i++) {
    newArray[i] = originalArray[i];
}

// 추가할 값 삽입
newArray[index] = newValue;

// 추가할 위치 이후의 값 복사
for (int i = index; i < originalArray.length; i++) {
    newArray[i+1] = originalArray[i];
}

배열값 제거하기

// 기존 배열
int[] originalArray = {1, 2, 3, 4, 5};

// 제거할 값의 인덱스
int indexToRemove = 2;

// 새로운 배열 생성
int[] newArray = new int[originalArray.length - 1];

// 삭제할 위치 이전까지 값 복사
for (int i = 0; i < indexToRemove; i++) {
    newArray[i] = originalArray[i];
}

// 삭제할 위치 이후의 값 복사
for (int i = indexToRemove + 1; i < originalArray.length; i++) {
    newArray[i - 1] = originalArray[i];
}

배열에서 peek값 구하기

// 배열 arr 에서 peek 값 모두 출력
// 입출력 예시)
// arr: 3, 1, 2, 6, 2, 2, 5, 1, 9, 10, 1, 11
// 결과: 3, 6, 5, 10, 11

public class Practice4 {
  public static void main(String[] args) {
      int[] arr = {3, 1, 2, 6, 2, 2, 5, 1, 9, 10, 1, 11};

      for (int i = 0; i < arr.length; i++) { // 첫번째 인덱스 peek값 여부확인
          if (i == 0 && arr[i] > arr[i + 1]) {
              System.out.print(arr[i] + " "); // 맞으면 출력 아니면 출력 X
          } else if (i == arr.length - 1 && arr[i] > arr[i - 1]){ // 마지막 인덱스 peek값 여부확인
              System.out.print(arr[i] + " "); // 맞으면 출력 아니면 출력 X
          } else {
              if (arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) {  // 나머지 인덱스들 peek값 여부확인
                  System.out.print(arr[i] + " "); // peek값인 인덱스들 출력
              }
          }
      }
       System.out.println();
    }
  }

배열 90도 회전하기

1 2 3 4 5
6 7 8 9 10
11 12 13 14 15

위 숫자 출력결과를 우측으로 90도 회전하면
아래와 같이 바뀌는데 90도 회전하는 방법을 알아보자. (행/열 변환)

11 6 1
12 7 2
13 8 3
14 9 4
15 10 5

Chat-GPT 소스

// 주어진 배열
int[][] originalArray = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}};

// 행과 열을 바꾸기 위한 새로운 배열 생성
int[][] Array90 = new int[originalArray[0].length][originalArray.length];

// 배열 회전
for (int i = 0; i < originalArray.length; i++) {
    for (int j = 0; j < originalArray[i].length; j++) {
        Array90[j][originalArray.length - 1 - i] = originalArray[i][j];
    }
}

// 회전된 배열 출력
for (int i = 0; i < Array90.length; i++) {
    for (int j = 0; j < Array90[i].length; j++) {
        System.out.print(Array90[i][j] + " ");
    }
    System.out.println();
}

배열 요소의 최대값 구하기

int[] a = {1, 2, 3, 4, 5};
	int max = a[0];
    for (int i = 1; i < a.length; i++) {
		if (a[i]>max){
			max=a[i];
        }
     }
	System.out.println(max);

최대값을 담을 그릇으로 int max를 선언하고, 첫번째 요소인 a[0]을 대입한다.
그리고 if문에 따라 모든 요소를 순회하고 큰 값이 나타날 경우 수시로 max값을 바꾼다.

순서도는 아래와 같다.

여기서 모든 요소를 하나씩 순회하며 비교를 하는데,
이런 과정을 알고리즘 용어로 '주사'(走査) 또는 스캔이라고 한다.


위에서 배운 코드를 응용하여 아래와 같은 코드를 작성할 수 있다.

import java.util.Scanner;

public class MaxOfArray {
    static int maxOf(int[] a) {
        int max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("키의 최대값을 구합니다.");

        System.out.print("사람 수 : ");
        int num = sc.nextInt();

        int[] height = new int[num]; // 키값 넣을 배열 생성

        for (int i = 0; i < num; i++) {
            System.out.print("height[" + i + "] : ");
            height[i] = sc.nextInt();
        }
        System.out.println("키의 최대값은 " + maxOf(height) + "입니다.");
    }
}
키의 최대값을 구합니다.
사람 수 : 3
height[0] : 172
height[1] : 183
height[2] : 192
키의 최대값은192입니다.

난수 (Random클래스)

난수(무작위수)를 사용하여 배열의 요소값 설정하기 (Random 클래스)

난수를 사용하려면 Random 클래스를 사용해야 한다.
그리고 Random클래스의 인스턴스를 아래와 같이 생성한다.

Random rand = new Random();

상단에 코드에서는 키의 값을 직접 입력했지만,
무작위수를 입력시킬 수도 있다. 코드는 아래와 같다.

int num = rand.nextInt(10)
0부터 9까지의 난수가 생성됨.
import java.util.Random;
import java.util.Scanner;

class MaxOfArrayRand {
    //--- 배열 a의 최댓값을 구하여 반환 ---//
    static int maxOf(int[] a) {
        int max = a[0];
        for (int i = 1; i < a.length; i++)
            if (a[i] > max)
                max = a[i];
        return max;
    }

    public static void main(String[] args) {
        Random rand = new Random();
        Scanner stdIn = new Scanner(System.in);
        // 스캐너 코드는 현재 소스코드에서는 데드코드임. 값을 랜덤으로 받기 때문.

        int num = 0;
        
        System.out.println("키의 최대값을 구합니다.");
        
        do {
        	num = rand.nextInt(10);   // 1~10명 중 랜덤으로 인원수 생성
        }while(num<=0);

        int[] height = new int[num];   // 요소수(인원수)가 num인 배열을 생성

        for (int i = 0; i < num; i++) {
            height[i] = 150 + rand.nextInt(40); // 기본값150+40이내의 난수를 더해서 구함
            System.out.println((i+1)+ "번째 사람의 키는 "+height[i]+"입니다");
        }

        System.out.println("가장 큰 키는 " + maxOf(height) + "입니다.");
    }
}

배열값을 역순으로 정렬하기

배열 요소를 역순으로 정렬하는 알고리즘을 알아보자.
{1,2,3,4,5} -> {5,4,3,2,1}

교환횟수는 배열길이/2이고, 이 나눗셈에서 나머지는 버린다.
배열의 길이가 5일 경우 교환횟수는 2이고, 나머지 1은 무시하고 버린다.

배열의 길이를 n이라하고, 인덱스를 i라고 할 경우
i <-> n-i-1 이렇게 교환을 하는 방식이다.

위 내용을 for문 사용한 알고리즘으로 나타내면 아래와 같다

for (int i = 0; i < n /2; i++)
   // a[i]와 a[n-i-1]의 값을 교환

그렇다면 교환 하는 두 값은 어떻게 교환하는걸까?

교환값을 x,y라고 가정하면,

위 그림 처럼 작업용 변수 t를 만들어 교환할 수 있다.

int t = x; // x값을 t에 보관
int x = y; // y값을 x에 대입
int y = t; // t에 보관한 처음 x값을 y에 대입

위 내용 그대로 swap 메소드를 만들어서 사용할 수 있다. (java 기본제공 메소드 X)

public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

그리고 위 메소드를 활용하여 아래와 같이 추가 메소드를 구현한다.

static void reverse(int[] a) {
	for (int i = 0; i < arr.length / 2; i++) {
		swap(arr, i, arr.length - i - 1);
	}
}
...(생략)
reverse(x); // 배열의 변수명을 x로 가정

System.out.println("x = " + Arrays.toString(x));  // 역순 배열 출력

그리고 마지막에 역순으로 정렬한 배열을 출력할 때,
for문을 사용하지 않고 Arrays.toString 메소드를 사용할 수 있다.
([ ] 로 둘러싸고 콤마(,)로 구분한 문자열 형태로 출력)


기수(基數) 변환

2진수 8진수 16진수 라는 말에서
앞에 2 8 16과 같은 n값이 '기수'이다.

아마 기준이나 기초가 되는 숫자라는 뜻 같은데...🤔

이런식으로 몫이 0이 될때까지 기수 n으로 계속 나눈다.
그리고 그 나머지를 거꾸로 나열한 숫자가 기수로 변환한 숫자이다.

위 그림에서는 마지막 몫 1은 따로 나누지 않았는데 한번 더 2로 나누어도
결과는 같다. 하지만 난 0이 될 때까지 나누는거로 기억해야 될 것 같다.

8진법 16진법도 동일하나, 그 중 16진법은 9다음이 10이 아니라 A인거를 기억하자.

10진수의 정수를 기수 변환하는 코드

(출처:Do it! 알고리즘 입문 - 자바편)

dchar라는 문자열에서 해당문자를 꺼내 d[digits]에 저장합니다.
해당 과정은 x가 0이 될 때까지 반복됩니다.

static int cardConv(int x, int r, char[] d) {
        int digits = 0;  // 변환 뒤 자리수
        String dchar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

        do {
            d[digits++] = dchar.charAt(x % r);  // r로 나눈 나머지를 저장
            x /= r;
        } while (x != 0);

하지만 이렇게 나머지를 구하는 순서대로 넣어두면 맨 앞에 아랫자리가 배치되므로,
바로 이어서 역순으로 정렬까지 해주도록 합니다. (배열 역순 정렬)

for (int i = 0; i < digits / 2; i++) {    // 배열 d의 숫자 문자열을 역순 정렬
            char t = d[i];
            d[i] = d[digits - i - 1];
            d[digits - i - 1] = t;
 		}

전체코드

package DataStructureBasic;

// 입력받은 10진수를 2진수 ~ 36진수로 기수 변환하여 출력

import java.util.Scanner;

class CardConv {
    //--- 정수값 x를 r진수로 변환하여 배열 d에 아랫자리부터 넣어 두고 자리수를 반환 ---//
    static int cardConv(int x, int r, char[] d) {
        int digits = 0;  // 변환 뒤 자리수
        String dchar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

        do {
            d[digits++] = dchar.charAt(x % r);  // r로 나눈 나머지를 저장
            x /= r;
        } while (x != 0);

        for (int i = 0; i < digits / 2; i++) {  // 배열 d의 숫자 문자열을 역순 정렬
            char t = d[i];
            d[i] = d[digits - i - 1];
            d[digits - i - 1] = t;
        }

        return digits;
    }

    public static void main(String[] args) {
        Scanner stdIn = new Scanner(System.in);
        int no;                       // 변환할 정수
        int cd;                       // 기수 선택
        int dno;                      // 변환 뒤 자리수
        int retry;                    // 다시 한 번 할래?
        char[] cno = new char[32];    // 변환 후 각 자리의 숫자를 넣어 두는 문자 배열

        System.out.println("10진수의 정수를 기수 변환합니다.");
        do {
            do {
                System.out.print("변환하는 음이 아닌 정수: ");
                no = stdIn.nextInt();
            } while (no < 0);

            do {
                System.out.print("어떤 진수로 변환할까요?(2-36): ");
                cd = stdIn.nextInt();
            } while (cd < 2 || cd > 36);

            dno = cardConv(no, cd, cno);  // no를 cd진수로 변환

            System.out.print(cd + "진수로 ");
            for (int i = 0; i < dno; i++)  // 순서대로 출력
                System.out.print(cno[i]);
            System.out.println("입니다.");

            System.out.print("다시 한 번 할까요? (1…예/0…아니오): ");
            retry = stdIn.nextInt();
        } while (retry == 1);
    }
}

소수(素數) 나열

소수는 자신과 1 이외의 어떤 정수로도 나누어 떨어지지 않는 정수이다.
(ex : 정수 13의 소수는 1과 13, 단 2개)


1,000이하의 소수를 나열하는 프로그램 (Ver.1)

중요하다고 생각하는 포인트

int i; 선언은 for문 하단에 int i가 for문 밖에서 사용되기 때문에 따로 선언되었다.
이중for문이 이 코드의 핵심인 것 같다.

  for (int n = 2; n <= 1000; n++) {
   int i;
   for (i = 2; i < n; i++) {
    counter++;
  if (n % i == 0)    // 나누어떨어지면 소수가 아님
      break;         // 반복은 더 이상 불필요
  1. n이 소수인 경우 : 안쪽 for문의 i값이 n값과 같음 (for문이 중단없이 끝까지 실행됨)
    (나누어 떨어지는 값이 없다는 것을 의미)
  2. n이 합성수인 경우 : 안쪽 for문의 i값이 b값보다 작음(for문이 도중에 중단됨)

전체코드

package DataStructureBasic;

// 1,000 이하의 소수를 나열하는 프로그램(Ver.1)

class PrimeNumber1 {
    public static void main(String[] args) {
        int counter = 0;        // 나눗셈 횟수

        for (int n = 2; n <= 1000; n++) {
        	int i;
            for (i = 2; i < n; i++) {
                counter++;
                if (n % i == 0)    // 나누어떨어지면 소수가 아님
                    break;         // 반복은 더 이상 불필요
            }
            if (n == i)   // 마지막까지 나누어떨어지지 않음
                System.out.println(n);
        }

        System.out.println("나눗셈을 수행한 횟수 : " + counter);
    }
}


이런식으로 출력이 된다.

하지만 Ver.1의 경우 불필요한 나눗셈을 많이 한다.
예를 들어 7이 약수인지 확인하기 위해 2부터 2..3..4..5..로 나뉘어지는지 모두 계산한다.
소수인지 확인하기 위해서는 7보다 작은 소수 2,3,5로 나눗셈을 하면 충분하다.


˙Ⱉ˙


1,000이하의 소수를 나열하는 프로그램 (Ver.2)

위에 있는 Ver.1의 알고리즘 개선버전!

중요하다고 생각하는 포인트

   prime[ptr++] = 2;                      // 2는 소수임

   for (int n = 3; n <= 1000; n += 2) {   // 조사 대상은 홀수만
     int i;
     for (i = 1; i < ptr; i++) {          // 이미 찾은 소수로 나누어 봄
       counter++;
        if (n % prime[i] == 0)           // 나누어떨어지면 소수가 아님
          break;                         // 더 이상의 반복은 불필요
      }
    if (ptr == i)                        // 마지막까지 나누어떨어지지 않음
        prime[ptr++] = n;                // 소수로 배열에 저장

Ver.1과 마찬가지로 이중for문을 통해 구한다.
바깥쪽 for문은 n값을 2씩 증가시켜 3,5,7,9...,999 홀수값만을 생성한다.
4이상의 짝수는 2로 나누어떨어지므로 소수가 아니기 때문이다.

(출처:Do it! 알고리즘 입문 - 자바편)


전체코드

package DataStructureBasic;

// 1,000이하의 소수를 나열하는 프로그램(Ver.2)

class PrimeNumber2 {
    public static void main(String[] args) {
        int counter = 0;                       // 나눗셈 횟수
        int ptr = 0;                           // 찾은 소수의 개수
        int[] prime = new int[500];            // 소수를 저장하는 배열

        prime[ptr++] = 2;                      // 2는 소수임

        for (int n = 3; n <= 1000; n += 2) {   // 홀수만, 조사대상 +2씩 증가
            int i;
            for (i = 1; i < ptr; i++) {        // 이미 찾은 소수로 나누어 봄
                counter++;
                if (n % prime[i] == 0)         // 나누어떨어지면 소수가 아님
                    break;                     // 더 이상의 반복은 불필요
            }
            if (ptr == i)                      // 마지막까지 나누어떨어지지 않음
                prime[ptr++] = n;              // 소수로 배열에 저장
        }

        for (int i = 0; i < ptr; i++)          // 찾은 ptr개의 소수를 출력
            System.out.println(prime[i]);

        System.out.println("나눗셈을 수행한 횟수 : " + counter);
    }
}

Ver.1과 Ver.2의 답은 같지만 알고리즘은 다르다.
빠른 알고리즘은 메모리를 많이 사용하는 경향이 있다.



1,000이하의 소수를 나열하는 프로그램 (Ver.3)

위에 있는 Ver.2의 알고리즘 개선버전!

중요하다고 생각하는 포인트

//안쪽 for문에 있는 prime[i]가 n의 제곱근 이하인지 판단하는 부분

for (int i = 1; prime[i] * prime[i] <= n; i++) 

n의 제곱근 이하의 어떤 소수로도 나누어 떨어지지 않음 = 소수이다.

(출처:Do it! 알고리즘 입문 - 자바편)


예를 들어 4X25와 25X4는 대칭을 이루고 똑같이 넓이 100을 가진다.
즉, 이 말은 대칭의 중심인 정사각형 10X10 뒤로는 앞에서 이미 나눗셈을 한 것과
같은 결과가 나타나므로 중복하여 나눗셈할 필요가 없는 것이다.
대칭의 기준이 되는 정사각형 10X10의 한 변의 길이(10)까지만 소수로 나눗셈을 하고,
그 과정에서 나누어지지 않으면 소수로 판단할 수 있다는 것이다.

이렇게 불필요한 계산을 줄이는 것이 Ver.3의 핵심 알고리즘이다.


전체코드

package DataStructureBasic;

// 1,000이하의 소수를 나열하는 프로그램 (Ver.3)

class PrimeNumber3 {
    public static void main(String[] args) {
        int counter = 0;               // 곱셈과 나눗셈의 횟수
        int ptr = 0;                   // 찾은 소수의 개수
        int[] prime = new int[500];    // 소수를 저장하는 배열

        prime[ptr++] = 2;    // 2는 소수입니다
        prime[ptr++] = 3;    // 3은 소수입니다

        for (int n = 5 ; n <= 1000; n += 2) {    // 조사 대상은 홀수만
            boolean flag = false;
            for (int i = 1; prime[i] * prime[i] <= n; i++) {
                counter += 2;
                if (n % prime[i] == 0) {     // 나누어떨어지면 소수가 아님
                    flag = true;
                    break;                   // 더 이상 반복은 불필요
                }
            }
            if (!flag) {              // 마지막까지 나누어떨어지지 않음
                prime[ptr++] = n;     // 소수로 배열에 저장
                counter++;
            }
        }

        for (int i = 0; i < ptr; i++)     // 찾은 ptr개의 소수를 출력
            System.out.println(prime[i]);

        System.out.println("곱셈과 나눗셈을 수행한 횟수: " + counter);
    }
}

안쪽의 for문을 반복할 때마다 counter를 2씩 증가시키는 것은 아래 두 연산의 수행 횟수를 계산하기 위해서 이다.

  1. 곱셈 ˙˙˙ prime[i] * prime[i]
  2. 나눗셈 ˙˙˙ n % prime[i]

배열 복제 (클론)

배열명.clone();
int[] a = {1,2,3}
int[] b = a.clone();
import java.util.Arrays;

public class CloneArray {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        int[] b = a.clone();   // b는 a의 복제를 참조

        b[3] = 0;   // 인덱스 3번째만 값 변경

        System.out.println("a = " + Arrays.toString(a));
        System.out.println("b = " + Arrays.toString(b));
    }
}
							// 출력 결과
							// a = [1, 2, 3, 4, 5]
							// b = [1, 2, 3, 0, 5]

얼마 전에 배운...이런 메소드는 필요없었던 거였나...?

static void copy(int[] a, int[] b) {
	int num = a.length <= b.length ? a.length : b.length;
	for (int i = 0; i < num; i++)
		a[i] = b[i];

확장 for문 (for each)

배열을 다룰 때는 거의 대부분 for문을 사용한다.
보통 사용하는 for문을 '기본 for문'이라고 하는데 또 다른 for문인 '확장 for문'을 사용하면
배열의 스캔을 매우 간결하게 구현할 수 있다.

public class Main {
    public static void main(String[] args) {
        double[] a = {1.0, 2.0, 3.0, 4.0, 5.0};

        for (int i = 0; i < a.length; i++) {
            System.out.println("a[" + i + "] = " + a[i]);
        }
        double sum = 0;
        for (double i : a)
            sum += i;

        System.out.println("모든 요소의 합은 " + sum + "입니다.");
    }
}

for each문 코드

double sum = 0;
for (double i : a)
  sum += i;

위 코드를 기본 for문으로 고치면 아래와 같다.

for (int i = 0; i < a.length; i++) {
  sum += a[i];
}

for each문의 문장구조는 루프 본문에서 인덱스값을 사용할 수 없는 구조이다.
배열의 모든 요소를 스캔하는 과정에서 인덱스 자체의 값이 필요하지 않은 경우,
그 스캔은 for-each문으로 구현하는 것이 좋다.

확장for문(for each문)의 장점

  • 배열의 길이를 조사하는 절차를 줄일 수 있다.
  • 배열의 모든 요소를 빼놓지 않고 스캔할 수 있다.
    즉, 시작조건, 종료조건을 지정할 대 발생하는 실수를 방지할 수 있다.
  • Iterator와 같은 방법으로 스캔할 수 있다.

번외로 Iterator에 대해 잠깐 살펴보자.

Iterator

Iterator는 자바에서 컬렉션 인터페이스를 구현한 클래스의 요소를 순회하는데 사용되는 인터페이스이다.
Iterator 인터페이스를 구현한 클래스는 hasNext()와 next() 메소드를 제공하여 컬렉션 내의 요소들을 차례대로 접근할 수 있게 해준다.

Iterator 인터페이스의 주요 메서드는 다음과 같다.

  • hasNext(): 다음 요소가 있는지 여부를 반환한다.
  • next(): 다음 요소를 반환한다.
  • remove(): 현재 요소를 삭제한다.

Iterator 인터페이스를 사용하면 반복문을 이용해 컬렉션의 요소를 순회할 수 있다.
아래는 ArrayList에서 Iterator인터페이스를 사용하여 요소를 순회하는 간단한 예시 코드이다.

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

위의 코드에서는 ArrayList에서 iterator() 메서드를 호출하여 Iterator 인터페이스를 반환하고, 반환된 Iterator를 사용하여 리스트의 요소를 순회하고 출력한다.
이와 같이 Iterator를 사용하면 다양한 컬렉션 타입에서 요소를 순회하고 조작할 수 있다.

profile
I'm still hungry.

0개의 댓글