Notice
Recent Posts
Recent Comments
Link
«   2024/12   »
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
Tags more
Archives
Today
Total
관리 메뉴

요리사에서 IT개발자로

스파르타 코딩클럽 부트캠프 (Java 문법 2장) 본문

Java

스파르타 코딩클럽 부트캠프 (Java 문법 2장)

H.S-Backend 2024. 4. 24. 11:30

피연산자와 연산자란

계산할 때 계산의 대상이 되는것피연산자.

계산의 목적이 되는것연산자

 

연산자 

덧셈 뺄셈처럼 계산할 기호

피연산자 

연산자로 인해 계산되는 숫자

 

package Week02;

public class w01 {
    public static void main(String[] args) {
        int x = 5;
        int y = 10;

        int z = x + y;
        System.out.println(z);
    }
}

산술연산자 +, -, *, / ,% ,<<,>> 사칙 연산과 비트연산
비교연산자 >, <, >=, <=, ==, != 크고 작음과 같고 다름을 비교
논리연산자 &&, ||, ! 그리고 (AND)와 또는(OR)으로 조건을 연결
대입연산자 -, ++, -- 우변의 값을 좌변에 저장, 연산 복합 대입
기타연산자 (type), ?:, instance of 형변환 연산자, 삼항 연산자, instance of 연산자

 

산술연산자

사칙연산을 계산한 결과값을 출력한다.

비교연산자

값의 크고/작음을 비교하거나 같고/다름을 비교하여 true/ false값인 boolean값으로 출력한다

논리연산자

조건을 연결하였을 때 boolean값들을 조합하여 true/false 값인 boolean값으로 출력한다.

대입연산자

기본대입연산자 (=) , 다른연산을 함께쓰는 복합대입연산자 (+=, -=, *= ...)

삼항연산자

3가지 피연산자가 존재하여 삼항연산자 (조건/참결과/거짓결과)

연산자 우선순위

산술  >  비교  >  논리  >  대입

산술변환

연산 전 두 피연산자의 타입을 같게 일치시킨다.

비트연산

1byte는 8bit

<< 왼쪽으로 자릿수 옮기기

>> 오른쪽으로 자릿수 옮기


대입연산자 중 증감 연산자 쓸때

피연산자의
앞 이나 뒤에 연산자를 붙이면 연산순서가 달라진다.
연산자
연산자 위치
기능
연산 예
++
++{피연산자}
연산 전에 피연산자에 1 더해줍니다.
val = ++num; num값+1 후에 val변수에 저장
++
{피연산자}++
연산 후에 피연산자에 1 더해줍니다.
val = num++; num값을 val변수에 저장 후 num+1
—{피연산자}
연산 전에 피연산자에 1 빼줍니다.
val = —num; num값-1 후에 val변수에 저장
{피연산자}—
연산 후에 피연산자에 1 빼줍니다.
val = num—; num값을 val변수에 저장 후 num-1
산술연산자 : +, -, *, /, %(나머지), <<, >>
비교연산자 : >, <, >=, <=,== !=
논리연산자 : &&, ||, !
대입연산자 : =, ++, --
기타연산자 : (type), ? :, instance of

[연산자 우선순위 : 산술 > 비교 > 논리 > 대입]
-연산자 여러개가 함께 있는 연산을 계산할 때는 우선순위가 있다.
-위 우선순위에 따라서 최종적인 응답값이 결정된다.
-단, 괄호로 감싸주면 괄호안의 연산이 최우선순위로 계산된다.


[연산자 우선순위 : 산술 > 비교 > 논리 > 대입]
-연산자 여러개가 함께 있는 연산을 계산할 때는 우선순위가 있다.
-위 우선순위에 따라서 최종적인 응답값이 결정된다.
-단, 괄호로 감싸주면 괄호안의 연산이 최우선
연산 전에 두 피 연산자의 타입이 다른 경우 타입을 일치시킨다.
- 두 피연산자의 타입을 같게 일치시킨다. (둘중에 저장공간 크기가 더 큰 타입으로 일치)
    -피연산자의 타입이 'int' 보다 작은 'short' 타입이면 'int'로 변환
    -피연산자의 타입이 'long'보다 작은 'int', 'short'타입이면 'Long'으로 변환
    -피연산자의 타입이 'float'보다 작은 'long', 'int','short' 타입이면 'float'으로 변환
    -피연산자의 타입이 'double'보다 작은 'float', 'long', 'int', 'short' 타입이면 'double'로 변환
    -변수 여러개를 연산했을 때 결과값은 피연산자 중 표현범위가 가장 큰 변수타입으로 변환하게된다.
