C5

5.1 데이터 타입 분류

자바의 데이터 타입은 기본타입(primitive type)과 참조타입(reference type)으로 분류된다. 참조 타입은 객체의 번지를 참조하는 타입으로 배열, 열거, 클래스, 인터페이스 타입이 있다.

기본 타입으로 선언된 변수는 저장된 값을 갖지만, 참조 타입으로 선언된 변수는 객체가 생성하는 메모리의 번지를 저장한다.

변수들은 모두 스택이라는 메모리 영역에 생성된다. 위에서 말한대로 아래 age, price는 직접 값을 저장하지만, 참조 타입 변수인 name과 hobby는 힙 메모리의 영역의 String 객체 번지를 저장하고 이 번지를 통해 String 객체를 참조한다.

	int age = 25;
   	double price = 100.5;
    
    String name = "신용권";
    String name = "독서";

5.2 메모리 사용 영역

JVM이 구동되면 JVM은 운영체제에서 할당받은 메모리 영역을 다음과 같이 구분해서 사용한다. (사진)

메소드 영역	바이트코드 파일을 읽은 내용이 저장되는 영역 클래스별로 상수, 정적 필드, 메소드 등이 저장된다. ( 바이트코드 파일 내용 저장소)

힙 영역	객체가 생성되는 영역이며 객체의 번지는 메소드 영역과 스택 영역의 상수와 변수에서 참조할 수 있다.

스택영역	메소드를 호출시 생성되는 프레임이 저장되는 영역이며 호출이 끝나면 프레임은 자동적으로 제거된다. 여기에서 기본, 참조 타입 변수가 생성되고 제거되며 프레임 내부에는 로컬 변수 스택이 있다.

5.3 참조 타입 변수의 ==, != 연산

"==" , "!=" 는 변수의 값이 같은지, 아닌지 비교를 한다. 참조 타입 변수는 객체의 번지를 저장하기에 연산자는 번지를 비교하는 것이 된다. 번지가 같다면 동일한 객체를 참조하는 것이고, 다르다면 다른 객체를 참조하는 것이다.

아래와 같이 참조하고 있다면 연산결과는..

스택영역	힙 영역
refVar1	객체1
refVar2	객체2
refVar3	객체2

	refVar1 == refVar2 // 결과 : fasle
    refVar1 != refVar2 // 결과 : true
    refVar2 == refVar3 //결과 : true
    refVar2 != refVar3 // 결과 : false

"==" , "!=" 연산자로 객체를 비교하는 코드는 if문에서 많이 사용된다.

	if ( refVar2 == refVar3 ) {...}

5.4 null 과 NullPointException

참조 타입 변수는 null값을 가질 수 있고 초기값으로도 사용가능 하기때문에 스택영에 생성된다.

	String refVar1 = "자바";
    String refVar2 = null;
    
    refVar1 == null // false
    refVar2 == null // true
   	refVar1 != null // true
    refVar2 != null // false

참조 변수를 사용하면서 가장 많이 마주하는게 NullPointExeception다. 변수가 null인 상태에서 객체의 데이터나 메소드를 사용하려 할 때 이 예외가 발생한다.

	int[] intArray = null;
    intArrayy[0] = 10;  // 배열 객체가 없으므로 10을 저장할 수 없기 때문에 오류
    String str = null;
    System.out.println(" 총 문자 수 : " + str.length()); // str변수가 참조하는 String 객체가 없으므로 길이를 구할 수 없어 오류

