Chapter 02-1. 기본 자료구조_배열이란

자료구조

데이터 단위와 데이터 자체 사이의 물리적 또는 논리적인 관계 → 자료를 효율적으로 사용할 수 있도록 컴퓨터에 저장하는 방법

 

배열(array)

같은 자료형의 변수인 구성 요소(component)가 모인 것

int[] a; // 구성 요소의 자료형이 int형인 배열

 

위의 배열 선언에서 만들어지는 a는 배열 변수(array variavle)라고 부르는 특수한 변수일뿐 배열 그 자체는 아님

배열 본체는 연산자 new를 사용하여 생성함

아래와 같이 선언하면 생성한 배열 본체를 참조할 수 있음 → 왼쪽 피연산자인 배열 a에 참조하는 곳을 대입하여 배열 변수 a와 배열 본체를 연결

a = new int[5]; // new를 사용하여 배열 본체를 생성한 뒤 배열 변수 a와 연결

 

아래의 코드는 배열 본체 생성과 배열 변수 연결을 하나의 선언으로 수행

배열 본체를 생성하는 new 식을 배열 변수의 초기자(initializer)로 사용함

int[] a = new int[5];

 

인덱스 식과 구성요소

배열 본체 안의 구성 요소에 접근(access)하려면 정수형 인덱스를 연산자 [] 안에 넣은 인덱스 식을 사용함

첫 번째 배열 요소의 인덱스는 0으로, 처음부터 순서대로 a[0], a[1], … a[4] → 표현식 a[i]는 배열 a에서 처음부터 i개 뒤의 구성 요소에 접근함

구성 요소가 n개인 배열의 구성 요소는 a[n-1]까지

배열 변수 이름[인덱스] // 배열 안의 특정 구성 요소에 접근

 

구성 요솟수(길이)

배열의 구성 요솟수는 배열의 길이(length)라고도 함

배열 변수 이름.length // 배열의 구성 요솟수

 

구성 요소의 자료형이 int형인 배열

package ch02_1;

// 구성 요소의 자료형이 int형인 배열(구성 요솟수는 5 - new에 의해 본체를 생성)
public class Ex01_intArray {
    public static void main(String[] args) {
        int[] a = new int[5]; // 배열의 선언

        a[1] = 37; // a[1]에 37을 대입
        a[2] = 51; // a[2]에 51을 대입
        a[4] = a[1] * 2; // a[4]에 a[1] * 2, 곧 74를 대입

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

/*
a[0] = 0
a[1] = 37
a[2] = 51
a[3] = 0
a[4] = 74
 */

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

 

각 자료형의 기본값

위의 코드에서 값을 대입하지 않은 a[0]과 a[3]의 값이 0 → 배열의 구성 요소는 자동으로 0으로 초기화되는 규칙이 있음

배열을 생성할 때 각 구성 요소에 넣는 초깃값을 기본값(default value)이라고 함

 

모든 자료형에서 기본값은 0 또는 0에 가까운 값

자료형	기본값
byte	zero, 곧 (byte)0
short	zero, 곧 (short)0
int	zero, 곧 0
long	zero, 곧 0L
float	zero, 곧 0.0f
double	zero, 곧 0.0d
char	널(null) 문자, 곧 ‘\u0000’
boolean	거짓, 곧 false
참조형	널(null) 참조, 곧 null

 

배열의 요솟값을 초기화하며 배열 선언하기

배열 본체는 new 연산자뿐만 아니라 배열 초기화(array initializer)에서도 생성할 수 있음

배열 초기화를 사용하면 배열 본체의 생성과 동시에 각 구성 요소를 특정값으로 초기화할 수 있음

package ch02_1;

// 구성 요소의 자료형이 int형인 배열(구성 요솟수는 5 - 배열 초기화에 의해 생성)
public class Ex02_intArrayInit {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5}; // 배열 초기화에 의해 생성

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

/*
a[0] = 1
a[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5
 */

 

배열 요소의 최댓값 구하기

아래의 if문을 요솟수가 3이면 2회, 4면 3회 실행하여 최댓값을 구함

int max = a[0];
if(a[1] > max) max = a[1];
if(a[2] > max) max = a[2];

int max = a[0];
// 요솟수가 n이면 if문을 n-1회 실행
for(int i=1; i<n; i++) {
	if(a[i] > max) max = a[i];
}

 

프로그램 실행 중 배열의 요솟수 결정하기

package ch02_1;

import java.util.Scanner;

// 배열 요소의 최댓값 출력
public class Ex03_maxOfArray {
    // 배열 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) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("키의 최댓값을 구합니다.");
        System.out.print("사람 수: ");
        int num = scanner.nextInt(); // 배열의 요솟수를 입력받음
        int[] height = new int[num]; // 요숫수가 num인 배열을 생성

        for (int i = 0; i < num; i++) {
            System.out.print("height[" + i + "]: ");
            height[i] = scanner.nextInt();
        }

        System.out.println("최댓값은 " + maxOf(height) + "입니다.");
    }
}

 

접근제한자 종류

public: 모든 접근 허용

protected: 같은 패키지의 객체, 상속 관계의 객체 허용

default: 같은 패키지의 객체 허용

private: 현재의 객체 안에서만 허용

 

접근 제한자 사용

클래스: public, default

생성자: public, protected, default, private

멤버 변수: public, protected, default, private

멤버 메서드: public, protected, default, private

지역 변수: 접근 제한자를 사용할 수 없음

 

난수를 사용하여 배열의 요솟값 설정하기

package ch02_1;

import java.util.Random;
import java.util.Scanner;

// 배열 요소의 최댓값을 출력(값을 난수로 생성)
public class Ex04_maxOfArrayRand {
    // 배열 a의 최댓값을 구하여 반환
    static int maxOf(int[] a) {
        int max = a[0];
        for (int i = 0; i < a.length; i++) {
            if (a[i] > max) max = a[i];
        }
        return max;
    }

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

