힘내보자

로또번호 총 1-45번을 저장하기 위해 배열 변수 45 길이로 선언 및 할당

1-45까지 다 적어서 넣을 필ㅇ없이 for문으로 1-45까지 배열에 값을 넣어주고 

로또번호 6자리만 선택될 수 있게 for문 6번 반복하도록 0에서 5까지 범위 설정

a=b

b=c

c=a 의 변하는 값을 바꿀 수 있는 알고리즘을 사용하여 

생성한 난수를 저장할 수 있는 임시 변수(randomNum)을 선언하고 거기에 값을 넣어주고

이후 기존의 배열 변수인 lNum[i]를 tempNum에 넣어줘서 지워지기 전에 다른 변수에 임시로 저장해준다

그리고 lNum[i]에 lNum[randomNum]을 넣어주고 다시 임시로 lNum[i]을 저장했던 tempNum을 다시 Num[randomNum]에 넣어주면 완성

// 로또번호 6개 만들기
// 45개의 정수값을 저장하기 위한 배열 생성.
// 배열의 각 요소에 1~45의 값을 저장한다.
int[] lNum = new int[45];

for(int i=0; i < lNum.length; i++){
    lNum[i] = i+1;
}
System.out.print(Arrays.toString(lNum)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45]


// 값 저장 임시변수 생성
int tempNum = 0;
int randomNum = 0;

for(int i=0; i<=5;i++) {
    randomNum = (int) (Math.random() * 45);
    tempNum = lNum[i];
    lNum[i] = lNum[randomNum];
    lNum[randomNum] = tempNum;
}
System.out.println();
System.out.println(Arrays.toString(lNum));

최대최소값

최소값, 최대값 각각 배열의 0번째 인덱스로 값을 선언 및 초기화 시켜두고

for문을 이용하여 전체를 돌려 각각 값을 비교하여 최대값과 최대값을 도출한다

가위바위보

스트링 배열 값에 가위,바위,보를 넣어놓고

난수 생성한 값을 임시 값 저장소인 ranNum변수에 넣어두고 이를 가위바위보를 저장한 배열 변수인 RPS의 인덱스 번호로 사용하여 랜덤하게 가위 바위 보를 도출시킨다

        // 최대값, 최소값 구하기
        int[] arr00 = {1,23,5,7,68,34,5};
        int maxNum = arr00[0];
        int minNum = arr00[0];

        for(int i=0; i < arr00.length; i++){
            if(maxNum < arr00[i]){
                maxNum = arr00[i];
            }else if(minNum > arr00[i]){
                minNum = arr00[i];
            }
        }
        System.out.println(maxNum);
        System.out.println(minNum);




        // 가위바위보 하기
        String[] rps = { "rock", "paper", "scissors"};
        int ranNum = 0;
        for(int i=1; i <= 3;i++){
            ranNum = (int)(Math.random()*3);
            System.out.printf("%s"+" ",rps[ranNum]);
        }
        System.out.println();
        System.out.println(ranNum);

BufferedReader, StringTokenizer 문자열만 받으며, 스캐너보다 빠름

split() 메서드는 정규 표현식을 사용해 구분하고, StringTokenizer는 문자를 사용해 구분한다는 점에서도 차이

StringTokenizer

문자열이 특정 구분자(delimiter)로 연결되어 있는 경우, 구분자를 기준으로 부분 문자열을 분리하기 위해 이용하는 클래스

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine()," ");

int[] arr1 = {1,1,2,2,2,8};
String answer = "";
int user = 0;

for(int i=0; i < 6; i++){
    user = Integer.parseInt(st.nextToken()); // NoSuchElementException 발생 : 참조 https://help.acmicpc.net/judge/rte/NoSuchElement
    answer += arr1[i] - user+ " ";
}

System.out.println(answer);

set은 list랑 다르게 인덱스가 없어서 인덱스 관련 메소드들이 없다

indexOf(), get(), set() 등등

인덱스가 없어서 순서도 없다. 순서 있는 LinkedHashSet도 인덱스가 없기 때문에 사용 불가

map도 마찬가지로 인덱스가 없어서 set처럼 사용불가

인덱스가 없기 때문에 for문도 사용 불가능하고 

