자바 2주차

x + y -> x 피연산자 + 연산자 y 피연산자

​

산술연산자 - +, -, *, /, %(나머지), <<, >>

비교연산자 - >, <, >=, <=, ==, !=

논리연산자 - &&, ||, !

대입연산자 - =, ++, --

기타연산자 - (type), ? :, instance of

        //기본대입연산자
        int number = 10;
        number = number + 2;
        System.out.println("기본 -> " + number);

        //복합대입연산자
        number = 10;
        number += 2;
        number *= 2;
        number /= 2;
        number %= 2;
        System.out.println("복합 -> " + number);

        //++, --
        number ++;
        number ++;
        number --;
        System.out.println("--,++ -> " + number);
        //대입연산자 주의해야할 점
        int a = 10;
        int b = 10;
        int val = ++a + b--; // ++ a앞에 있으면 a에 ++하고 객체 바로 실행 즉 11 + 10, ++a + b 한 다음 ++함

 //형변환연산자
        int intNumber = 10 + (int)10.8;
        double doubleNumber = 10 + (double)10.8;

        //삼항연산자 비교연산자
        int a = 10;
        int b = 12;

        boolean f = (a==b) ? true : false ;
        System.out.println(f);

        String s = (a==b) ?  "같음" : "같지않음" ;
        System.out.println(s);

        int max = (a > b) ? a : b;
        System.out.println(max);

        int min = ( a > b ) ? b : a;
        System.out.println(min);

        //instance of 피연산자가 조건에 명시된 클래스의 객체인지 비교하면 맞으면 true 틀리면 false

연산자 우선순위

산술>비교>논리>대입

괄호로 감싸줌으로써 연산이 최우선순위로 계산

​

산술변환

연산 전에 피연산자의 타입을 일치시키는 것

두 피연산자의 타입을 같게 일치 (둘중에 저장공간 크기가 더 큰 타입으로 일치)

피연산자의 타입이 int 보다 작은 short 타입이면 int 로 변환

피연산자의 타입이 long 보다 작은 int, short 타입이면 Long 으로 변환

피연산자의 타입이 float보다 작은 long, int, short 타입이면 float 으로 변환

피연산자의 타입이 double 보다 작은 float, long, int, short 타입이면 double 으로 변환

int a = 10;

double b = 12.5

result = a+b -> 22.5

​

비트연산

0101 << 1010 왼쪽 2의 배수로 곱셈이 연산되는것과 동일

5 -> 10

1010 >> 0101 오른쪽 2의 배수로 나눗셈이 연산되는것과 동일

10 -> 5

ex) 3 << 2 -> 11(2) -> 1100(2)

3 << 1 -> 11(2) ->110(2)

즉 12, 6 출력

​

조건문(if, swich)

가위바위보

 for(int i = 0 ; i < 5 ; i++) {
            System.out.println("a 입력 : ");
            String aHand = sc.nextLine();

            System.out.println("b 입력 : ");
            String bHand = sc.nextLine();

            if (Objects.equals(aHand, "가위")) {
                if (Objects.equals(bHand, "가위")) {
                    System.out.println("비겼습니다.");
                } else if (Objects.equals(bHand, "바위")) {
                    System.out.println("a가졌습니다");
                } else {
                    System.out.println("b가졌습니다");
                }
            } else if (Objects.equals(aHand, "바위")) {
                if (Objects.equals(bHand, "가위")) {
                    System.out.println("b가졌습니다");
                } else if (Objects.equals(bHand, "바위")) {
                    System.out.println("비겼습니다");
                } else {
                    System.out.println("a가졌습니다.");
                }
            } else if (Objects.equals(aHand, "보")) {
                if (Objects.equals(bHand, "가위")) {
                    System.out.println("a가졌습니다");
                } else if (Objects.equals(bHand, "바위")) {
                    System.out.println("b가졌습니다");
                } else {
                    System.out.println("비겼습니다.");
                }
            }else{
                System.out.println("오류");
            }
        }

Objects.equals(a,b) 좌우가 같은경우 true 다른경우 false

Objects.equals(bHand, "가위") -> bHand가 "가위"라면

  int month = 2;
        String monthString = "";

        switch (month) {
            case 1:
                monthString = "1월";
                break;
            case 2:
                monthString = "2월";
                break;
            case 3:
                monthString = "3월";
                break;
            default:
                monthString = "오류";
        }
        System.out.println(monthString);

swich, if 차이점

if 문은 복합조건을 지원

if 문은 상대적으로 코드중복이 많음.

​