        System.out.println("키의 최댓값을 구합니다.");
        System.out.print("사람 수: ");
        int num = scanner.nextInt(); // 배열의 요솟수 입력받기

        int[] height = new int[num]; // 요솟수가 num인 배열 생성

        System.out.println("킷값은 아래와 같습니다.");
        for (int i = 0; i < num; i++) {
            height[i] = 100 + random.nextInt(90); // 요솟값을 난수로 결정(0~89 사이의 수)
            System.out.println("height[" + i + "]: " + height[i]);
        }

        System.out.println("최댓값은 " + maxOf(height) + "입니다");
    }
}

 

사람 수, 키를 난수로 생성하기

package ch02_1;

import java.util.Random;

// 배열 요소의 최댓값을 출력(값을 난수로 생성)
public class Ex05_maxOfArrayRand {
    // 배열 a의 최댓값을 구하여 반환
    static int maxOf(int[] a) {
        int max = a[0];
        for (int i = 0; i < a.length; i++) {
            if (a[i] > max) max = a[i];
        }
        return max;
    }

    public static void main(String[] args) {
        Random random = new Random();

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

        int num = random.nextInt(10) + 1;
        System.out.println("사람 수: " + num);

        int[] height = new int[num];

        System.out.println("킷값은 아래와 같습니다.");
        for (int i = 0; i < num; i++) {
            height[i] = 100 + random.nextInt(90);
            System.out.println("height[" + i + "]: " + height[i]);
        }

        System.out.println("최댓값은 " + maxOf(height) + "입니다");
    }
}

 

난수의 생성

Random rand = new Random(); // seed를 임의로 생성(자동으로 결정함)
Random rand = new Random(n); // seed를 지정(주어진 seed 바탕 난수 생성)

 

난수를 생성하는 Random 클래스의 메서드

구하는 식(메서드 호출)	자료형	생성한 값의 범위
nextBoolean()	boolean	true 또는 false
nextInt()	int	-2147483648 ~ +2147483647
nextInt(n)	int	0 ~ n-1
nextLong()	long	-9223372036854775808 ~ +9223372036854775808
nextDouble()	double	0.0 이상 1.0 미만
nextFloat()	float	0.0 이상 1.0 미만

 

요솟수가 n인 배열 요소를 역순으로 정렬하는 알고리즘

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

 

두 값의 교환 과정(x와 y의 값을 교환)

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

 

배열 요소 역순 정렬 과정을 출력

package ch02_1;

import java.util.Arrays;
import java.util.Scanner;

