일 | 월 | 화 | 수 | 목 | 금 | 토 |
---|---|---|---|---|---|---|
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 |
- aws #아키텍트 #과정 #vpc #인프라 구축 #amazon sns #server #less #architecture
- aws #아키텍트 #과정 #vpc #인프라 구축 #auto scailling #lauch template #ec2 instace #private #subnet
- 스파르타코딩클럽 #부트캠프 #IT #백엔드 #OSI #ISO #AI #서버 #자동화 #SQL #기본문법 #데이터베이스 #DBMS #Oracle #MongoDB #아키텍쳐 #DB
- 업로드 #lambda #함수 #모바일 이미지 #썸네일 이미지
- aws #아키텍트 #과정 #vpc #인프라 구축 #rds #endpoint #cloudwatch #monitoring
- aws #아키텍트 #과정 #vpc #인프라 구축 #second nat #gateway #routing table #route53 #고가용성 #private subnet #
- aws #아키텍트 #과정 #vpc #인프라 구축 #sqs #trigger #python3.9 #패키지 #
- aws #아키텍트 #과정 #vpc #인프라 구축 #ec2 #instance #launch #template #생성 #ami #amazone #machine #image
- 썸네일 #이미지
- 공간복잡도 #공간자원 #캐시메모리 #SRAM #DRAM #시간복잡도
- aws #아키텍트 #과정 #vpc #인프라 구축 #s3 #bucket #객체 스토리지 #objects storage #events #upload #알림
- aws #아키텍트 #과정 #vpc #인프라 구축 #haproxy #고가용성 #테스트 #alb #application #load balancer #application
- aws #아키텍트 #과정 #vpc #인프라 구축 #s3 #bucket #객체 #스토리지 #isci #이미지 #업로드
- aws #아키텍트 #과정 #vpc #인프라 구축 #rds #replica #복제본 #aurora #database #고가용성
- aws #아키텍트 #과정 #vpc #인프라 구축 #haproxy #round robin #process #high ability #auto scailling #app server #launch template
- 스파르타코딩클럽 #부트캠프 #IT #백엔드 #머신러닝 #AI #서버 #자동화 #SQL #기본문법 #데이터베이스 #웹개발
- aws #아키텍트 #과정 #vpc #인프라 구축 #alb #load balancer #t.g #target #group #haproxy #high ability #db #replica #region
- aws #아키텍트 #과정 #vpc #인프라 구축
- 스파르타코딩클럽 #부트캠프 #IT #백엔드 #머신러닝 #AI #서버 #자동화 #SQL #KDT #기본문법 #데이터베이스 #Computer #Science #CPU #메모리
- 스파르타코딩클럽 #부트캠프 #IT #백엔드 #머신러닝 #AI #서버 #자동화 #SQL #기본문법 #데이터베이스
- aws #아키텍트 #과정 #vpc #인프라 구축 #aurora #database #rds #rdbs #load #balancer #web #page #haproxy
- 비트 #바이트 #이진수
- 쓰레드 #쓰레드풀 #프로세스
- aws #아키텍트 #과정 #vpc #인프라 구축 #t.g #target group #alb #application #load #balancer #web #server
- 스파르타코딩클럽 #부트캠프 #IT #백엔드 #머신러닝 #딥러닝 #AI #서버 #자동화 #SQL #기본문법 #데이터베이스
- 프로세스 #CPU #시공유 #커널
- 스파르타코딩클럽 #부트캠프 #IT #백엔드 #머신러닝 #딥러닝 #AI #서버 #자동화 #SQL #기본문법 #데이터베이스 #DBMS #Oracle #MongoDB #아키텍쳐 #DB
- aws #아키텍트 #과정 #vpc #인프라 구축 #db #장애조치 #reand only #replica #events
- aws #아키텍트 #과정 #vpc #인프라 구축 #sqs #message #queue #sns구독
- aws #아키텍트 #과정 #vpc #인프라 구축 #php #alb #application #load #balancer #security #group #igw #ec2 #vpc #virtual #private #cloud
- Today
- Total
요리사에서 IT개발자로
스파르타 코딩클럽 부트캠프 (Java 문법 2장) 본문
피연산자와 연산자란
계산할 때 계산의 대상이 되는것이 피연산자.
계산의 목적이 되는것이 연산자
연산자
덧셈 뺄셈처럼 계산할 기호
피연산자
연산자로 인해 계산되는 숫자
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(조건)
- switch(피연산자) {case(조건):(연산)} 형태로 많이 쓰인다
- switch(피연산자)가 case(조건)을 만족하면 case: 뒤에 명시되있는 연산을 수행한다
- case(조건) : (연산)은 여러개 설정할 수 있다.
- 연산문에 break;를 꼭 넣어야한다.(무한 루프 발생하지 않도록)
- 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[ ]와 같은 배열형 변수는 여러 개를 변수에 저장할 수 있다
한 번에 많은 양의 데이터를 다루거나 계산할 때 사용한다.
선언방법
- 타입 [ ] 변수; Ex) int[ ] intArray;
- 타입 변수[ ] , 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차원 배열에 대괄호를 하나 더 추가해주면된다.
- int [ ] [ ]array
- int array [ ] [ ]
- 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)처럼 일렬로 데이터를 저장, 조회하여
순번 값(인덱스)으로 하나씩 조회 할 수 있다.
특징
- 배열(Array)처럼 크기가 정해져 있지 않고
- 필요할 때 마다 크기가 늘어난다.
기능
- 선언 : ArrayList<Integer> intList 형태로 선언
- 생성 : new ArrayList<Integer> ( ); 형태로 생성
- 초기화 : 사이즈를 지정하는 겂이 없기에 초기화가 필요없다.
- 값 추가 : intList. add( { 추가할 값 } ) 형태로 값을 추가한다.
- 값 수정 : intList.set ( { 수정할 순번}, {수정할 값} ) 형태로 값을 수정한다.
- 값 삭제 : intList.remover ( { 삭제할 순번 } ) 형태로 값을 삭제한다.
- 전체 출력 : intList.toString( )형태로 전체 값을 대괄호 [ ]로 묶어 출력한다.
- 전체 제거 : intList.clear ( )형태로 전체값을 삭제한다.
Array는 크기를 고정하여 생성하는 것 (정적 배열)
- 메모리에 연속된 공간을 요청한 사이즈 만큼 받아서 실제 값을 저장하는 변수
ArrayList는 크기가 가변적으로 늘어나는 것 (동적배열)
- 생성 시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담고,
- 값이 추가될 때 더 큰공간이 필요하면 할당을 받아 저장한다.
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란
메모리에 남는 공간을 요청해서 여기저기 나누어 실제값을 담고,
실제 값이 있는 주소값으로 목록을 구성하고 저장한다.
특징
- 기본적인 기능은 ArrayList와 동일하지만
- LinkedList는 값을 나누어 담기에 모든값을 조회하는 속도가 느리다.
- 값을 중간에 추가하거나 삭제할 때는 속도가 빠르다.
- 중간에 값을 추가하는 기능이 있다.(속도 빠름)
기능
- 선언 : 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)
특징
- 물건을 뺄때 위에 있는 것을 빼는 것.
- 넣는 기능 push ( ), 조회peek( ), 꺼내다 pop( ) 기능만 존재한다.
- 최근에 저장된 데이터를 나열하고 싶거나 데이터의 중복처리를 막고싶을 때 사용한다.
기능
- 선언 : 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)
특징
- 넣는기능 add( ), 조회 peek( ), 꺼내는 poll( ) 기능만 존재한다.
- Queue는 생성자가 인터페이스라서 바로 생성 할 수 없다.
- 생성자가 존재하는 클래스 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이란
순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지할 수 있다.
특징
- set은 HashSet, TreeSet등으로 응용하여 사용할 수 있다.
- Set은 생성자가 없는 인터페이스라서 바로 생성할 수 없다.
- 생성자가 존재하는 클래스 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구로조 구성된 데이터를 저장할 수 있다.
특징
- key-value형태로 저장하기에 기존 순번으로만 조회하던 방식에서
- key값을 기준으로 value를 조회할 수 있다.
- key값 단위로 중복을 허용하지 않는 기능을 가지고 있다.
- 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
https://hs-backend.tistory.com/25
https://hs-backend.tistory.com/24
'Java' 카테고리의 다른 글
스파르타 코딩클럽 부트캠프 (Java 문법 3장) (0) | 2024.04.29 |
---|---|
스파르타 코딩클럽 자바문법 2장 배열, 컬렉션정리 (1) | 2024.04.25 |
스파르타 코딩클럽 부트캠프 (Java 문법 1장) (2) | 2024.04.22 |
Eclipse 단축키 정리(with 자바의 정석) (0) | 2024.04.18 |
Java 2장(with 이것이 자바다) (0) | 2024.04.11 |