경우에 따라서 참조 타입 변수에 null값을 대입하기도 하는데 이 경우 번지를 잃게 되므로 더 이상 객체를 사용할 수 없다. 어떤 변수에도 객체를 참조하지 않으면 해당 객체는 사용할 수 없는 객체가 되고 힙 메모리에는 있지만 위치 정보를 모르기 때문에 사용할 수 없어 Garbage Collector가 실행시켜 자동으로 제거한다. 객체를 제거하는 유일한 방법은 객체의 모든 참조를 없애는 것이다.

		String hobby = "여행";
        hobby = null; // "여행"에 해당되는 String 객체는 쓰레기가 됨
        
        String kind1 = "자동차";
        String kind2 = kind1; /// kind1 변수에 저장되어 있는 번지를 kind2 변수에 대입
        kind1 = null; // 자동차에 해당되는 String 객체는 쓰레기가 아님
        System.out.println("kind2 : " + kind2);

5.5 문자열(String) 타입

자바의 문자열은 String 객체로 생성된다. 변수에 문자열 리터럴이 대입되면 문자열은 String 객체로 생성되고, 객체의 번지가 각각 대입된다.

문자열 비교

문자열 리터럴이 동일하다면 String 객체를 공유하도록 설계되어 있다.

		String name1 = "홍길동";
        String name2 = "홍길동"; // 같은 String 객체에 번지가 저장된다.

new 연산자는 새로운 객체를 만드는 연산자로 객체 생성 연산자라고 한다.

		String name1 = new String("홍길동");
        String name2 = new String("홍길동");

new 연산자로 생성하면 서로 다른 String 객체의 번지를 가지게 되기 때문에, 문자열 리터럴로 생성하느냐 new 연산자로 생성하느냐에 따라 비교 연산자의 결과가 달라질 수 있다.

		String name 1 ="홍길동";
        String name 2 ="홍길동";
        String name 3 =new String("홍길동");
        name1==name2 // true
        name2==name3 // false

동일한 String 객체든 다른 String 객체든 상관없이 내부 문자열만 비교시 equals() 메소드를 사용한다.

		boolean result = str1.equals(str2);
        boolean result = !str1.equals(str2);

위 내용들의 전체적 예시.

        String strVar1 = "홍길동";
        String strVar2 = "홍길동";
        if(strVar1 == strVar2 ) {
            System.out.println("strVar1과 strVar2는 참조가 같다");
        } else {
            System.out.println("strVar1과 strVar2는 참조가 다르다");
        }
        if(strVar1.equals(strVar2)) {
            System.out.println("strVar1과 strVar2는 문자열이 같다");
        } else {
            System.out.println("strVar1과 strVar2는 문자열이 다르다.");
        }
        String strVar3 = new String("홍길동");
        String strVar4 = new String("홍길동");
        if (strVar3 == strVar4) {
            System.out.println("strVar3과 strVar4는 참조가 같다");
        } else {
            System.out.println("strVar3과 strVar4는 참조가 다르다.");
        }
        if (strVar3.equals(strVar4)) {
            System.out.println("strVar3과 strVar4는 문자열이 같다");
        } else {
            System.out.println("strVar3과 strVar4는 문자열이 다르다.");
        }

출력 결과는

strVar1과 strVar2는 참조가 같다
strVar1과 strVar2는 문자열이 같다
strVar3과 strVar4는 참조가 다르다.
strVar3과 strVar4는 문자열이 같다

(" ") 빈 문자열도 대입할 수 있는데 이 경우도 equals() 메소드를 사용한다.

문자 추출

문자자열에서 특정 위치의 문자를 얻고 싶다면 charAt() 메소드를 이용할 수 있다. charAt() 메소드는 매개값으로 주어진 인덱스의 문자를 리턴한다. 여기서 인덱스란 0에서부터 '문자열의 길이-1' 까지의 번호를 말한다.

		String subject = "자바 프로그래밍";
        char charValue = subject.charAt(3) // '프'가 해당된다.

성별 확인하는 예제코드

        String ssn = "9506241230123";
        char sex = ssn.charAt(6);
        switch (sex) {
            case '1':
            case'3':
                System.out.println("남자입니다.");
                break;
            case '2':
            case '4':
                System.out.println("여자입니다.");
                break;
        }

문자열 길이