반복문(for, while, do-while)

        int[] a = {3, 6, 9, 12, 15};
        for (int number : a) {
            System.out.print(number + " ");
        }

        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        } //foreach랑 동일
        -------------------------------------
        int n = 0;
        while (true){
            n++;
            System.out.println(n);
            if(n==10){
                break;
            }
        } //10까지 출력
        -------------------------------------
        int n = 0;
        while (true){
            n++;
            if(n==10){
                break;
            }
            System.out.println(n);
        } //9까지 출력
        -------------------------------------
        int a = 0;
        while(a<10){
            a++;
            System.out.println(a);
        }
        -------------------------------------
        int b = 4;
        do{
            System.out.println(b); //4출력 후 멈춤
        }while( b < 3 );
        -------------------------------------
        int n = 0;
        while(n<4){
            n++;
            if(n==3){
                continue;
            }
            System.out.println(n);
        }

continue -> n==3 만족시 print출력하지 않고 넘어감

break -> n==3만족시 종료

        Scanner sc = new Scanner(System.in);
        System.out.println("몇단까지 보시겠습니까");
        int a = sc.nextInt();
        System.out.println("몇단을 제외하시겠습니까?");
        int pass = sc.nextInt();
        for (int i = 1; i <= a; i++) {
            if(i == pass){
                continue;
            }
            for (int j = 1; j <= 9; j++) {
                System.out.println(i+ " * " + j + " = " +  + i * j);
            }
        }

배열선언방식

int[] a = new int[5] -> length(a) -> 5

int a[] = new int[5]

int[] arrays;

arrays = new int[3];

​

초기값

int[3] = 0,0,0

String[3] = "","",""

boolean[3] = false, false, false

        Scanner sc = new Scanner(System.in);
        System.out.println("몇개를 생성할까요?");
        int n = sc.nextInt();
        int[] a = new int[n];

        for (int i = 0; i < a.length; i++) {
            a[i] = sc.nextInt();
        }
        System.out.println(Arrays.toString(a)); // a에 {1,2,3,4,5} 입력시 {1,2,3,4,5} 그대로 나옴
        for(int result : a){
            System.out.println(result); // 1,2,3,4,5 출력
        }

배열초기화

        int[] intArr = {1,2,3,4,5};
        //배열초기화
        Arrays.fill(intArr,1);
        for(int result : intArr){
            System.out.println(result);
        }

얕은복사

        int[] a = { 1,2,3,4 };
        int[] b = a;
        b[0] = 3;
        System.out.println(a[0]); //3나옴

깊은복사

          int[] a = { 1,2,3,4 };
          int[] b = new int[a.length];

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

        b[0] = 3;
        System.out.println(a[0]);
        System.out.println(b[0]); 
-------------------------------------------------------------------------------------
        int[] a = { 1,2,3,4 };
        int[] b = Arrays.copyOf(a, a.length);
-------------------------------------------------------------------------------------
        int[] a = { 1,2,3,4 };
        int[] b = a.clone(); //2차원 이상 배열에서는 얕은 복사로 동작함

영향을 주지 않음

​

기본형 변수는 소문자

참조형 변수는 대문자로 시작함

ex) int n = 10; Integer a = n;

기본형 변수는 값 자체를 저장

참조형 변수는 별도의 공간에 값을 저장 후 주소를 저장(=주소형 변수)

String str = "ABCD";
        int strNum = str.length(); //4
        System.out.println(strNum);

        char chr = str.charAt(0); //A
        System.out.println(chr);

        String strSub = str.substring(0,3); //0~2까지 ABC
        System.out.println(strSub);

        String newStr = "ABCD";
        boolean strEqual = newStr.equals(str); //newstr과 str이 일치하면 true 아니면 false / true출력
        System.out.println(strEqual);

        char[] strCharAry = str.toCharArray(); //String->char[] ABCD 출력
        System.out.println(strCharAry);

        char[] charAry = {'a', 'b', 'c'};
        String charAryString = new String(charAry); //char->String->char / abc출력
        System.out.println(charAryString);

2차원 배열

int[][] a = new int[][]

int a[][] = new int[][]

int[] a[] = new int[][]

    int[][] arr = new int[2][3];   
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(i + ", "+ j);
            }
        }
        // 0,0/ 0,1/ 0,2/ 1,0/ 1,1/ 1,2 출력
------------------------------------------------------------------------------------
        int[][] arr = {
                {1,2,3},
                {4,5,6}
        };

가변배열

        //가변배열
        int[][] arr = new int[3][];
        //배열원소마다 각기 다른 크기로 지정
        arr[0] = new int[2]; // 0, 0,1
        arr[1] = new int[4]; // 1, 0,1,2,3
        arr[2] = new int[1]; // 2, 0
        -----------------------------------
        int[][] arr2 ={
                {10,20},
                {10,20,30,40},
                {10},
        };