// 배열 요소 역순 정렬 과정을 출력
public class Ex07_reverseArray {
    static void reverse(int[] a) {
        System.out.println(Arrays.toString(a));
        for (int i = 0; i < a.length / 2; i++) {
            int index = a.length - i - 1;
            System.out.println("a[" + i + "]과 a[" + index + "]을 교환합니다.");
            int temp1 = a[i];
            a[i] = a[index];
            a[index] = temp1;
            System.out.println(Arrays.toString(a));
        }
    }

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

        System.out.print("요솟수는 : ");
        int num = scanner.nextInt(); // 요솟수

        int[] x = new int[num]; // 요솟수가 num인 배열

        for (int i = 0; i < num; i++) {
            System.out.print("x[" + i + "] : ");
            x[i] = scanner.nextInt();
        }

        reverse(x); // 배열 a의 요소를 역순으로 정렬

        System.out.println("역순 정렬을 마쳤습니다.");
    }
}

/*
요솟수는 : 7
x[0] : 2
x[1] : 5
x[2] : 1
x[3] : 3
x[4] : 9
x[5] : 6
x[6] : 7
[2, 5, 1, 3, 9, 6, 7]
a[0]과 a[6]을 교환합니다.
[7, 5, 1, 3, 9, 6, 2]
a[1]과 a[5]을 교환합니다.
[7, 6, 1, 3, 9, 5, 2]
a[2]과 a[4]을 교환합니다.
[7, 6, 9, 3, 1, 5, 2]
역순 정렬을 마쳤습니다.
 */

 

배열의 모든 요소의 합계를 구하여 반환

package ch02_1;

import java.util.Scanner;

// 배열의 모든 요소의 합계를 구하여 반환
public class Ex08_sumOf {
    // 배열의 요솟값을 출력
    static int sumOf(int[] a) {
        int result = 0;
        for (int i = 0; i < a.length; i++) {
            result += a[i];
        }
        return result;
    }

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

        System.out.print("요솟수는 : ");
        int num = scanner.nextInt(); // 요솟수
        int[] a = new int[num]; // 요솟수가 num인 배열

        for (int i = 0; i < num; i++) {
            System.out.print("a[" + i + "]: ");
            a[i] = scanner.nextInt();
        }

        System.out.println("모든 요소의 합계는 " + sumOf(a) + "입니다.");
    }
}

/*
요솟수는 : 3
a[0]: 1
a[1]: 2
a[2]: 3
모든 요소의 합계는 6입니다.
 */

 

배열 b의 모든 요소를 배열 a에 복사하는 메서드

package ch02_1;

import java.util.Scanner;

// 배열b의 모든 요소를 배열a에 복사하는 메서드
public class Ex09_copy {
    // 배열 b의 모든 요소를 배열 a에 복사
    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];
        }
    }

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

        System.out.print("a의 요솟수는 : ");
        int numA = scanner.nextInt(); // 요솟수
        int[] a = new int[numA]; // 요솟수가 num인 배열

        for (int i = 0; i < numA; i++) {
            System.out.print("a[" + i + "]: ");
            a[i] = scanner.nextInt();
        }

        System.out.print("b의 요솟수는 : ");
        int numB = scanner.nextInt(); // 요솟수
        int[] b = new int[numB]; // 요솟수가 num인 배열

        for (int i = 0; i < numB; i++) {
            System.out.print("b[" + i + "]: ");
            b[i] = scanner.nextInt();
        }

        copy(a, b);

        System.out.println("배열 b의 모든 요소를 배열 a에 copy 하였습니다.");
        for (int i = 0; i < numA; i++) {
            System.out.println("a[" + i + "] = " + a[i]);
        }
    }
}

/*
a의 요솟수는 : 2
a[0]: 1
a[1]: 2
b의 요솟수는 : 3
b[0]: 5
b[1]: 4
b[2]: 3
배열 b의 모든 요소를 배열 a에 copy 하였습니다.
a[0] = 5
a[1] = 4
 */

 

배열의 모든 요소를 역순으로 복사하는 메서드

package ch02_1;

import java.util.Scanner;

// 배열의 모든 요소를 역순으로 복사하는 메서드
public class Ex10_rCopy {
    // 배열 b의 모든 요소를 배열 a에 역순으로 복사
    static void rcopy(int[] a, int[] b) {
        int length = a.length <= b.length ? a.length : b.length;
        for (int i = 0; i < length; i++) {
            a[i] = b[b.length - i - 1];
        }
    }

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