package Week02;

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(4%2); //0
        System.out.println(5%2); //1
        System.out.println("----------------");


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

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

        //덧셈
        c= a + b;
        System.out.println(c);

        //뺼셈
        c= a - b;
        System.out.println(c);

        //곱셈
        c= a * b;
        System.out.println(c);

        //나눗셈
        c= a / b;
        System.out.println(c);
    }
}
package Week02;

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
    }
}
package Week02;

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

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


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

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

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

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

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

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

    }
}
package Week02;

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);  //8;

        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;

        // ++, --

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

        number--;
        System.out.println(number);
    }
}
package Week02;

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

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 of 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 ) ? x : y;
        System.out.println(min);

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

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 && true
        System.out.println(result);

        result = x + 10 < y && y < z; // false && true
        System.out.println(result);

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

        result = x + 2 * 3 > y; //false
        System.out.println(result);
        System.out.println("-----");

        result = (x+2) * 3 > y;  //true
        System.out.println(result);
    }
}
package Week02;

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

        int z = x + y;

        long lx = 30L;
        long lz = z + lx;

        float fx = x;
        float fy = y;
        float fz = z;

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

public class w10 {
    public static void main(String[] args) {
        System.out.println(3<<2); //3을 2로 나누면 2진수로 11 왼쪽으로 옮긴다. 2번째 앞으로 1100 => 12
        System.out.println(5<<1); //5를 2로 나누면 2진수로 101을 왼쪽으로 옮긴다. 1번째 앞으로 1010 => 10
        System.out.println(3<<3); //3을 2로 나누면 2진수로 11 을 왼쪽으로 옮긴다. 3번째 앞으로 11000 => 24 
    }
}

조건문과 반복문

 

특정 조건에 따라 다른연산을 수행하고 싶을때조건문

특정 조건에 따라 동일한 연산을 수행하고 싶을 때 반복문


조건문 if와 switch

차이점1.
if문은 복합조건을 지원한다
- 복합조건 : 괄호 ()안에 조건 여러개를 지정하여 조건문을 수행할 수 있다.
-switch문은 피연산자 한개에 대한 조건만 지원한다.

차이점2.
-if문은 상대적으로 코드중복이 많다.
-switch문은 코드중복이 적다.
if(조건)

if의 소괄호()안의 조건이 boolean값 true를 만족하면 중괄호 { }안의 연산을 수행한다.

if(조건) -else

if의 소괄호()안의 조건이 boolean값 false를 만족하면 else의 중괄호{ }안의 연산을 수행한다.

if(조건) - else if(조건)

else if의 소괄호()안의 조건이 boolean값 true를 만족하면 else if의 중괄호{ }안의 연산을 수행한다.

중첩 if(조건)

if, else, else if 로 해결못하면 if, else if, else 안에 if를 넣을 수 있다.

차이점1.
if문은 복합조건을 지원한다
- 복합조건 : 괄호 ()안에 조건 여러개를 지정하여 조건문을 수행할 수 있다.
switch문은 피연산자 한개에 대한 조건만 지원한다.

차이점2.
if문은 상대적으로 코드중복이 많다.
switch문은 코드중복이 적다.
package Week02;