3차원배열

        int[][][] arr = {{{1, 2}, {3, 4}, {5, 6}, {7, 8}}};

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                for (int k = 0; k < arr[i][j].length; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + arr[i][j][k] + "   ");
                }
            }
        }
    }
}
//출력값
//arr[0][0][0] = 1   arr[0][0][1] = 2   
//arr[0][1][0] = 3   arr[0][1][1] = 4   
//arr[0][2][0] = 5   arr[0][2][1] = 6   
//arr[0][3][0] = 7   arr[0][3][1] = 8

가변적으로 설정 가능

​

최대값 확인

        int[] arr = {3,2,1,5,2};
        int max = arr[0];

        for(int num : arr){
            if(num > max){
                max = num;
            }
        }
        System.out.println(max); //5출력

최소값 확인

        int[] arr = {3,2,1,5,2};
        int min = arr[0];
        for(int num : arr){
            if(num < min){
                min = num;
            }
        }
        System.out.println(min);

Java Collection

기능 - 크기 자동조정, 추가, 수정, 삭제, 반복, 순회, 필터, 포함확인 등

Collection - List, Set, Queue, Map

List - 순서가 있는 데이터 집합(데이터 중복 허용) - 배열과 비슷

-Array(정적배열), List(동적배열, 크기가 가변적으로 변함)

Queue - FIFO구조, 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺼 수 있는 집합 (원통이라고 생각)

-(Stack - LIFO구조 바구니라고 생각)

Set - 순서가 없는 데이터의 집합(데이터 중복 허용 안함) - 순서없고 중복없는 배열

Map - 순서가 없는(key, value) 쌍으로 이루어진 데이터의 집합(Key값 중복허용 안함)

Collection은 기본형 변수가아닌 참조형 변수를 저장

List사용법

.add, .set, .remove, .clear, .get

        ArrayList<Integer> intList = new ArrayList<Integer>();
        //값추가
        intList.add(99);
        intList.add(15);
        intList.add(3);
        System.out.println(intList.get(1));

        //값변경
        intList.set(1,10); // (1) 15->10으로 바꿈
        System.out.println(intList.get(1));

        //값삭제
        intList.remove(0);
        System.out.println(intList.get(0)); //(0)이 삭제되어 (1) -> (0), 10이나옴

        //전체삭제
        System.out.println(intList.toString());
        intList.clear();
        System.out.println(intList.toString());

Linkedlist

메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 저장

실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조

기본적 기능은 ArrayList와 동일

나누어서 저장하기 때문에 조회 속도가 느림

값을 추가하거나 삭제할때는 빠름

.add, .set, .remove, .clear, .get

        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        linkedList.add(5);
        linkedList.add(10);
        linkedList.add(3);
        System.out.println(linkedList.get(0));
        System.out.println(linkedList.toString());
        //값 추가
        linkedList.add(2,4); //ArrayList랑은 다른점, 2번쨰 4를 추가(2번째 값은 3번째로 이동)
        System.out.println(linkedList.toString());
        //값 변경
        linkedList.set(0,30);
        System.out.println(linkedList.toString());
        //값 삭제
        linkedList.remove(0);
        System.out.println(linkedList.toString());
        //전체삭제
        linkedList.clear();
        System.out.println(linkedList.toString());

Queue

add, peek, poll

생성자가 없는 인터페이스

        //Queue : FIFO
        Queue<Integer> intQueue = new LinkedList<Integer>(); //생성자가 없기 때문 linkedList
        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);
        while (!intQueue.isEmpty()){
            System.out.println(intQueue.poll()); //pop -> LIFO, poll -> FIFO 1,5,9출력 intQueue에서 사라짐
        }
        System.out.println(intQueue.toString()); //값 X

        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);
        intQueue.add(10);
        System.out.println(intQueue.peek()); //조회 1나옴
        System.out.println(intQueue.size());//size조회 4출력

Stack

push, peek, pop

최근 저장된 데이터를 나열할때, 데이터 중복처리를 막고 싶을때

        //Stack : LIFO
        Stack<Integer> intStack = new Stack<Integer>();
        intStack.push(10); //추가 add랑 비슷
        intStack.push(15);
        intStack.push(1);
        while (!intStack.isEmpty()){ //isEmpty -> 값이 없으면 true 있으면 false, !intStack.pop ->값이 있지만 부정을 써서 true로 만듬
            System.out.println(intStack.pop()); //pop -> 상단값(마지막)부터 출력되면서 intStack에서 사라짐 1, 15, 10 순서
        }

        intStack.push(10);
        intStack.push(15);
        intStack.push(1);
        System.out.println(intStack.peek()); //마지막 값 출력 -> 1 값이 안사라짐
        System.out.println(intStack.size()); //3출력

 

Set

순서 없고, 중복 없음

