프로그래밍 기초

오늘 한 것

알고리즘 문제 (SQL, 자바) 1문제 풀이 & 블로그 정리
Java 문법 종합반_2주차 듣기
개인 과제 발제

배운 내용 정리

연산자

연산자 : 덧셈, 뺄셈처럼 계산할 기호
피연산자 : 연산자로 인해 계산되는 숫자

package operator;

public class W01 {

    public static void main(String[] args) {
        // x + y = z
        int x = 5;
        int y = 10;

        int z = x + y;  // 5(피연산자) +(연산자) 10(피연산자)

        System.out.println(z);
    }
}

연산자 종류

산술 연산자

사칙 연산 및 비트연산을 포함한다.
+(덧셈), -(뺄셈), *(곱셈), /(나눗셈(몫)), %(나눗셈(나머지))

package operator;

public class W02 {
    public static void main(String[] args) {
        // 사칙연산 : +, -, *, /, %
        System.out.println(4 + 2);  // 6
        System.out.println(4 - 2);  // 2
        System.out.println(4 * 2);  // 8
        System.out.println(4 / 2);  // 2
        System.out.println(5 / 2);  // 2
        System.out.println(2 / 4);  // 0
        System.out.println(4 % 2);  // 0
        System.out.println(5 % 2);  // 1

        System.out.println("-----------------");

        // 우선순위 연산
        System.out.println(2 + 2 * 2);  // 6
        System.out.println((2 + 2) * 2);  // 8
        System.out.println(2 + (2 * 2));  // 6

        System.out.println("-----------------");

        // 변수를 이용한 연산
        int a = 20;
        int b = 10;
        int c;

        // 덧셈
        c = a + b;
        System.out.println(c);  // 30
        // 뺄셈
        c = a - b;
        System.out.println(c);  // 10
        // 곱셈
        c = a * b;
        System.out.println(c);  // 200
        // 나눗셈(몫)
        c = a / b;
        System.out.println(c);  // 2
        // 나눗셈(나머지)
        c = a % b;
        System.out.println(c);  // 0
    }
}

비교 연산자

값의 크고/작음을 비교하거나 같고/다름을 비교하여 참(true)/거짓(false) 값인 boolean 값을 출력한다.
>(크다), <(작다), >=(크거나 같다), <=(작거나 같다), ==(같다), !=(다르다)

package operator;

public class W03 {
    public static void main(String[] args) {
        // 비교연산자 예제
        System.out.println(10 > 9);  // 10이 9보다 크니? : 응! (true)
        System.out.println(10 >= 9);  // 10이 9보다 크거나 같니? : 응! (true)
        System.out.println(10 < 9);  // 10이 9보다 작니? : 아니! (false)
        System.out.println(10 <= 9);  // 10이 9보다 작거나 같니? : 아니! (false)
        System.out.println(10 == 10);  // 10은 10이랑 같니? : 응! (true)
        System.out.println(10 == 9);  // 10은 9랑 같니? : 아니! (false)
        System.out.println(10 != 10);  // 10은 10이 아니니? : 아니! (false)
        System.out.println(10 != 9);  // 10은 9가 아니니? (true)
    }
}

논리 연산자

비교 연산의 결과값을 받을 수 있는 boolean 값을 연결하는 연산자이다.
조건을 연결했을 때 boolean 값들을 조합하여 참(true)/거짓(false) 값인 boolean 값을 출력한다.
&&(AND), ||(OR), !(NOT)

package operator;

public class W04 {
    public static void main(String[] args) {
        // 논리 연산자
        // 비교 연산의 결과값으로 받을 수 있는 boolean 값을 연결하는 연산자
        // 조건을 연결했을 때 boolean 값들을 조합하여 참(true) 또는 거짓(false) 값인 boolean 값을 출력
        // &&(AND), ||(OR), !(NOT)

        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = false;

        System.out.println(flag1);
        System.out.println(flag2);
        System.out.println(flag3);

        System.out.println("---------------");

        // (1) 피연산자 중 하나라도 true이면 true -> 또는(OR : ||)
        System.out.println(flag1 || flag2);  // true
        System.out.println(flag1 || flag2 || flag3);  // true

        System.out.println("---------------");

        // (2) 피연산자가 모두 true이면 true -> 그리고(AND : &&)
        System.out.println(flag1 && flag2);  // true
        System.out.println(flag1 && flag2 && flag3);  // false

        System.out.println("---------------");

        // (3) AND
        System.out.println((5 > 3) && (3 > 1));  // true && true -> true
        System.out.println((5 > 3) && (3 < 1));  // true && false -> false

        System.out.println("---------------");

        // (4) OR
        System.out.println((5 > 3) || (3 > 1));  // true || true -> true
        System.out.println((5 > 3) || (3 < 1));  // true || false -> true
        System.out.println((5 < 3) || (3 < 1));  // false || false -> true

        System.out.println("---------------");

        //System.out.println(1 < 3 < 5);  // 불가능!

        // 논리 부정 연산자(! : NOT)
        System.out.println(!flag1);  // false
        System.out.println(!flag3);  // true
        System.out.println(!(5 == 5));  // false
        System.out.println(!(5 == 3));  // true
    }
}