public class w11 {
    public static void main(String[] args) {
        boolean flag = true;

//        if(1!=1) {
//            //true인경우
//            System.out.println("값이 true입니다.");
//        } else {
//            //false인경우
//            System.out.println("값이 false입니다.");
//        }


       //조건문
        int number = 2;

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

public class w12 {
    public static void main(String[] args) {
        //중첩 if문
        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입니다");
            }else {
                System.out.println("flag값은 false이고, number값은 모르겠습니다.");
            }
        } else{
            if(number == 1) {
                System.out.println("flag값은 true이고 number값은 1입니다");
            }else if (number ==2){
                System.out.println("flag값은 true이고 number값은 2입니다");
            }else {
                System.out.println("flag값은 false이고, number값은 모르겠습니다.");
            }
        }
    }
}
package Week02;

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

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

        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("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가 잘못입력하였습니다.");
            }

            if (Objects.equals(aHand, "바위")) {
                if (Objects.equals(bHand, "가위")) {
                    System.out.println("B가 이겼습니다.");
                } else if (Objects.equals(bHand, "바위")) {
                    System.out.println("A와 B는 비겼습니다");
                } else if (Objects.equals(bHand, "보")) {
                    System.out.println("B가 이겼습니다.");
                } else {
                    System.out.println("B가 잘못입력하였습니다.");
                }
                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(조건)

  1. switch(피연산자) {case(조건):(연산)} 형태로 많이 쓰인다
  2. switch(피연산자)가 case(조건)을 만족하면 case: 뒤에 명시되있는 연산을 수행한다
  3. case(조건) : (연산)은 여러개 설정할 수 있다.
  4. 연산문에 break;를 꼭 넣어야한다.(무한 루프 발생하지 않도록)
  5. if의 else처럼 switch는 default: (연산)를 넣어 아무조건이 일치하지않으면 나오게 해야한다.
package Week02;

public class w14 {
    public static void main(String[] args) {
        int month = 8;
        String monthString = "";

        //switch문
        switch (month) {
            // case ~~~연산
            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 = "12월";
                break;
            case 12:
                monthString = "12월";
                break;
            default:
                monthString = "알 수 없음";
        }
        System.out.println(monthString);
    }
}

 

반복문 - fot, while, do-while

for문
  • for(초기값; 조건문; 증가연산) { (연산) } 형태로 사용
  • 특정 조건초기값과 조건문을 통해 정의한다.
  • 반복할 때 마다 값을 증가시키려면 증가연산을 정의한다.
  • 초기값이 조건문을 만족할 때까지 (연산)을 수행하며 회차마다 증가연산을 수행한다.
향상된 for문
  • for(변수타입 변수명 : 목록변수) { ( 연산) } 형태로 사용
  • 연속된 변수 목록을 출력할 때 쓰인다.
  • 변수 타입과 변수명은 for문 안에서 연산을 수행할 변수를 정의한다.
while문
  • while(조건문) {(연산)} 형태로 사용
  • 위 처럼 while문으로 사용하면 조건문을 만족해야지만 연산이 반복 수행한다.
  • 한번 반복할 때 조건문을 체크해서 불만족이면 반복을 중단한다.
do-while문
  • do{ (연산) } while(조건문) 형태로 사용
  • 위처럼 do-while문으로 사용하면 최초 1회 연산 수행후 조건문을 체크하고 더 반복할지 결정한다.
  • 반복하게 된다면 그 이후에 한번 반복할 때 마다 조건문을 체크해서 불만족(false)이면 반복을 중단한다.
break명령
  • break; 명령을 호출하면 가장 가까운 블럭의 for문 또는 while문의 반복문을 중단한다.
continue명령 
  • for과 while문에서 해당 순서를 패스하고 싶을 때 continue 명령을 사용한다..
package Week02;

public class w15 {
    public static void main(String[] args) {
//        //for문
//        // (초기값; 조건문; 증가연산)
//        for (int i=0; i < 4; i++ ) {
//            System.out.println(i+"번째 출력");
//        }


        //향상된 for문
        //rlwhs : for문 안에 3개의 표현이 들어간다 => (초기값 ; 조건문 ; 증가연산)
        // 향상된 for문 : 2개로 줄여준다.
//        int [] numbers = {3, 6, 9, 12, 15};
//        for (int number : numbers) {
//            System.out.print(number+" ");
//        }
        int[] numbers = {3, 6, 9, 12, 15};
        for (int i=0; i < numbers.length; i++) {
            System.out.print(numbers[i]+ " ");
        }

    }
}

package Week02;

public class w16 {
    public static void main(String[] args) {
//        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(깨부수다)
        // 가장 가까운 블록의 for문 또는 while문, switch문을 중단한다.
//        int number = 0;
//        while(number < 3) {
//            number++;
//            if (number == 1) {
//                break;
//            }
//            System.out.println(number + "출력 !");
//            }
//        for (int i = 0; i<10; i++) {
//            System.out.println("i : "+ i);
//            if(i == 2 ) {
//                break;
//            }
//            for(int j=0;j<10;j++){
//                System.out.println("j: "+j);
//                if(j==2){
//                    break; //j가 2일때 반복문 for종료
//                }
//            }
//        }
        int number = 0;
        while(number < 3) {
            number++;
            if(number == 2){
                continue;
            }
            System.out.println(number + "출력!");
        }
    }
}
package Week02;

import java.util.Scanner;

public class w17 {
    public static void main(String[] args) {
        //입력받는 단을 제외하고 출력
        Scanner sc = new Scanner(System.in);
        int passNum = sc.nextInt(); //출력을 제외할 구구단수 값

        //구구단 만들기
        for (int i=2; i<=9; i++) { //구구단의 첫 번째 수
            if(i ==passNum){
                continue;
            }
            for(int j=2; j<=9; j++){ //구구단의 두번째 수
                System.out.println(i+ "곱하기"+ j +"는" + (i*j)+ "입니다.");
            }
        }
    }
}

배열(Array)

 

여러개 변수를 같은 곳에 모아서 배열(array)이라는 변수에 저장한다.

 

int와 같은 기본형 변수는 1개의 값만 변수에 저장할 수 있다면
int[ ]와 같은 배열형 변수는 여러 개를 변수에 저장할 수 있다

 

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

선언방법
  1. 타입 [ ] 변수; Ex) int[ ] intArray;
  2. 타입 변수[ ] , Ex) int intArray[ ];

 