이는 for문과 인덱스를 통해 해당 엘리먼트에 접근 가능하던게 불가능하다는 뜻인데

이를 보완하기 위해 Iterator를 사용한다

Iterator + hasNext() + while문으로 컬렉션 내부 엘리먼트에 접근 가능

public void method04(){


        // 공용 메소드들
        // add(E e):boolean
        // contains(Object o) : boolean
        // iterator() : Iterator<E>
        // remove(Object o) : boolean
        // size() : int
        // equals(Object o) : boolean
        // isEmpty() : boolean
        // clear() : void

        // HashSet
        HashSet<Dog> hSet = new HashSet<Dog>();
        hSet.add(new Dog("풍이",10));
        hSet.add(new Dog("해피",10));
        System.out.println(hSet);   // [풍이(10.0kg), 해피(10.0kg)]


        // 순서x 중복x HashSet, add하면 어디에 추가될까?
        // 위치는 랜덤
        hSet.add(new Dog("뚱이",10));
        System.out.println(hSet); // 마지막 추가 : [풍이(10.0kg), 해피(10.0kg), 뚱이(10.0kg)] 
        hSet.add(new Dog("호야",10));
        System.out.println(hSet); // 중간 추가 : [풍이(10.0kg), 해피(10.0kg), 호야(10.0kg), 뚱이(10.0kg)]

        // set 중복 저장안되는데 중복 저장 되는 이유 : equals() 오버라이딩 안되어있어서
        hSet.add(new Dog("뚱이",10));
        System.out.println(hSet);              // [풍이(10.0kg), 해피(10.0kg), 호야(10.0kg), 뚱이(10.0kg)]
        // equals() 오버라이딩 주석처리하면 중복 가능 : [풍이(10.0kg), 해피(10.0kg), 호야(10.0kg), 뚱이(10.0kg), 뚱이(10.0kg)]

        // LinkedHashSet
        // 순서가 유지o 중복저장x 안되는 컬렉션
        LinkedHashSet<Dog> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.addAll(hSet);
        System.out.println("linkedHashSet : " +linkedHashSet); // [풍이(10.0kg), 해피(10.0kg), 호야(10.0kg), 뚱이(10.0kg)]

        // LinkedHashSet 순서가 있으니까 add로 추가하면 어디서부터 추가될까?
        // 뒤부터 추가
        linkedHashSet.add(new Dog("도리",10));
        linkedHashSet.add(new Dog("아리",10));
        System.out.println(linkedHashSet); // [풍이(10.0kg), 해피(10.0kg), 호야(10.0kg), 뚱이(10.0kg), 도리(10.0kg), 아리(10.0kg)]

        // contains()
        // 값 비교 메소드 필요
        System.out.println(linkedHashSet.contains(new Dog("풍이",10))); // true
        // 오버라이딩 메소드 주석처리하면 false

        // size() : int
        linkedHashSet.size();
        System.out.println(linkedHashSet.size()); // 6

        // remove(Object o) : boolean
        // removeAll(Collection<?> c ) : boolean
        // Collection<?> c는 해당 컬렉션 변수 통째로 넣는 걸 의미 : ex)HashSet의 변수명 hSet
        linkedHashSet.remove(new Dog("아리",10));
        System.out.println(linkedHashSet);
        linkedHashSet.removeAll(linkedHashSet); // [풍이(10.0kg), 해피(10.0kg), 호야(10.0kg), 뚱이(10.0kg), 도리(10.0kg)]
        System.out.println(linkedHashSet); // []

        // isEmpty() : boolean
        linkedHashSet.isEmpty();
        System.out.println(linkedHashSet.isEmpty()); // true

        // equals(Object o) : boolean
        System.out.println(hSet); // [풍이(10.0kg), 해피(10.0kg), 호야(10.0kg), 뚱이(10.0kg)]
        hSet.equals(new Dog("풍이",10));
        System.out.println(hSet.equals(new Dog("풍이",10))); // false


        // clear() : void
        hSet.clear();
        System.out.println(hSet); // []

        // 공용 메소드들
        // add(E e):boolean
        // contains(Object o) : boolean
        // iterator() : Iterator<E>
        // remove(Object o) : boolean
        // size() : int
        // equals(Object o) : boolean
        // isEmpty() : boolean
        // clear() : void


        // TreeSet
        // 정렬을 해주는 Set
        TreeSet<Dog> treeSet = new TreeSet<>();

        System.out.println(treeSet); // []
        treeSet.add(new Dog("멍뭉이",10));
        System.out.println(treeSet); // [멍뭉이(10.0kg)]
        treeSet.clone();
        System.out.println(treeSet); // [멍뭉이(10.0kg)]

        // remove(int index):E
        // remove()의 return은 삭제한 값을 돌려준다
        // set은 인덱스가 없으므로 위의 인덱스 번호로 지우는 것은 불가능. 따로 해당 메소드는 set과 map에는 없음
//        System.out.println(treeSet.remove(1)); Exception in thread "main" java.lang.ClassCastException


        // remove(Object o):boolean
        // 같은 데이터라면 앞에 있는거부터 삭제
        // equals()가 오버라이딩이 안되어 있어서 값 비교가 아니라 주소값 비교라 삭제 못한 것.
        System.out.println(treeSet.remove(new Dog("멍뭉이",10))); //  true
        System.out.println(treeSet); // []

        treeSet.add(new Dog("멍뭉이",15));
        System.out.println(treeSet);


        // Iterator<E>	iterator()
        Iterator<Dog> it = treeSet.iterator();
        System.out.println(it); // java.util.TreeMap$KeyIterator@1b6d3586

        System.out.println(it.equals(new Dog("멍뭉이",15))); // false
        // 왜 false일까...?
        while(it.hasNext()){
            Dog d = it.next();
            System.out.println("iterator : "+it); // iterator : java.util.TreeMap$KeyIterator@1b6d3586
//            System.out.println(it.next());  // Exception in thread "main" java.util.NoSuchElementException
            System.out.println("Dog d : "+d); // Dog d : 멍뭉이(15.0kg)
        }
        

//        인텔리제이가 자동생성 해준 이터레이터 코드
//        Iterator<Dog> iterator = new Iterator<Dog>() {
//            @Override
//            public boolean hasNext() {
//                return false;
//            }
//
//            @Override
//            public Dog next() {
//                return null;
//            }
//        };


        // hSet.set();
        // linkedHashSet.set();
        // treeSet.set();
        // 위의 셋 다 set(),get()가 없음 -> 인덱스 번호로 replace해주기 때문
        //      set(int index, E e) : 바꾸기 전 값 반환
        //      해당 인덱스 번호에 값  교체
        //      get(int index):E
        //      인덱스번호의 엘리먼트 값을 가져온다

        // contains(Object) : boolean
        System.out.println(treeSet.contains(new Dog("멍뭉이",15))); // true

        // clear():void
        treeSet.clear();
        System.out.println(treeSet); // []

        // isEmpty():boolean
        System.out.println(treeSet.isEmpty()); // true


    }