대입 연산자

변수를 바로 연산해서 그 자리에서 저장하는 연산자
기본 대입 연산자(=), 복합 대입 연산자(+=, -=, *=, /=, %=)

package operator;

public class W05 {
    public static void main(String[] args) {
        // 대입연산자
        // 변수를 바로 연산해서 그 자리에서 저장하는(대입하는) 연산자
        // =(기본 대입연산자), +=, -=, *=, ...(복합 대입연산자)
        // ++ : += 1
        // -- : -= 1

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

        number = number - 2;
        System.out.println(number);

        number = number * 2;
        System.out.println(number);

        number = number / 2;
        System.out.println(number);

        number = number % 2;
        System.out.println(number);

        System.out.println("--------------");

        // 복합 대입연산자
        number = 10;

        number += 2;  // number = number + 2;
        System.out.println(number);  // 12

        number -= 2;  // number = number - 2;
        System.out.println(number);  // 10

        number *= 2;  // number = number * 2;
        System.out.println(number);  // 20

        number /= 2;  // number = number / 2;
        System.out.println(number);  // 10

        number %= 2;  // number = number % 2;
        System.out.println(number);  // 0

        System.out.println("--------------");

        // ++, --
        number++;  // number = number + 1; number += 1;
        System.out.println(number);  // 0

        number--;  // number = number - 1; number -= 1;
        System.out.println(number);  // 0
    }
}

package operator;

public class W06 {
    public static void main(String[] args) {
        // 대입연산자에서 주의해야 할 점!!
        // ++, --
        int a = 10;
        int b = 10;
        int val = ++a + b--;  // 11 + 10 = 21
        System.out.println(a);  // 11
        System.out.println(b);  // 9
        System.out.println(val);  // 21
    }
}

기타 연산자

형변환 연산자, 삼항 연산자, instance of 연산자

package operator;

public class W07 {
    public static void main(String[] args) {
        // 기타 연산자
        // (1) 형변환 연산자
        int intNumber = 93 + (int) 98.8;
        System.out.println(intNumber);

        double doubleNumber = (double) 93 + 98.8;  // 93.0 + 98.8
        System.out.println(doubleNumber);

        // (2) 삼항 연산자
        // 비교연산자와 항상 함께 쓰인다.
        // 비교연산자의 결과 : true or false -> 이 결과의 값에 따라 결정되는 무언가!
        // 조건 ? 참 : 거짓
        int x = 1;
        int y = 9;

        boolean b = (x == y) ? true : false;
        System.out.println(b);

        // x가 y랑 다르니? : 응!!!
        String s = (x != y) ? "정답" : "오답";
        System.out.println(s);

        int max = (x > y) ? x : y;
        System.out.println(max);

        int min = (x > y) ? y : x;
        System.out.println(min);

        // (3) instance of (3주차 -> 클래스, 객체)
        // 피연산자가 조건에 명시된 클래스의 객체인지 비교하여
        // 맞으면 -> true
        // 틀리면 -> false
    }
}

연산자 우선순위

산술 > 비교 > 논리 > 대입

package operator;