배열(Array) 참조형 변수들 처럼 new 명령을 통하여 생성하며, 대괄호[ ] 안에 크기를 지정해준다.

 

순번이 0부터 시작해서 8개까지이면 0~7까지가 8이다.

출처 : 스파르타 코딩클럽

 

int 0, boolean은 false,

String은 null값과 같은 초기값이 정해져있다.

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) 다건 조회(important)
        //length의 길이만큼 출력
        for(int i=0; i<intArray2.length; i++){
            System.out.println(intArray2[i]);
        }
    }
}

순회란

배열 안에 담겨있는 변수를 하나씩 꺼내서 사용하는 것

 

해당 배열 변수뒤에 순번을 대괄호[ ]로 감싸서 명시해주면된다.

순회하는 방법은 반복문 사용이 가장 일반적이다.

 

 

반복문 안에서 단건 조회 했던것처럼 대괄호 [ ] 안에 반복문 순번 값 i를 넣어주면 된다.[ i ]

.length() 
배열이 지원하는 메소드배열의 길이값을 응답해준다.
배열의 길이는 처음에 선언한 크기를 갖고있다.

 

package Week02.array;

import java.util.Arrays;

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

        //1.배열의 특정값을 대입해서 선언
//        int[] intArr = {10, 20, 30, 40, 50};
//        String[] stringArray = {"a", "b", "c", "d"};

        //2. for 문을 통해서 대립
//        for(int i=0; i<intArr.length; i++){
//            intArr[i] = i;
//        }
        System.out.println("---------");
        //다건출력
//        for(int i=0; i<intArr.length; i++){
//            System.out.println(intArr[i]);
//        }
        int[] intArr = {10, 20, 30, 40, 50};
//        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;
        System.out.println(a[0]);
    }
}

얕은 복사

배열 변수 간 대입연산자 (=) 를 사용해서 복사를 하면 주소값만 복사되는 값 


주소값만 복사되고 실제 값은 1개로 유지되는 걸 얕은 복사라 한다.

깊은 복사

새로운 배열을 똑같이 만들 때 사용하는 복사

 

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

package Week02.array;

import java.util.Arrays;