문자열에서 문자의 개수를 얻고 싶다면 length() 메소드를 사용한다.

       String ssn = "9506241230123";
        int length = ssn.length(); // length 변수에 ssn의 문자열 길이가 저장됨
        if (length == 13) {
            System.out.println("주민등록번호 자릿수가 맞습니다.");
        } else  {
        System.out.println("주민등록번호 자릿수가 틀립니다.");
        } 

문자열 대체

문자열에서 특정 문자열을 다른 문자열로 대체하고 싶다면 replace() 메소드를 사용한다. replace() 메소드는 기존 문자열은 그대로, 새로운 문자열을 리턴한다.

        String oldStr = "자바 문자열은 불변입니다. 자바 문자열은 String 입니다.";
        String newStr = oldStr.replace("자바", "JAVA");

        System.out.println(oldStr);
        System.out.println(newStr);

문자열 잘라내기

문자열에서 특정 위치의 문자열을 잘라내어 가져오고 싶다면 substring() 메소드를 사용한다.

메소드	설명
substring(int beginIndex)	beginIndex에서 끝까지 잘라내기
substring(int beginIndex, int endIndex)	beginIndex에서 endIndex 앞까지 잘라내기

        String ssn = "880815-1234567";

        String firstNum = ssn.substring(0,6 );
        System.out.println(firstNum);

        String secondNum = ssn.substring(7);
        System.out.println(secondNum);

문자열 찾기

문자열에서 특정 문자열의 위치를 찾고자 할 때에는 주어진 문자열이 시작되는 인덱스를 리턴하는 indexOf() 메소드를 사용한다. 만약 주어진 문장이 포함되어 있지 않으면 indexOf() 메소드는 -1을 리턴한다. 주어진 문자열이 포함되어 있는지 여부에 따라 실행 코드를 달리하고 싶다면 if조건식을 사용 할 수 있다

	int index = subject.indexOf("프로그래밍");
    if(index == 1) {
    // 포함이 되어 있는 경우
    } else { 
    //포함이 안되어 있는 경우
    }

주어진 문자열이 단순히 포함되어 있는지만 조사하고 싶다면 contains() 메소드를 사용하면 편리하다. 포함시에는 true를 리턴하고 미포함시에는 false를 리턴한다.

        String subject = "자바 프로그래밍";
        int location = subject.indexOf("프로그래밍"); // location 3 저장
        System.out.println(location); // 3출력
        String substring = subject.substring(location); //3번째부터 짜름 , "프로그래밍"
        System.out.println(substring); "프로그래밍" 출력
        
        location = subject.indexOf("자바");
        if(location != -1) { // " 자바가 포함되면 
            System.out.println("자바와 관련된 책이군요.");
        } else  {
            System.out.println("자바와 관련없는 책이군요.");
        }
         boolean result = subject.contains("자바");
        if(result) {  
            System.out.println("자바와 관련된 책이군요.");
        } else  {
            System.out.println("자바와 관련없는 책이군요.");
        }

문자열 분리

문자열이 구분자를 사용하여 여러 개의 문자열로 구성되어 있을 경우, 이를 따로 분리해서 얻고 싶다면 split() 메소드를 사용한다.

split() 메소드 호출시 쉼표를 제공하면 분리된 문자열로 배열을 얻을 수 있다.

        String board = "1, 자바 학습, 참조 타입 String을 학습합니다., 홍길동";

    // 문자열 분리
    String[] tokens = board.split(",");
    // 인덱스별로 읽기
    System.out.println("번호: " + tokens[0]);
    System.out.println("제목: " + tokens[1]);
    System.out.println("내용: " + tokens[2]);
    System.out.println("성명: " + tokens[3]);
    System.out.println();
    // for문을 이용한 읽기
    for (int i=0; i<tokens.length; i++) {
        System.out.println(tokens[i]);
    }