public class W08 {
    public static void main(String[] args) {
        // 연산자 우선순위
        int x = 2;
        int y = 9;
        int z = 10;

        boolean result = x < y && y < z; // true &7 true,  <,> 비교연산자 계산 후 && 논리 연산자 계산
        System.out.println(result); // true

        result = x + 10 < y && y < z; // false && true, +10 산술연산자 계산 후 <,> 비교연산자 계산 후 && 논리 연산자 계산
        System.out.println(result); // false

        result = x + 2 * 3 > y; // false, 산술연산자 곱셈 > 덧셈 순으로 계산 후 > 비교연산자 계산
        System.out.println(result); // false (8>9)

        result = (x + 2) * 3 > y; // true, 괄호 안 덧셈 연산 후 괄호 밖 곱셈 계산 후 > 비교연산자 계산
        System.out.println(result); // true (12>9)
    }
}

산술 변환

package operator;

public class W09 {
    public static void main(String[] args) {
        short x = 10;
        int y = 20;

        int z = x + y; // 결과값은 더 큰 표현타입인 int 타입의 변수로만 저장할 수 있습니다.

        long lx = 30L;
        long lz = z + lx; // 결과값은 더 큰 표현타입인 long 타입의 변수로만 저장할 수 있습니다.

        float fx = x; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
        float fy = y; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
        float fz = z; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.

        System.out.println(lz);
        System.out.println(fx);
        System.out.println(fy);
        System.out.println(fz);
    }
}

비트 연산

package operator;

public class W10 {
    public static void main(String[] args) {
        // 비트 연산

        // 참고, 3의 이진수값은 11(2) 입니다. 12의 이진수값은 1100(2) 입니다.
        // (2) 표기는 이 숫자가 이진수값이라는 표식 입니다.

        System.out.println(3 << 2);
        // 3의 이진수값인 11(2) 에서 왼쪽으로 2번 옮겨져서 1100(2) 인 12값이 됩니다.

        System.out.println(3 >> 1);
        // 3의 이진수값인 11(2) 에서 오른쪽으로 1번 옮겨져서 1(2) 인 1 값이 됩니다.
    }
}

조건문, 반복문

if문

특정 조건에 따라 다른 연산을 수행하고 싶을 때 사용하는 문맥이다.

package operator;

public class W11 {
    public static void main(String[] args) {
        // 조건문 with else
        boolean flag = false;

        if (flag) {
            System.out.println("flag 값은 true 입니다."); // 미출력
        } else {
            System.out.println("flag 값은 false 입니다."); // flag 값은 false 입니다. 출력
        }

        // 조건문 with else if
        int number = 2;

        if (number == 1) {
            System.out.println("number 값은 1 입니다."); // 미출력
        } else if (number == 2) {
            System.out.println("number 값은 2 입니다."); // number 값은 2 입니다. 출력
        } else {
            System.out.println("number 값은 모르는 값입니다."); // 미출력
        }
    }
}

중첩 if문

package operator;

public class W12 {
    public static void main(String[] args) {
        // 중첩 조건문
        boolean flag = true;
        int number = 2;

        if (flag) {
            if (number == 1) {
                System.out.println("flag 값은 true, number 값은 1 입니다."); // 미출력
            } else if (number == 2) {
                System.out.println("flag 값은 true, number 값은 2 입니다."); // flag 값은 true, number 값은 2 입니다. 출력
            }
        } else {
            if (number == 1) {
                System.out.println("flag 값은 false, number 값은 1 입니다."); // 미출력
            } else if (number == 2) {
                System.out.println("flag 값은 false, number 값은 2 입니다."); // 미출력
            }
        }
    }
}

중첩 if문 활용

package operator;

import java.util.Objects;
import java.util.Scanner;

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

        // A에게 값 입력받기
        System.out.print("A 입력 : ");
        String aHand = scanner.nextLine();

        // B에게 값 입력받기
        System.out.print("B 입력 : ");
        String bHand = scanner.nextLine();

        // 두 개의 값을 비교하는 메서드 -> Objects.equals(좌, 우) : 좌 우가 같은 경우 true, 다른 경우 false
        if (Objects.equals(aHand, "가위")) {
            if (Objects.equals(bHand, "가위")) {
                System.out.println("A와 B는 비겼습니다.");
            } else if (Objects.equals(bHand, "바위")) {
                System.out.println("B가 이겼습니다.");
            } 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("A가 이겼습니다.");
            } else if (Objects.equals(bHand, "바위")) {
                System.out.println("A와 B는 비겼습니다.");
            } else if (Objects.equals(bHand, "보")) {
                System.out.println("B가 이겼습니다");
            } 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("A가 이겼습니다.");
            } else if (Objects.equals(bHand, "보")) {
                System.out.println("A와 B는 비겼습니다.");
            } else {
                System.out.println("B 유저의 값을 잘못 입력했습니다.");
            }
        } else {
            System.out.println("A 유저의 값을 잘못 입력했습니다.");
        }
    }
}