        System.out.print("a의 요솟수는 : ");
        int numA = scanner.nextInt(); // 요솟수
        int[] a = new int[numA]; // 요솟수가 num인 배열

        for (int i = 0; i < numA; i++) {
            System.out.print("a[" + i + "]: ");
            a[i] = scanner.nextInt();
        }

        System.out.print("b의 요솟수는 : ");
        int numB = scanner.nextInt(); // 요솟수
        int[] b = new int[numB]; // 요솟수가 num인 배열

        for (int i = 0; i < numB; i++) {
            System.out.print("b[" + i + "]: ");
            b[i] = scanner.nextInt();
        }

        rcopy(a, b);

        System.out.println("배열 b의 모든 요소를 배열 a에 역순으로 copy 하였습니다.");
        for (int i = 0; i < numA; i++) {
            System.out.println("a[" + i + "] = " + a[i]);
        }
    }
}

/*
a의 요솟수는 : 2
a[0]: 1
a[1]: 2
b의 요솟수는 : 4
b[0]: 1
b[1]: 2
b[2]: 3
b[3]: 4
배열 b의 모든 요소를 배열 a에 역순으로 copy 하였습니다.
a[0] = 4
a[1] = 3
 */

 

전위형 증가 연산자와 후위형 증가 연산자

전위형 증가 연산자 ++a: 식 전제를 평가하기 전에 피연산자의 값 증가

후위형 증가 연산자 a++: 식 전체를 평가한 후 피연산자의 값 증가

 

기수 변환하기

10진수를 n진수로 변환하려면, 정수를 n으로 나눈 나머지를 몫이 0이 될 때까지 반복하고 이러한 과정을 통해 구한 나머지를 거꾸로 나열하면 됨

 

10진수(decimal)

0 1 2 3 4 5 6 7 8 9
1234 = 1 * 10^3 + 2 * 10^2 + 3 * 10^1 + 4 * 10^0

 

2진수(binary)

0 1
0b1011 = 1 * 2^3 + 0 * 2^2 + 1 * 2^1 + 1 * 2^0 // 2진수 표시 0b

 

8진수(octal)

0 1 2 3 4 5 6 7
05307 = 5 * 8^3 + 3 * 8^2 + 0 * 8^1 + 6 * 8^0 // 8진수 표시 0

 

16진수(hexadecimal)

0 1 2 3 4 5 6 7 8 9 A B C D E F
0x12A0 = 1 * 16^3 + 2 * 16^2 + A * 16^1 + 0 * 16^0 // 16진수 표시 0x

 

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

package ch02_1;

import java.util.Scanner;

// 입력받은 10진수를 2진수~36진수로 기수 변환 출력
public class Ex11_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);

        // 배열 d를 역순으로 정렬
        for (int i = 0; i < digits / 2; i++) {
            char t = d[i];
            d[i] = d[digits - i - 1];
            d[digits - i - 1] = t;
        }

        return digits;
    }

    public static void main(String[] args) {
        Scanner scanner = 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 = scanner.nextInt();
            } while (no < 0);

            do {
                System.out.print("변환하고자 하는 진수(2~36): ");
                cd = scanner.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 = scanner.nextInt();
        } while (retry == 1);
    }
}

/*
10진수를 기수 변환합니다.
변환하는 음이 아닌 정수: 59
변환하고자 하는 진수(2~36): 2
2진수로 111011입니다.
한 번 더 할까요? (1. 예 / 0. 아니요): 0
 */

 

기수 변환 과정 출력 프로그램

package ch02_1;

import java.util.Scanner;

// 기수 변환 과정 출력 프로그램
public class Ex12_cardConv {
    // 정숫값 no를 cd진수로 변환하여 배열 cno에 역순으로 저장하고 자릿수 반환
    static int cardConv(int no, int cd, char[] cno) {
        int n = ((Integer) no).toString().length(); // 변환 전 자릿수
        int dno = 0; // 변환 후 자릿수
        String dChar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

        System.out.printf(String.format("%%2d | %%%dd\\n", n), cd, no);

        do {
            System.out.printf("   +");
            System.out.print("-".repeat(n + 2));
            System.out.println();

            if (no / cd != 0) {
                System.out.printf(String.format("%%2d | %%%dd    ... %%d\\n", n), cd, no / cd, no % cd);
            } else {
                System.out.printf(String.format("     %%%dd    ... %%d\\n", n), no / cd, no % cd);
            }

            cno[dno++] = dChar.charAt(no % cd); // cd로 나눈 나머지를 저장
            no /= cd;
        } while (no != 0);

        // 역순으로 정렬
        for (int i = 0; i < dno / 2; i++) {
            char temp = cno[i];
            cno[i] = cno[dno - i - 1];
            cno[dno - i - 1] = temp;
        }

        return dno;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int no; // 변환하는 정수
        int cd; // 기수
        int dno; // 변환 후의 자릿수
        int retry; // 재시작
        char[] cno = new char[32]; // 변환 후 각 자리 숫자 넣어두는 배열

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

            do {
                System.out.print("변환하고자 하는 진수(2~36): ");
                cd = scanner.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 = scanner.nextInt();
        } while (retry == 1);
    }
}