단축키 습득

Ctrl + Shift + 방향키 : 코드 라인 이동동
Ctrl + Q : 도큐먼트를 조회
Ctrl + P : 메서드의 파라미터 정보를 조회

Ctrl + 해당 코드 클릭 : 관련 내용 보기
 - interface, method 등등

저번에 이클립스에서 쓰던 코드 끌어와서 이클립스에서 듀얼창으로 볼려고 하다가 여러가지 에러났던 부분

혹시나해서 패키지명(경로)를 빼고 클래스명부터 코드내용만 불러왔는데 잘 작동하고 있다

아마도 경로부터 해서 컴파일 하는 부분까지 이어져 문제가 생겼던 것 같다

역시 여러번 보다보면 시야가 넓혀지고 생각 못했던 문제들을 다시 보게되면서 풀리거나 이해되거나 하는게 맞는 것 같고

 신기하기도 하고 하나씩 풀리는게 재미있다!

(참고로, 프로젝트파일 생성할 때 java + maven으로 했다)

(maven이 target 폴더에서 이것저것 작동하는 듯하다. spring 처음 쓸 때는 몰랐는데 maven꺼였음)

어제 최대최소값 구하기 중에 if문 쪽이 잘 이해가 안갔는데

로직은 배열 안에 첫번째 값을 넣고 for문으로 전체 값을 읽는데 