switch / case

if 문보다 좀 더 가독성이 좋은 조건문 표현식이다.

package operator;

public class W14 {
    public static void main(String[] args) {
        // switch/case 문

        int month = 8;
        String monthString = "";
        switch (month) {
            case 1:  monthString = "1월";
                break;
            case 2:  monthString = "2월";
                break;
            case 3:  monthString = "3월";
                break;
            case 4:  monthString = "4월";
                break;
            case 5:  monthString = "5월";
                break;
            case 6:  monthString = "6월";
                break;
            case 7:  monthString = "7월";
                break;
            case 8:  monthString = "8월";
                break;
            case 9:  monthString = "9월";
                break;
            case 10: monthString = "10월";
                break;
            case 11: monthString = "11월";
                break;
            case 12: monthString = "12월";
                break;
            default: monthString = "알수 없음";
        }
        System.out.println(monthString); // 8월 출력
    }
}

for문

특정 조건에 따라 연산을 반복해서 수행하고 싶을 때 사용하는 문맥이다.

package operator;

public class W15 {
    public static void main(String[] args) {
        // for 문
        // (초기값; 조건문; 증가연산)
        for(int i=0; i < 4; i++) { // 변수 i 값은 0 ~ 3 까지 반복
            System.out.println(i + "번째 출력"); // i 변수와 문자열 합치기
        }

        // 향상된 for문
        // 기존 : for문 안에 3개의 표현식이 들어간다 -> (초기값; 조건문; 증가연산)
        // 향상된 for문 : 2개로 줄여준다.

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

        // 만약 기존 for 문으로 구현한다면?
        int[] numbers = {3,6,9,12,15};
        for (int i = 0; i < numbers.length; i++) { // 배열에 .length 를 붙이면 길이값이 응답됩니다.
            System.out.println(numbers[i]);
        }
    }
}

while문, do-while문

for문과 동일하게 특정 조건에 따라 연산을 반복해서 수행하고 싶을 때 사용하는 문맥이다.
초기값 없이 조건문만 명시하여 반복한다.

package operator;

public class W16 {
    public static void main(String[] args) {
        // while 문
        int number = 0;
        while(number < 3) {  // number < 3인 동안~~
            number++;
            System.out.println(number + "출력");
        }

        // do-while 문
        int number = 4;
        do {
            System.out.println(number + "출력");
        } while(number < 3); // 연산을 한번 수행 후 조건문 체크

        // break 명령
        int number = 0;
        while(number < 3) {
            number++;
            if (number == 2) {
                break;  // 2일때 반복 중단
            }
            System.out.println(number + "출력");
        }

        // break 명령 범위
        for (int i = 0; i < 10; i++) {
            System.out.println("i: " + i);
            if (i == 2) {
                break; // i 가 2일때 가장 바깥 반복문이 종료됩니다.
            }
            for (int j = 0; j < 10; j++) {
                System.out.println("j: " + j);
                if (j == 2) {
                    break; // j 가 2일때 가장 안쪽 반복문이 종료됩니다.
                }
            }
        }

        // continue 명령
        int number = 0;
        while(number < 3) {
            number++;
            if (number == 2) {
                continue;  // 2일때 반복 패스
            }
            System.out.println(number + "출력");
        }
    }
}

배열

한 번에 많은 양의 데이터를 다루거나 계산할 때 사용한다.

package week02.array;

public class Arr01 {
    public static void main(String[] args) {
        // 배열 생성
        int[] intArray = new int[3];  // [0, 0, 0]
        boolean[] boolArray = new boolean[3];  // [false, false, false]
        String[] stringArray = new String[3];  // ["", "", ""]

        // 배열 선언 먼저! -> 나중에 초기화
        int[] intArray2;
        intArray2 = new int[3];  // [0, 0, 0]

        // 생성한 배열을 '순회' -> 배열의 값을 하나씩 뽑아서 조회한다.
        // (1) 단건 조회
        System.out.println(intArray[1]);

        System.out.println("----------");

        // (2) 다건 조회
        // length : 길이를 구하는 메서드
        for (int i = 0; i < intArray2.length; i++) {
            System.out.println(intArray2[i]);
        }
    }
}