public class Arr04 {
    public static void main(String[] args) {
        //2. Arrays.copy0f() 메서드
        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 기능 활용 (= char 배열)

문자열(String) = 문자배열(char)

String = char[ ]

 

기본형 변수(char)와 참조형 변수(String)의 차이
기본형 변수는 소문자로 시작하고 참조형 변수는 대문자로 시작한다.
참조형 변수는 실제값의 주소를 저장하고 있는 변수
  • String은 char배열과 같기에 둘 다 문자열을 저장할 수 있는 변수이다.
  • 하지만 String을 더 많이 쓰는데 그 이유가 참조형 변수가 더 많은 기능을 가지고 있기 때문이다.

 

char 배열에 없고 String만 가지고 있는 기능 표

메서드
응답값 타입
설명
length()
int
문자열의 길이를 반환한다.
charAt(int index)
char
문자열에서 해당 index의 문자를 반환한다.
substring(int from, int to)
String
문자열에서 해당 범위(from~to)에 있는 문자열을 반환한다. (to는 범위에 포함되지 않음)
equals(String str)
boolean
문자열의 내용이 같은지 확인한다. 같으면 결과는 true, 다르면 false가 된다.
toCharArray()
char[]
문자열을 문자배열(char[])로 변환해서 반환한다.
new String(char[] charArr)
String
문자배열(char[]) 을 받아서 String으로 복사해서 반환한다.

 

package Week02;

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

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

        //char < String 을 더 많이 사용한다
        //String이 가지고 있는 기능이 더 많다.
        // Wrapper class와 비슷 하다 => 기본형 변수가 가지고 있는 기능이 지한 = > 다양한 기능을 제공하는 Wrapper를 감쌈으로써 추가기능을 더함

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

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

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

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

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

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

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

다차원 배열

 

2차원 배열(2열 배열), 순회

 

2차원 배열 선언방법

 1차원 배열에 대괄호를 하나 더 추가해주면된다.

  1. int [ ] [ ]array
  2. int array [ ] [ ]
  3. int [ ] array [ ]

생성할 때도 int [ ] [ ] array = new int [ ] [ ] ; 해주면된다.

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


다차원 배열조회

2차원 배열 조회할 때

2차원 인덱스를 가진만큼 2중 반복문을 통해 출력할 수 있다.

package Week02.array;

public class Arr08 {
    public static void main(String[] args) {
        //최소값 구하기
        int[] arr = {0, 3, 2, 1, 5, 1};

        //최소값의 초기화를 세팅
        int min = arr[0];

        //최소값의 로직 구하기
        for(int num: arr){
            if (num < min){
                min = num;
            }
        }
        System.out.println("최소값은 => " + min);
    }
}

컬렉션(Collection)

참조형 변수만 저장함으로써 여러 기능을 제공한다.

컬렉션은 여러가지 종류가 있으며 이러한 컬렉션들은
데이터를 넣고 빼는 방법이 각자 다르기에 용도에 맞게 사용한다.

 

컬렉션 종류
  • List : 순서가 있는 데이터의 집합(데이터 중복 O) - 배열과 비슷하다.
  • Queue : 한쪽에서 데이터를 넣고 반대쪽에서 뺄 수 있다. (FIFO)
  • Set : 순서가 없는 데이터의 집합(데이터 중복 X) - 순서 없고 중복없는 배열
  • Map : 순서가 없는 (Key, Value) 쌍으로 이루어진 데이터의 집합( Key 값 중복 허용하지 않는다)

출처 : 스파르타 코딩클럽

int의 참조형 변수 = Integer
long의 참조형 변수 = Long
double의 참조형 변수 = Double
String은 기본 참조형 변수

 

ArrayList란

배열(Array)처럼 일렬로 데이터를 저장, 조회하여
순번 값(인덱스)으로 하나씩 조회 할 수 있다.

 

특징
  1. 배열(Array)처럼 크기가 정해져 있지 않고
  2. 필요할 때 마다 크기가 늘어난다.
기능
  • 선언 : ArrayList<Integer> intList 형태로 선언
  • 생성 : new ArrayList<Integer> ( ); 형태로 생성
  • 초기화 : 사이즈를 지정하는 겂이 없기에 초기화가 필요없다.
  • 값 추가 : intList. add( { 추가할 값 } ) 형태로 값을 추가한다.
  • 값 수정 : intList.set ( { 수정할 순번}, {수정할 값} ) 형태로 값을 수정한다.
  • 값 삭제 : intList.remover ( { 삭제할 순번 } ) 형태로 값을 삭제한다.
  • 전체 출력 : intList.toString( )형태로 전체 값을 대괄호 [ ]로 묶어 출력한다.
  • 전체 제거 : intList.clear ( )형태로 전체값을 삭제한다.
Array는 크기를 고정하여 생성하는 것 (정적 배열)
  • 메모리에 연속된 공간을 요청한 사이즈 만큼 받아서 실제 값을 저장하는 변수
ArrayList는 크기가 가변적으로 늘어나는 것 (동적배열)
  1. 생성 시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담고,
  2. 값이 추가될 때 더 큰공간이 필요하면 할당을 받아 저장한다.
package collection;

import java.util.ArrayList;

public class Col1 {
    public static void main(String[] args) {
        //List
        //순서가 있는 데이터의 집합 => 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란

메모리에 남는 공간을 요청해서 여기저기 나누어 실제값을 담고,
실제 값이 있는 주소값으로 목록을 구성하고 저장한다.

 

특징
  1. 기본적인 기능은 ArrayList와 동일하지만 
  2. LinkedList는 값을 나누어 담기에 모든값을 조회하는 속도가 느리다.
  3. 값을 중간에 추가하거나 삭제할 때속도가 빠르다.
  4. 중간에 값을 추가하는 기능이 있다.(속도 빠름)
기능
  • 선언 : LinkedList<integer> linkedList 형태로 선언한다.
  • 생성 : new LinkedList<Integer> ( ); 형태로 생성한다
  • 초기화 : 사이즈를 지정하는 겂이 없기에 초기화가 필요없다.
  • 값 추가 : linkedList.add( { 추가할 값 }) 형태로 값을 추가한다.
  • 값 중간에 추가 : linkedList.add( { 추가할 순번 } , {추가할 값} ) 형태로 값을 중간에 추가한다.
  • 값 수정 : linkedList.set ( { 수정할 순번 } , {수정할 값 } ) 형태로 값을 수정한다.
  • 값 삭제 : linkedList.remove( { 삭제할 순번 } ) 형태로 값을 삭제한다.
  • 전체 출력 : linkedList.toString( ) 형태로 전체 값을 대괄호 [ ]로 묶어서 출력한다.
  • 전체 제거 : linkedList.clear( ) 형태로 전체값을 삭제한다.
package 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());  //

        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이란

값을 수직으로 쌓아놓고 넣었다가 빼며 조회하는 형식으로 데이터를 관리한다.
LIFO(Last in First out)
특징
  1. 물건을 뺄때 위에 있는 것을 빼는 것.
  2. 넣는 기능 push ( ), 조회peek( ), 꺼내다 pop( ) 기능만 존재한다.
  3. 최근에 저장된 데이터를 나열하고 싶거나 데이터의 중복처리를 막고싶을 때 사용한다.
기능 
  • 선언 : Stack<Integer> intStack 형태로 선언
  • 생성 : new Stack<Integer>( ); 형태로 생성
  • 추가 : intStack.push( { 추가할 값 } ) 형태로 값을 추가한다.
  • 조회 : intStack.peek( ) 형태로 맨 위값을 조회한다.
  • 꺼내기 : intStack.Pop()형태로 맨위 값을 꺼낸다.(꺼내고 나면 삭제한다.)
package 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란 

 

한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합
FIFO(Firsts In First out)

 

특징
  1. 넣는기능 add( ), 조회 peek( ), 꺼내는 poll( ) 기능만 존재한다.
  2. Queue는 생성자가 인터페이스라서  바로 생성 할 수 없다.
  3. 생성자가 존재하는 클래스 LinkedList를 사용하여 Queue를 생성하여 받을 수 있다.
기능
  • 선언 : Queue<Integer> intQueue형태로 선언
  • 생성 : new LinkedList<Integer>( ); 형태로 생성한다.
  • 추가 : intQueue.add( { 추가할 값 } )형태로 값을 맨 위에 추가한다.
  • 조회 : intQueue.peek( )형태로 맨 아래 값을 조회한다.
  • 꺼내기 : intQueue.poll( )형태로 맨 아래 값을 꺼낸다.(꺼내고 나면 삭제된다)
package 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(3);
        intQueue.add(5);

        while(!intQueue.isEmpty()){
            System.out.println(intQueue.poll());
        }
        intQueue.add(1);
        intQueue.add(3);
        intQueue.add(5);
        intQueue.add(10);

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

Set이란

순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지할 수 있다.
특징
  1. set은 HashSet, TreeSet등으로 응용하여 사용할 수 있다.
  2. Set은 생성자가 없는 인터페이스라서 바로 생성할 수 없다.
  3. 생성자가 존재하는 클래스 HashSet을 사용하여 set을 생성하여 받을 수있다.
기능
  • 선언 : Stack<Integer> intStack 형태로 선언한다.
  • 생성 : new Stack<Integer> ( ): 형태로 생성한다.
  • 추가 : intStack.push( { 추가할 값 }) 형태로 값을 추가한다.
  • 조회 : intStack.peek( )형태로 맨 위 값을 조회한다.
  • 꺼내기 : intStack.pop( ) 형태로 맨위 값을 꺼낸다.(꺼내고 나면 삭제된다)
package 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));  //전체 변수의 종류가 3이 아님 false
        System.out.println(intSet.contains(5));  //전체 변수의 종류가 6이 맞음 true

    }
}