값을 하나씩 비교해서 더 큰 값이 있으면 max변수에 넣고 아니면 다음꺼 비교하고 하는 식으로 최대값, 최소값을 찾는 식이다

여기 저기 많이 사용할 것 같으니 몇번 더 쓰면서 머리에 완전히 익혀야겠다

로또 번호구하기

a=b
b=c
c=a
파이썬 할 때 배웠던 그 알고리즘 방식 적용한 것

이렇게 하면서 숫자 바꿔치기 가능

        // 최대값, 최소값 구하기
        int[] score2 = {79, 88, 91, 33, 100, 55,95};

        int max2 = score2[0];
        int min2 = score2[0];


        for(int i = 0; i < score2.length; i++){
            if(score2[i] > max2){
                max2 = score2[i];
            }else if(score[i] < min2){
                min2 = score2[i];
            }
        }
        System.out.println(max2);
        System.out.println(min2);

        int[] score3 = {79, 88, 91, 33, 100, 55,95};
        int max3 = score3[0];
        int min3 = score3[0];

        for(int i = 0; i < score3.length; i++){
            if(score3[i]  > max3){
                max3 = score3[i];
            }else if(score3[i] < min3){
                min3 = score3[i];
            }
        }
        System.out.println(max3);
        System.out.println(min3);




        // 로또번호 6개 만들기
        // 45개의 정수값을 저장하기 위한 배열 생성.
        int[] lotto = new int[45];

        // 배열의 각 요소에 1~45의 값을 저장한다.
        for(int i = 0; i < lotto.length; i++){
            lotto[i] = i+1;
        }
        System.out.println(Arrays.toString(lotto)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45]

        // 값 저장 임시변수 생성
        int temp2 = 0;
        int j2 = 0;

        // 배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다.
        // 0번째 부터 5번째 요소까지 모두 6개만 바꾼다.
        for(int i=0; i < 6; i++){
            j2 = (int)(Math.random()*45);
            temp2 = lotto[i];
            lotto[i] = lotto[j2];
            lotto[j2] = temp2;
            System.out.println(lotto); // [I@610455d6
            // 주소값이  갑자기 왜 나왔을까?
            // 객체 주소로 저장되는 배열 그냥 찍으니까 주소값 나옴ㅋㅋ Arrays.toString으로 찍으면 제대로 나올 듯
            System.out.println(Arrays.toString(lotto)); // [10, 23, 1, 34, 40, 16, 7, 8, 9, 3, 11, 12, 13, 14, 15, 6, 17, 18, 19, 20, 21, 22, 2, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 4, 35, 36, 37, 38, 39, 5, 41, 42, 43, 44, 45]
            // Arrays.toString으로 찍으니 제대로 값 잘 나옴. 이제 앞에서 6자리만 뽑아서 보여주면 된다
        }

        // 배열 ball의 앞에서 부터 6개의 요소를 출력한다.
        for(int i=0; i < 6; i++){
            System.out.print(lotto[i] + " ");   // 33 19 13 36 8 21
        }
        System.out.println();
        for(int i=0; i < 6; i++){
            System.out.printf("lotto[%d]=%d%n", i, lotto[i]);
//            lotto[0]=33
//            lotto[1]=19
//            lotto[2]=13
//            lotto[3]=36
//            lotto[4]=8
//            lotto[5]=21
        }

반복해서 머리 속에 넣어두기!

내부 작동 로직 익숙해지기

팔, 다리 사용하듯 자연스럽게

package com.prac.array;

import java.util.Arrays;

public class arrayControllerPrac {

    public static void main(String[] args) {

        // 최대값, 최소값 구하기
        int[] score = {79, 88, 91, 33, 100, 55,95};

        int max = score[0];
        int min = score[0];

        for(int i=0; i < score.length; i++){
            if(score[i] > max){
                max = score[i];
            }else if(score[i] < min){
                min = score[i];
            }
        }
        System.out.println("최대값"+max);
        System.out.println("최대값"+min);




        // 로또번호 6개 만들기
        // 45개의 정수값을 저장하기 위한 배열 생성.
        // 배열의 각 요소에 1~45의 값을 저장한다.
        int[] lNumber = new int[45];

        // 값 저장 임시변수 생성
        int temp = 0;
        int j = 0;

        for(int i=0; i < lNumber.length; i++)
            lNumber[i] = i+1;
        System.out.println(Arrays.toString(lNumber));


        // 배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다.
        // 0번째 부터 5번째 요소까지 모두 6개만 바꾼다.
        for(int i=0; i < 6; i++){
            j = (int)(Math.random()*45);
            temp = lNumber[i];
            lNumber[i] = lNumber[j];
            lNumber[j] = temp;
            System.out.println(Arrays.toString(lNumber));
        }

        // 배열 ball의 앞에서 부터 6개의 요소를 출력한다.
        for(int i=0; i < 6; i++)
            System.out.printf("lotto_Number[%d]=%d%n",i,lNumber[i]);



    }

}