package week02.array;

import java.util.Arrays;

public class Arr02 {
    public static void main(String[] args) {
        // 초기화

        // 1. 배열에 특정값 대입해서 선언
        int[] intArr = {1, 2, 3, 4, 5};
        String[] stringArray = {"a", "b", "c", "d"};

        // 2. for문을 통해서 대입
        for (int i = 0; i < intArr.length; i++) {
            intArr[i] = i;
        }

        // 다건출력
        for (int i = 0; i < intArr.length; i++) {
            System.out.println(intArr[i]);
        }

        for (int item : intArr) {
            System.out.println(item);
        }

        // 배열의 주소를 모두 같은 값으로 초기화
        Arrays.fill(intArr, 1);

        for (int item : intArr) {
            System.out.println(item);
        }
    }
}

복사

얕은 복사 : 배열 변수 간에 대입 연산자를 사용해서 복사를 하게 되면 주소값만 복사된다.

package week02.array;

public class Arr03 {
    public static void main(String[] args) {
        // 얕은 복사
        int[] a = { 1, 2, 3, 4 };
        int[] b = a; // 얕은 복사

        b[0] = 3; // b 배열의 0번째 순번값을 3으로 수정했습니다. (1 -> 3)

        System.out.println(a[0]); // 출력 3  <- a 배열의 0번째 순번값도 3으로 조회됩니다.
    }
}

깊은 복사 : 실제 값을 가지고 있는 배열의 기본형을 꺼내서 복사하면 된다.

package week02.array;

import java.util.Arrays;

public class Arr04 {
    public static void main(String[] args) {
        // 2. Arrays.copyOf() 메서드
        int[] a = { 1, 2, 3, 4 };
        int[] b = Arrays.copyOf(a, a.length); // 배열과 함께 length값도 같이 넣어줍니다.

        a[3] = 0;
        System.out.println(a[3]);
        System.out.println(b[3]);
    }
}

String 배열

package week02.array;

public class Arr05 {
    public static void main(String[] args) {
        // 문자(char), 문자열(String)
        // String = char[]

        // [기본형 변수 vs 참조형 변수]
        // 1. 기본형 변수는 '소문자로 시작함' 반면, 참조형 변수는 '대문자로 시작함'
        //    - Wrapper class에서 기본형 변수를 감싸줄 때(boxing), int -> Integer
        // 2. 기본형 변수는 값 자체를 저장, 참조형 변수는 별도의 공간에 값을 저장 후 그 주소를 저장함. (=주소형 변수)

        // char < String(훨씬 더!)
        // String이 가지고 있는 기능이 너무 많아서..!!!!!!
        // Wrapper class와도 상당히 비슷..! -> 기본형 변수가 가지고 있는 기능이 제한 -> 다양한 기능을 제공하는 Wrapper을 감쌈으로써, 추가기능을 더함

        // String 기능 활용 예시
        String string = "ABCD";

        // (1) length
        int strLength = string.length();
        System.out.println(strLength);

        // (2) charAt(int index)
        char strChar = string.charAt(1);
        System.out.println(strChar);

        // (3) substring(int fromIdx, int toIdx)
        String strSub = string.substring(0, 3);
        System.out.println(strSub);

        // (4) equals(String str)
        String newStr = "ABCE";
        boolean strEqual = newStr.equals(string);
        System.out.println(strEqual);

        // (5) toCharArray() : String -> char[]
        char[] strCharArray = string.toCharArray();

        // (6) 반대로 char[] -> String -> char
        char[] charArray = {'A', 'B', 'C'};
        String charArrayString = new String(charArray);
        System.out.println(charArrayString);
    }
}

다차원 배열

2차원 배열

package week02.array;

public class Arr06 {
    public static void main(String[] args) {
        // 반복문을 통한 초기화
        int[][] array = new int[2][3]; // 최초 선언

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println("출력값 -> " + i + ", " + j);
                array[i][j] = 0;  // i, j 는 위 노란색 네모박스 안에있는 숫자를 의미하며 인덱스 라고 부릅니다.
            }
        }
    }
}

가변 배열

package week02.array;