Map이란

key-value구로조 구성된 데이터를 저장할 수 있다.

특징
  1. key-value형태로 저장하기에 기존 순번으로만 조회하던 방식에서
  2. key값을 기준으로 value를 조회할 수 있다.
  3. key값 단위로 중복을 허용하지 않는 기능을 가지고 있다.
  4. Map은 HashMap,TreeMap등으로 응용하여 사용할 수 있다.
기능
  • 선언 : Map<String, Integer> intMap형태로 Key타입과 Value타입을 지정해서 선언한다.
  • 생성: new HashMap<> ( );형태로 생성한다
  • 추가 : intMap.put( { 추가할 key값}, {추가할 Value값 } ) 형태로 Key에 Value값을 추가한다.
  • 조회 : intMap.get( {조회할 Key 값} )형태로 key에 잇는 Value값을 조회한다.
  • 전체 Value 조회 : intMap.values( ) 형태로 전체 value 값들을 조회한다.
  • 삭제 : intMap.remove( { 삭제할 key값 } )형태로 key에 있는 Value값을 삭제한다.
HashMap 
중복을 허용하지 않고 순서를 보장하지 않는다,키와 값으로 null이 허용된다.

TreeMap  
key값을 기준으로 정렬을 할 수 있다.
저장시 정렬을 오름차순으로 하기때문에 저장시간이 오래걸린다
package collection;

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