배열 안에 배열값을 넣어서 배열 하나를 지정하고 그 안에 다시 배열값을 꺼내는 방식으로

[][] 이어서 꺼내온다

이중 for문을 이용하여 각 과목의 합계를 누적 합산하여 총점을구하고

해당 총점을 통해 length로 총점을 나눌 수를 구하여 avg를 계산

// 학생별 평균,총점
        int[][] score01 = {
                         {100,100,100}
                        ,{20,20,20}
                        ,{30,30,30}
                        ,{40,40,40}
                        ,{50,50,50}
                        };

        // 과목별 총점
        int korTotal = 0, engTotal = 0, mathTotal = 0;
        System.out.println("번호 국어 영어 수학 총점 평균");
        System.out.println("=============================");

        for(int i=0; i < score01.length;i++){
            int sum = 0;        // 각 개인 총점
            float avg = 0.0f;   // 각 개인 평균

            korTotal += score01[i][0];
            engTotal += score01[i][1];
            mathTotal += score01[i][2];
            System.out.printf("%3d", i+1); // 3d는 왼쪽으로 세칸 공간차지 // 번호 1~5 출력

            for(int jj=0;jj < score01[i].length;jj++) {
                sum += score01[i][jj];
                System.out.printf("%5d", score01[i][jj]);
            }

            avg = sum/(float)score01[i].length;  // 평균계산
            System.out.printf("%5d %5.1f%n", sum, avg);

        System.out.println("=============================");
        System.out.printf("총점:%3d %4d %4d%n", korTotal, engTotal, mathTotal);
/*  
    출력 결과

            번호 국어 영어 수학 총점 평균
            =============================================
            1  100  100  100  300 100.0
            =============================
            총점:100  100  100
            2   20   20   20   60  20.0
            =============================
            총점:120  120  120
            3   30   30   30   90  30.0
            =============================
            총점:150  150  150
            4   40   40   40  120  40.0
            =============================
            총점:190  190  190
            5   50   50   50  150  50.0
            =============================
            총점:240  240  240

*/
            
        }

ball 변수에 배열 선언 및 길이까지 할당

a = b

b = c

c = a

로직을 이용하여 Math.random()으로 생성한 난수를 j에 넣고 

temp에 ball[i]를 넣어서 임시 보관시키고, 

난수 생성한 j를 ball인덱스 번호에 넣은 ball[j]를 ball[i] 다시 넣고

ball[j]에는 tmp에 넣어두었던 ball[i]를 다시 넣으므로써 스위칭이 가능해진다

 // 로또번호 6개 만들기
        // 45개의 정수값을 저장하기 위한 배열 생성.
        int[] ball = new int[45];

        // 배열의 각 요소에 1~45의 값을 저장한다.
        for(int i=0; i < ball.length; i++)
            ball[i] = i+1;
        System.out.println(Arrays.toString(ball));

        int temp = 0; // 두 값을 바꾸는데 사용할 임시변수
        int j = 0;    // 임의의 값을 얻어서 저장할 변수

        // 배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다.
        // 0번째 부터 5번째 요소까지 모두 6개만 바꾼다.
        for(int i=0; i < 6; i++){
            j = (int)(Math.random()*45); // 0~44범위의 임의의 값을 얻는다.
            temp = ball[i];
            ball[i] = ball[j];
            ball[j] = temp;
            System.out.println(Arrays.toString(ball));
        }

        // 배열 ball의 앞에서 부터 6개의 요소를 출력한다.
        for(int i=0; i < 6; i++)
            System.out.printf("ball[%d]=%d%n", i, ball[i]);