public class Arr07 {
    public static void main(String[] args) {
        // 가변배열
        int[][] array = new int[3][];

        // 배열 원소마다 각기 다른 크기로 지정
        array[0] = new int[2];
        array[1] = new int[4];
        array[2] = new int[1];

        // 중괄호로 초기화를 아예 해버릴 때도 가능함!!
        int[][] array2 = {
                {10, 20},
                {10, 20, 30, 40},
                {10}
        };
    }
}

컬렉션

컬렉션 종류

List : 순서가 있는 데이터의 집합(데이터 중복 허용) - 배열과 비슷하다.
Queue : 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합이다.
Set : 순서가 없는 데이터의 집합(데이터 중복 불가능) - 순서 없고 중복 없는 배열이다.
Map : 순서가 없는 (Key-Value) 쌍으로 이루어진 데이터의 집합이다. (Key값 중복 불가능)

List

배열처럼 크기가 정해져 있지 않고 필요할 때마다 크기가 점점 늘어난다.

package week02.collection;

import java.util.ArrayList;

public class Col1 {
    public static void main(String[] args) {
        // 리스트
        // 순서가 있는 데이터의 집합 -> Array(최초 길이를 알아야 함)
        // 처음에 길이를 몰라도 만들 수 있음!
        // 1) Array -> 정적배열
        // 2) List(ArrayList) -> 동적배열(크기가 가변적으로 늘어난다.)
        //     - 생성 시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓는다.
        //     - 값이 추가될 때 더 큰 공간이 필요하면 더 큰 공간을 받아서 저장하니까 상관없다!!

        ArrayList<Integer> intList = new ArrayList<Integer>();  // 선언 + 생성

        intList.add(99);
        intList.add(15);
        intList.add(3);

//        System.out.println(intList.get(1));

        // 2번째 있는 값(15)을 바꿔보자.
        intList.set(1, 10);
//        System.out.println(intList.get(1));

        System.out.println(intList.get(0));

        // 삭제
        intList.remove(0);
        System.out.println(intList.get(0));

        System.out.println("클리어 전");
        System.out.println(intList.toString());
        intList.clear();
        System.out.println("클리어 후");
        System.out.println(intList.toString());
    }
}

LinkedList

기본적인 기능은 ArrayList와 동일하지만 값을 나누어 담기 때문에 모든 값을 조회하는 속도가 느리다.
값을 중간에 추가하거나 삭제할 때는 속도가 빠르다.

package week02.collection;

import java.util.LinkedList;

public class Col2 {
    public static void main(String[] args) {
        // Linked list
        // 메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 담아놓는다.
        // 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조.

        // 기본적 기능은 ArrayList와 동일!!
        // LinkedList는 값 -> 여기저기 나누어서 저장 -> 조회하는 속도가 "느리다...."
        // 값을 추가하거나, 삭제할 때는 빠르다.

        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.get(1));
        System.out.println(linkedList.get(2));

        System.out.println(linkedList.toString());  // 이렇게 조회할 때는 arrayList보다 속도가 현저히 느리다.

        linkedList.add(200);
        System.out.println(linkedList.toString());

        linkedList.add(2, 4);
        System.out.println(linkedList.toString());

        linkedList.set(1, 30);
        System.out.println(linkedList.toString());

        linkedList.remove(1);
        System.out.println(linkedList.toString());

        linkedList.clear();
        System.out.println(linkedList.toString());
    }
}

Stack

상자에 물건을 넣고 꺼내는 것처럼 밑에서 위로 쌓고, 꺼낼 때는 위에서부터 꺼낸다.
최근 저장된 데이터를 나열하고 싶거나 데이터의 중복처리를 막고 싶을 때 사용한다.

package week02.collection;

import java.util.Stack;

public class Col3 {
    public static void main(String[] args) {
        // Stack
        // 수직으로 값을 쌓아놓고, 넣었다가 뺸다. FILO(Basket)
        // push, peek, pop
        // 최근 저장된 데이터를 나열하고 싶거나, 데이터의 중복 처리를 막고 싶을 때 사용

        Stack<Integer> intStack = new Stack<Integer>();

        intStack.push(10);
        intStack.push(15);
        intStack.push(1);

        // 다 지워질 때까지 출력
        while (!intStack.isEmpty()) {
            System.out.println(intStack.pop());
        }

        // 다시 추가
        intStack.push(10);
        intStack.push(15);
        intStack.push(1);

        // peek
        System.out.println(intStack.peek());
        System.out.println(intStack.size());
    }
}