/*
10진수를 기수 변환합니다.
변환하는 음이 아닌 정수: 59
변환하고자 하는 진수(2~36): 2
 2 | 59
   +----
 2 | 29    ... 1
   +----
 2 | 14    ... 1
   +----
 2 |  7    ... 0
   +----
 2 |  3    ... 1
   +----
 2 |  1    ... 1
   +----
      0    ... 1
2진수로 111011입니다.
한 번 더 할까요? (1. 예 / 0. 아니요): 0
 */

 

1000 이하의 소수 나열(버전1)

package ch02_1;

// 1000 이하의 소수 나열(버전1)
public class Ex13_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);
    }
}

/*
나눗셈을 수행한 횟수: 78022
 */

 

소수 판단

n이 2 또는 3으로 나누어 떨어지지 않으면 23인 4 혹은 23인 6으로도 나누어 떨어지지 않음

즉, 2부터 n-1까지의 어떤 소수로도 나누어 떨어지지 않는다.

만약 어떤 정수 n이 n의 제곱근 이하의 어떤 소수로도 나누어 떨어지지 않으면 소수이다.

 

1000 이하의 소수 나열(버전2)

package ch02_1;

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

        prime[ptr++] = 2; // 소수 2 넣고 index값 증가시킴

        // 소수를 찾는 것이기에 홀수만 조사
        for (int n = 3; n <= 1000; n+=2) {
            int i;
            for (i = 1; i < ptr; i++) {
                count++;
                // 이미 찾은 소수로 나눠보기
                if(n % prime[i] == 0) {
                    break; // 나누어 떨어지면 소수가 아니기에 반복문 탈출
                }
            }
            // 끝까지 나누어 떨어지지 않으면 소수 배열에 저장
            if(ptr == i) {
                prime[ptr++] = n;
            }
        }

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

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

/*
나눗셈을 수행한 횟수: 14622
 */

 

1000 이하의 소수 나열(버전3)

package ch02_1;

// 1000이하의 소수 나열(버전3)
public class Ex15_primeNumber3 {
    public static void main(String[] args) {
        int count = 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;

            // prime[i]의 제곱이 n 이하인지 판단
            for (int i = 1; prime[i]*prime[i] <=n ; i++) {
                count += 2;
                // 나누어 떨어지면 소수가 아니기에 반복문 탈출
                if(n % prime[i] == 0) {
                    flag = true;
                    break;
                }
            }

            // 마지막까지 나눠지지 않았을 경우 소수 배열에 저장
            if(!flag) {
                prime[ptr++] = n;
                // prime[i]*prime[i] <=n 조건이 성립하지 않는 경우 여기서곱셉 연산 횟수 증가시켜줌
                count++;
            }
        }

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

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

/*
곱셈과 나눗셈을 수행한 횟수: 3774
 */

 

배열 요소의 접근

접근 여부는 모두 런타임(실행 시)에 검사 → 만약 범위를 벗어나는 인덱스값을 사용하면 IndexOutOfBoundsException 발생

 

배열 복제

package ch02_1;

import java.util.Arrays;

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

        b[3] = 0; // 한 요소에만 0 대입

        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]
 */

 

배열의 모든 요소의 합을 구하여 출력(확장 for문)

package ch02_1;

// 배열의 모든 요소의 합을 구하여 출력(확장 for문)
public class Ex17_arraySumForIn {
    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 + "입니다.");
    }
}

/*
a[0] = 1.0
a[1] = 2.0
a[2] = 3.0
a[3] = 4.0
a[4] = 5.0
모든 요소의 합은 15.0입니다.
 */