순사거 보장되지 않는 대신 중복을 허용하지 않도록 프로그램에서 사용할 수 있는 자료구조

Set -> 그냥쓸 수 있으나 HashSet, TreeSet 등으로 응용해서 같이 사용 가능

Set은 생성자가 없기 때문에 바로 생성 X

HashSet -> 생성자가 존재

        Set<Integer> intSet = new HashSet<Integer>();
        intSet.add(1);
        intSet.add(12);
        intSet.add(5);
        intSet.add(9);
        intSet.add(1);
        intSet.add(12);
        for(Integer value : intSet){
            System.out.println(value); //1,5,9,12 값 출력 중복값은 허용하지않음.
        }
        System.out.println(intSet.toString()); //값 X

        System.out.println(intSet.contains(2)); //2를 포함하고 있는지 true, false 값 출력, false 출력
        System.out.println(intSet.contains(5)); //true 출력

Map

key -> Value pair

key값 unique해야함

Map -> HashSet, TreeSet 등으로 응용해서 같이 사용 가능

        //key, value
        Map<String, Integer> intMap = new HashMap<>();

        intMap.put("일",11); //put -> 생성
        intMap.put("이",12);
        intMap.put("삼",13); //key중복
        intMap.put("삼",14); //key중복
        intMap.put("삼",15); //key중복
        for(String key : intMap.keySet()){ //keyset -> key값만 가져옴
            System.out.println(key); //이 일 삼 출력
        }
        for(Integer value : intMap.values()){ // values -> value값 가져옴
            System.out.println(value); //12 11 15 출력 -> 중복값은 마지막값으로 나옴
        }
        System.out.println(intMap.get("삼"));//15출력

생성자가 없음

Queue(<->Stack) -> LinkedList 사용

Set -> HashSet 사용

Map -> HashMap 사용

​

1. length

• arrays(int[], double[], String[])
• length는 배열의 길이를 조회해줍니다.

2. length()

• String related Object(String, StringBuilder etc)
• length()는 문자열의 길이를 조회해줍니다. (ex. “ABCD”.length() == 4)

3. size()

• Collection Object(ArrayList, Set etc)
• size()는 컬렉션 타입목록의 길이를 조회해줍니다.

​

과제 (1주차 리팩토링)

next() -> 띄어쓰기 X, ex) 안녕 하세요 -> 안녕 출력

nextLine() -> 띄어쓰기 O

package Collection;

import java.io.BufferedReader;
import java.util.*;

public class 과제 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("List, HashSet, Set, Map 중 입력하세요");
        String CollectionName = sc.next();
        System.out.println("title제목 입력하세요");
        String title = sc.nextLine();

        switch (CollectionName) {
            case "List": {
                ArrayList<String> strList = new ArrayList<String>();
                while (true) {
                    String text = sc.nextLine();
                    if (Objects.equals(text, "끝")) {
                        break;
                    }
                    strList.add(text);
                }
                String strTitle = "[ List로 저장된 " + title + " ]";
                System.out.println(strTitle);
                for (int i = 1; i <= strList.size(); i++) {
                    System.out.println(i + ". " + strList.get(i));
                }
                break;
            }

            case "HashSet" : {
                HashSet<String> strHashSet = new HashSet<String>();
                while (true){
                    String text = sc.nextLine();
                    if(Objects.equals(text,"끝")){
                        break;
                    }
                    strHashSet.add(text);
                }
                title = "[ HashSet으로 저장된 " + title + " ]";
                System.out.println(title);

                Iterator iterator = strHashSet.iterator(); //Iterator에 저장하여 꺼냄

                for (int i = 0; i < strHashSet.size(); i++) {
                    int number = i + 1;
                    System.out.println(number + ". " + iterator.next());
                }
                break;
            }

            case "Set" : {
                Set<String> strSet = new HashSet<String>();
                while(true){
                    String text = sc.nextLine();
                    if(Objects.equals(text,"끝")){
                        break;
                    }
                    strSet.add(text);
                }
                String strTitle = "[ Set로 저장된 " + title + " ]";
                System.out.println(strTitle);
                int n = 1;
                for(String str : strSet){
                    System.out.println(n++ + ". " + str);
                    }
                break;
            }

            case "Map" : {
                Map<Integer, String> strMap = new HashMap<>();
                int lineNumber=1;
                while(true){
                    String text = sc.nextLine();
                    if(Objects.equals(text,"끝")){
                        break;
                    }
                    strMap.put(lineNumber++,text);
                }
                title = "[ Map으로 저장된 " + title + " ]";
                System.out.println(title);
                for (int i = 1; i <= strMap.size(); i++) {
                    System.out.println(i + ". " + strMap.get(i));
                }
                break;
            }
            default:{
                System.out.println("오류발생");
            }
        }
    }
}
​