Queue

빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있다.
First In First Out : 먼저 들어간 순서대로 값을 조회할 수 있다.
생성자가 없는 껍데기라서 바로 생성할 수 없다.

package week02.collection;

import java.util.LinkedList;
import java.util.Queue;

public class Col4 {
    public static void main(String[] args) {
        // Queue : FIFO
        // add, peek, poll
        // Queue : 생성자가 없는 인터페이스

        Queue<Integer> intQueue = new LinkedList<>();  // queue 선언, 생성

        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);

        while (!intQueue.isEmpty()) {
            System.out.println(intQueue.poll());
        }

        // 다시 추가
        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);
        intQueue.add(10);

        // peek
        System.out.println(intQueue.peek());
        System.out.println(intQueue.size());
    }
}

Set

순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지할 수 있다.
생성자가 없는 껍데기라서 바로 생성할 수 없다.

package week02.collection;

import java.util.HashSet;
import java.util.Set;

public class Col5 {
    public static void main(String[] args) {
        // Set(집합) : 순서 없고, 중복 없음!!
        // 순서가 보장되지 않는 대신 중복을 허용하지 않도록 하는 프로그램에서 사용할 수 있는 자료구조
        // Set -> 그냥 쓸 수도 있음. 그러나, HashSet, TreeSet 등으로 응용해서 같이 사용 가능
        // Set은 생성자가 없는 껍데기라서 바로 생성할 수 없음!!!!!
        // 생성자가 존재하는 HashSet을 이용해서 -> Set을 구현해볼 수 있다!!

        Set<Integer> intSet = new HashSet<>();  // 선언 및 생성

        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);
        }

        // contains
        System.out.println(intSet.contains(2));
        System.out.println(intSet.contains(5));
    }
}

Map

key - value 형태로 데이터를 저장하기 때문에 기존에 순번으로만 조회하던 방식에서, key 값을 기준으로 value를 조회할 수 있다.
key 값 단위로 중복을 허용하지 않는다.

package week02.collection;

import java.util.HashMap;
import java.util.Map;

public class Col6 {
    public static void main(String[] args) {
        // Map : key - value pair -> 중요!!
        // key라는 값으로 unique하게 보장이 되어야 한다!
        // Map -> HashMap, TreeMap으로 응용 가능!

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

        // 키 값
        intMap.put("일", 11);
        intMap.put("이", 12);
        intMap.put("삼", 13);  // 중복 key
        intMap.put("삼", 14);  // 중복 key
        intMap.put("삼", 15);  // 중복 key

        // key 값 전체 출력(향상된 for문)
        for (String key : intMap.keySet()) {
            System.out.println(key);
        }

        // value 값 전체 출력(향상된 for문)
        for (Integer value : intMap.values()) {
            System.out.println(value);
        }

        System.out.println(intMap.get("삼"));
    }
}

숙제

자료구조 요리 레시피 메모장 만들기

입력값

저장할 자료구조명을 입력합니다. (List, Set, Map)
내가 좋아하는 요리 제목을 먼저 입력합니다.
이어서 내가 좋아하는 요리 레시피를 한 문장씩 입력합니다.
입력을 마쳤으면 마지막에 "끝" 문자를 입력합니다.

출력값

입력이 종료되면 저장한 자료구조 이름과 요리 제목을 괄호로 감싸서 먼저 출력해 줍니다.
이어서, 입력한 모든 문장 앞에 번호를 붙여서 입력 순서에 맞게 모두 출력해 줍니다.

내가 작성한 코드

package week02;