## 5.6 배열(Array) 타입
#### 변수는 하나의 값만 저장할 수 있다. 저장해야 할 값의 수가 많아지면 그만큼 많은 변수가 필요하다. 책에 있는 예로 30명의 성적을 저장하고 평균값을 구한다고 하면 30명의 성적을 저장하기 위한 변수 30개를 선언해야 한다.
```java
		int score1 = 83;
        int score2 = 90;
        .
        .
        .
        int score30 = 99;

그 후 모든 변수들을 다 더해야 한다. 이러한 방법은 매우 비효율적인 코딩이 된다. 이러한 문제를 해결하고자 사용하는 방법이 배열이다. 배열은 연속된 공간에 값을 나열 후 , 각 값에 인덱스를 부여해 놓은 자료구조이다. 배열의 특징으로는 같은 타입의 값만 관리하며 배열의 길이를 한번 결정하면 배열의 길이를 줄이거나 늘릴 수 없다.

앞의 예에서 30명의 성적은 score 배열로 생성할 수 있다.

인덱스는 대괄호와 함께 사용되며 값을 읽거나 저장하는데 사용된다. score[0] 은 83, score[1] 은 90 이런형식으로. 이렇게 성적을 배열에 저장한다면 평균값은 배열 인덱스를 이용하여 for문으로 쉽게 구할 수 있다.

		int sum = 0;
        for(int i=0; i<=30; i++) { //수 백명의 학생으로 늘어나도 i< 수백명 으로 바꾸면 되기에 간편하다.
        sum += score[i];
        }
        int avg = sum /30;

배열 변수 선언

변수를 사용할 때 선언을 하는 것과 같이 배열 변수 또한 선언을 해야한다. 배열 변수 선언은 아래 두 가지 형태로 작성이 가능하지만, 관례적으로 첫 번째 방법을 사용한다고 한다.

		타입 [] 변수;
        타입 변수[];
 		
 		// 배열 선언 방법
        int[] intArray;
        String[] strAraay;
        double[] doubleArray;
        
        int intAraay[]
        String strArray[]
        double doubleArray[]
        

배열 변수는 참조 변수이며 배열도 객체이므로 힙 영역에 생성되고 배열 변수는 힙 영역의 배열 주소를 저장한다. 참조할 변수가 없다면 배열 변수도 null로 초기화가 가능하나 변수[인덱스]로 값을 읽거나 저장하게 되면 NullPointExeception이 발생한다.

값 목록으로 배열 생성

배열에 저장될 값의 목록이 있다면 더욱 간편하게 배열을 생성할 수 있다.

		타입[] 변수 = { 값0, 값1, 값2, 값3, 값, ...};

중괄호에 나열된 값들을 항목으로 가지는 배열을 힙에 생성하고, 번지를 리턴한다. 배열 변수는 리턴된 번지를 저장함으로써 참조가 이루어진다.

		//사계절 문자열을 갖는 배열
        String[] season = { "Winter", "Spring", "Summer", "fall" };
		// 이렇게 생성된 배열에서는 "Winter"를 season[0]으로 읽을 수 있다.
        // 대입연산자를 통해 배열에 저장되어 있는 값을 바꿀 수 있다.

        //배열 변수 선언과 배열 생성
        String[] season = { "Spring", "Summer", "Fall", "Winter" };

        //배열의 항목값 읽기
        System.out.println("season[0] : " + season[0]);
        System.out.println("season[1] : " + season[1]);
        System.out.println("season[2] : " + season[2]);
        System.out.println("season[3] : " + season[3]);

        //인덱스 1번 항목의 값 변경
        season[1] = "여름";
        System.out.println("season[1] : " + season[1] );
        System.out.println();

        //배열 변수 선언과 배열 생성
        int[] scores = { 83, 90 ,87 };

        //총합과 평균 구하기
        int sum = 0;
        for(int i=0; i<=2; i++) {
            sum += scores[i];
        }
        System.out.println("총합 : " + sum);
        double avg = (double) sum / 3;
        System.out.println("평균 : " + avg);
    }
}

배열 변수를 미리 선언한 후에는 값 목록을 변수에 대입할 수 없다

		타입[] 변수;
        변수 = { 값0, 값1 ,값2 , ... }; // 컴파일 에러

배열 변수를 선언한 시점과 값 목록이 대입되는 시점이 다르다면 new 타입[ ]을 중괄호 앞에 붙여주면 된다.

		//변수 = new 타입[] { 값0, 값1, 값2, 값3, ... };
        // String 타입이라면 new String[]을 중괄호 앞에 붙여줘야 한다.
        String[] names = null;
        names = new String[] { "신용권", "홍길동", "김자바" };       

printItem() 메소드를 호출할 때 매개값으로 중괄호로 감싼 값 목록을 주면 에러가 발생한다.

		//메소드 선언
        void printItem(int[] scores) { ... }
        //잘못된 메소드 선언 
        PrintItem( { 95, 85, 90} ); // 컴파일 에러
        //올바른 메소드 선언
        printItem( new int[] { 95, 85, 90} );

new 연산자로 배열 생성

값의 목록은 없지만 향후 값들을 저장할 목적으로 배열을 미리 생성할 수 있는데 new 연산자를 아래와 같이 사용해서 배열 객체를 생성시킨다. ( 길이는 배열이 저장할 수 있는 항목의 수이다.)

		타입[] 변수 = new 타입[길이]
        // 변수 선언 후 대입 방법
        타입[] 변수 = null;
        변수 = new 타입[길이];

		int[] scores = new int[30]; // scores[0] ~ scores[29] 의 모든 값은 0으로 초기화 된다.
        String[] names = new String[30] // names[0]~name[29] 의 모든 값은 null로 초기화된다.

배열 생성 후 인덱스 항목을 새로운 값으로 변경하는 방법은 동일하다 ( 변수[인덱스] = 값 )

배열 길이

배열의 길이란 배열에 저장할 수 있는 항목 수를 말한다. 코드에서 배열의 길이를 얻으려면 도트(.) 연산자를 사용해서 참조하는 배열의 length 필드를 읽으면 된다.

		배열변수.length;

배열의 length 필드는 읽기만 가능하므로 다음과 같이 값을 변경할 수는 없다.

		intArray.length = 10; //컴파일 에러 발생

        //배열 변수 선언과 배열 대입
        int[] scores = { 84, 90, 96 };
        //배열 항목의 총합 구하기
        int sum = 0;
        for(int i=0; i<scores.length; i++) {
            sum += scores[i];
        }
        System.out.println("총합 : " + sum);
        //배열 항목의 평균 구하기
        double avg = (double) sum / scores.length;
        System.out.println("평균 : " + avg);

인덱스를 초과해서 사용하면 ArrayIndexOutOfBoundsExeception이 발생한다.

5.7 다차원 배열

배열 항목에는 또 다른 배열이 대입될 수 있는데, 이러한 배열을 다차원 배열이라고 부른다. 아래그림은 2차원과 3차원 배열의 모양을 보여준다.

다차원 배열에서 각 차원의 항목에 접근하는 방법은 다음과 같다.

		변수[1차원인덱스][2차원인덱스]...[N차원인덱스] 
        
        // 위 그림 값
        변수[0][0][0] // 값1
        변수[0][1][0] // 값3
        변수[1][0][1] // 값6

값 목록으로 다차원 배열 생성

다차원 배열을 생성하려면 배열 변수 선언 시 타입 뒤에 대괄호 []를 차원의 수만큼 붙이고, 값 목록도 마찬가지로 차원의 수만큼 중괄호를 중첩시킨다.

		타입[][] 변수 = {
        {값1, 값2, ... }, 	// 1차원 배열의 0인덱스
        {값3, 값4, ... },		// 1차원 배열의 1인덱스
        ...
        };

new 연산자로 다차원 배열 생성

new 연산자로 다차원 배열을 생성하려면 배열 변수 선언 시 타입 뒤에 '[ ]' 를 차원의 수만큼 붙이고, new 타입 뒤에도 차원의 수만큼 '[ ]' 를 작성하면 된다.

		타입[][] 변수 = new 타입[1차원수][2차원수]; //초기값 정수: 0 ,실수: 0.0 ,논리: false ,참조:null

5.8 객체를 참조하는 배열

기본 타입 배열은 각 항목에 값을 직접 저장하지만, 참조 타입 배열은 객체의 번지를 저장한다. String[ ] 배열의 항목은 String 변수와 동일하게 참조 타입 변수로 취급된다.

		String[] languages = new String[3];
        languages[0] = "Java";
        languages[1] = "Java";
        languages[2] = new String("Java");
        
        System.out.println( languages[0] == languages[1]); // true 같은 객체 참조
        System.out.println( languages[0] == languages[2]); // false 같은 객체 참조X
        System.out.println( languages[0].equals(languages[2]) ); //true 문자열이 같음

5.9 배열 복사

배열은 한 번 생성하면 길이를 변경할 수 없다. 더 많은 저장 공간이 필요하다면 더 큰 길이의 배열을 새로 만들고 이전 배열로부터 항목들을 복사해야 한다.

for문을 이용한 배열 복사

        //길이 3인 배열
        int[] oldIntArray = { 1, 2, 3};
        //길이 5인 배열을 새로 생성
        int[] newIntArray = new int[5];
        //배열 항목 복사
        for (int i=0; i<oldIntArray.length; i++) {
            newIntArray[i] = oldIntArray[i];
        }
        //배열 항목 출력
        for (int i=0; i<newIntArray.length; i++) {
            System.out.print(newIntArray[i] + ", ");
        }

위 예제에서 newIntArray 변수가 참조하는 초기값은 0이므로 복사되지 않은 3번 인덱스와 인덱스 항목0을 유지하고 있다.

배열 복사를 위한 더 간단한 방법이 있는데 System의 arraycopy() 메소드를 이용하면 한 줄만으로 배열 복사가 가능하다.

       //길이 3인 배열
        String[] oldStrArray = { "Java", "array", "copy" };
        //길이 5인 배열
        String[] newStrArray = new String[5];
        //배열 항목 복사
        System.arraycopy(oldStrArray, 0, newStrArray, 0 ,oldStrArray.length);
        //배열 항목 출력
        for(int i=0; i<newStrArray.length; i++) {
            System.out.print(newStrArray[i] + ", ");
        }

newStrArray 변수가 참조하는 배열의 항목 초기값은 null이므로 복사되지 않은 3번 인덱스와 4번 인덱스 항목은 null을 유지하고 있다. 번지 복사가 되어 참조하는 String 객체는 변함이 없다.

5.10 배열 항목 반복을 위한 향상된 for 문

자바는 배열 및 컬렉션을 좀 더 쉽게 처리할 목적으로 다음과 같은 for문을 제공한다. 카운터 변수와 증감식을 사용하지 않고, 항목의 개수만큼 반복한 후 자동으로 for문을 빠져나간다.

        //배열 변수 선언과 배열 생성
        int[] scores = { 95, 71, 84, 93, 87 };
        //배열 항목 전체 합 구하기
        int sum = 0;
        for (int score : scores) {
            sum = sum + score;
        }
        System.out.println("점수 총합 = " + sum);
        //배열 항목 전체 평균 구하기
        double avg = (double) sum / scores.length;
        System.out.println("점수 평균 = " + avg);

5.11 main() 메소드의 String[ ] 매개변수 용도

자바 실행시 지금까지 main() 메소드를 사용했는데 여기에서 String[] args매개변수가 왜 필요한가?

        if(args.length != 2) {
            System.out.println("프로그램 입력값이 부족");
            System.exit(0);
        }
        
        String strNum1 = args[0];
        String strNum2 = args[1];
        
        int num1 = Integer.parseInt(strNum1);
        int num2 = Integer.parseInt(strNum2);
        
        int result = num1 + num2;
        System.out.println(num1 + " + " + num2 + " = " + result);

5.12 열거(Enum) 타입

한정된 값을 갖는 타입을 열거 타입이라고 한다.

public enum Week {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

import java.util.Calendar;

public class WeekExample {
    public static void main(String[] args) {
        //Week 열거 타입 변수 선언
        Week today = null;

        //Calendar 얻기
        Calendar cal = Calendar.getInstance();

        //오늘의 요일 얻기(1~7)
        int week = cal.get(Calendar.DAY_OF_WEEK);

        //숫자를 열거 상수로 변환해서 변수에 대입
        switch(week) {
            case 1: today = Week.SUNDAY ; break;
            case 2: today = Week.MONDAY ; break;
            case 3: today = Week.TUESDAY ; break;
            case 4: today = Week.WEDNESDAY ; break;
            case 5: today = Week.THURSDAY ; break;
            case 6: today = Week.FRIDAY ; break;
            case 7: today = Week.SATURDAY ; break;
        }

        //열거 타입 변수를 사용
        if(today == Week.SUNDAY) {
            System.out.println("일요일에는 축구를 합니다.");
        } else {
            System.out.println("열심히 자바를 공부합니다.");
        }
    }
}

1. 4번

2. 3번

3. 2번

4. 2번

5. 3번

6.

    public static void main(String[] args) {
        int max = 0;
        int[] array = {1, 5, 3, 8, 2};
        for (int i = 0; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
            System.out.println("max: " + max);
        }
    }

7.

        public static void main(String[] args) {
            int[][] array = {
                    {95, 86},
                    {83, 92, 96},
                    {78, 83, 93, 87, 88}
            };
            int sum = 0;
            double avg = 0.0;
            int count = 0;
            for(int i=0; i<array.length; i++) {
                for(int j=0; j<array[i].length; j++) {
                    sum += array[i][j];
                    count++;
                }
            }
            avg = (double) sum / count;
            System.out.println("sum: " + sum);
            System.out.println("avg: " + avg);
        }

8.

import java.util.Scanner;
public class Example {
public static void main(String[] args) {
 boolean run = true;

 int studentNum = 0;
 int[] scores = null;
 
     public static void main(String[] args) {
        boolean run = true;

        int studentNum = 0;
        int[] scores = null;
        Scanner scanner = new Scanner(System.in);

        while (run) {
            System.out.println("----------------------------------------------------");
            System.out.println("1.학생수 | 2.점수입력 | 3.점수리스트 | 4.분석 | 5.종료");
            System.out.println("----------------------------------------------------");
            System.out.print("선택> ");

            int selectNo = scanner.nextInt();

            if (selectNo == 1) {
                System.out.print("학생수> ");
                studentNum = scanner.nextInt();
                scores = new int[studentNum];
            } else if (selectNo == 2) {
                for (int i = 0; i < scores.length; i++) {
                    System.out.print("scores[" + i + "]> ");
                    scores[i] = scanner.nextInt();
                }
            } else if (selectNo == 3) {
                for (int i = 0; i < scores.length; i++) {
                    System.out.println("scores[" + i + "]: " + scores[i]);
                }
            } else if (selectNo == 4) {
                int max = 0;
                int sum = 0;
                double avg = 0;
                for (int i = 0; i < scores.length; i++) {
                    max = (max < scores[i]) ? scores[i] : max;
                    sum += scores[i];
                }
                avg = (double) sum / studentNum;
                System.out.println("최고 점수: " + max);
                System.out.println("평균 점수: " + avg);
            } else if (selectNo == 5) {
                run = false;
            }
        }

        System.out.println("프로그램 종료");
    }
}