public class Col6 {
    public static void main(String[] args) {
        // Map : key => value pair => 중요하다.
        //keyvalue 값으로 uique하게 보장이 되야한다.
        // Map => HashSet, Treeset으로 응용된다.

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

        // 키 값
        intMap.put("일", 11);
        intMap.put("이", 12);
        intMap.put("삼", 13);
        intMap.put("삼", 14); //중복 key
        intMap.put("삼", 15); //중복 key
        intMap.put("삼", 16); //중복 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("삼"));  //삼중에 높은값을 출력 중복 허용하지않는다
    }
}

lengh는 배열의 길이를 조회해준다

array(int[ ], double [ ]. String[ ]

 

length( )는 문자열의 길이를 조회해준다. Ex) "ABCD.length() == 4

String related Objedct(String, StringBuilder etc)

 

Size( )는 컬렉션 타입 목록의 길이를 조회해준다.

Collection Object (ArrayList, Set etc)

 

https://hs-backend.tistory.com/43

 

스파르타 코딩클럽 부트캠프 (Java 문법 1장)

개발 언어의 역사 A언어 첫 개발 언어 A Programming Language의 약자 1960년대 발표 핵심기능 입/출력, 문맥 B언어 Bell사에서 개발한 언어 1960년대 발표 핵심기능 A언어 기능 + 기계식 데이터 타입, 연산

hs-backend.tistory.com

 

https://hs-backend.tistory.com/25

 

Java 2장(with 이것이 자바다)

변수(Variable)란 값을 저장할 수 있는 메모리의 공간 변수에는 복수 개의 값을 저장할 수 없고 하나의 값만 저장할 수 있다. 변수의 선언 어떤 타입의 데이터를 저장하고 이름이 무엇인지를 결정

hs-backend.tistory.com

 

https://hs-backend.tistory.com/24

 

Java 2장(with 자바의 정석)

연산자 (Operator) 어떠한 기능을 수행하는 기호(+, -, *, / 등) 피연산자(Operand) 연산자의 작업 대상(변수, 상수, 리터럴, 수식) 연산자의 종류 단항 연산자 + - (타입) ++ -- ~ ! 이항연산자 산술 : + - * / %

hs-backend.tistory.com

 

반응형