import java.util.*;

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

        System.out.print("원하는 자료구조를 입력하세요 (List, Set, Map) : ");
        String structure = scanner.nextLine();

        if (structure.equals("List")) {
            ArrayList<String> strList = new ArrayList<String>();

            System.out.print("좋아하는 요리 제목을 입력해주세요 : ");
            String title = scanner.nextLine();

            // 입력
            while (true) {
                String sentence = scanner.nextLine();

                if (sentence.equals("끝")) {
                    break;
                }

                strList.add(sentence);
            }

            // 출력
            System.out.println("[ " + structure + " 으로 저장된 " + title + " ]");

            for (int i = 0; i < strList.size(); i++) {
                System.out.println((i + 1) + ". " + strList.get(i));
            }
        } else if (structure.equals("Set")) {
            Set<String> strSet = new LinkedHashSet<>();

            System.out.print("좋아하는 요리 제목을 입력해주세요 : ");
            String title = scanner.nextLine();

            // 입력
            while (true) {
                String sentence = scanner.nextLine();

                if (sentence.equals("끝")) {
                    break;
                }

                strSet.add(sentence);
            }

            // 출력
            System.out.println("[ " + structure + " 으로 저장된 " + title + " ]");

            int count = 1;
            for (String value : strSet){
                System.out.println(count + ". " + value);
                count++;
            }
        } else if (structure.equals("Map")) {
            Map<Integer, String> strMap = new LinkedHashMap<>();

            System.out.print("좋아하는 요리 제목을 입력해주세요 : ");
            String title = scanner.nextLine();

            // 입력
            int count2 = 1;
            while (true) {
                String sentence = scanner.nextLine();

                if (sentence.equals("끝")) {
                    break;
                }

                strMap.put(count2, sentence);
                count2++;
            }

            // 출력
            System.out.println("[ " + structure + " 으로 저장된 " + title + " ]");

            for (int n = 1; n <= strMap.size(); n++) {
                System.out.println(n + ". " + strMap.get(n));
            }
        } else {
            System.out.println("잘못 입력된 자료구조입니다.");
        }
    }
}

공부하면서 느낀 점

오늘은 또 자바의 새로운 개념을 마주했다. 뭔가 이번 주부터 프로그래밍 챕터에 들어가고 강의를 듣다 보니 새로운 내용이 엄청 쏟아지는 것 같다. 새로운 내용을 배우는 것은 재밌지만 이해하기 위해서는 시간을 상당히 투자해야 된다!

그리고 개인 과제 발제 시간에 인텔리제이의 기능인 자동완성 기능을 꺼버렸다! 튜터님께서 끄고 하는 것이 나중에 실력 오르는 데 더 효과적이라고 하셨다.

아직 2주 차까지 들었지만 각 주차의 숙제를 어렵지 않게 해결하고 있어 다행이라는 생각이 든다... 내일은 3주 차를 듣고 3주 차의 숙제를 해결해야 하는데 난이도가 조금 오른다고 해서 걱정이다.. 하지만 강의 잘 듣고 개념을 잘 정리한다면 해결할 수 있을 것이라고 생각한다!!!

그리고 오늘 숙제를 해결하면서 출력에서 내가 원하는 대로 나오지 않아서 헤맸는데.. 그 이유가 HashSet을 사용했을 때 순서를 반영하지 않고 저장을 하기 때문에 출력 또한 입력한 순서대로 나오지 않는 것이었다... 그래서 이 문제를 해결하기 위해 LinkedHashSet을 사용했고 입력한 순서대로 출력 값을 얻을 수 있었다. 조만간 컬렉션 관련 개념을 더 공부하고 정리해서 블로그에 올려두고 자주 복습해야겠다.....

후.. 나만의 속도로 열심히 하다 보면 팀 프로젝트에서 민폐는 끼치지 않는 팀원이 될 수 있겠지..
중간에 게을러지지 않고 열심히 강의 듣고 내 것으로 만들어야겠다!!! 더 노력하자!!

'✏️ Today I Learned(TIL) > 🌱 스파르타 내일배움캠프' 카테고리의 다른 글

프로그래밍 기초_Day 4 (7)	2024.11.15
프로그래밍 기초_Day 3 (31)	2024.11.14
프로그래밍 기초_Day 1 (12)	2024.11.12
미니 프로젝트를 통해 얻은 내용들 (0)	2024.11.10
미니 프로젝트_KPT 회고 (4)	2024.11.08

Carrot Dev🥕

프로그래밍 기초_Day 2

오늘 한 것

배운 내용 정리

연산자

연산자 종류

조건문, 반복문

배열

컬렉션

숙제

공부하면서 느낀 점

'✏️ Today I Learned(TIL) > 🌱 스파르타 내일배움캠프' 카테고리의 다른 글

티스토리툴바

프로그래밍 기초_Day 2

오늘 한 것

배운 내용 정리

연산자

연산자 종류

조건문, 반복문

배열

컬렉션

숙제

공부하면서 느낀 점

'✏️ Today I Learned(TIL) > 🌱 스파르타 내일배움캠프' 카테고리의 다른 글

관련글

티스토리툴바