int A = 1
if (A == 1) {// 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}
if else 문
else문은 if문이 거짓일 시 실행 된다.
int A = 1
if (A == 1) {// 조건식 혹은 조건
System.out.println("조건 참일시 실행됨");
}else{ System.out.println("조건 거짓일시 실행됨");
if else if문
특정 조건이 여럿 필요 할때 이용하는 문맥
if else 문도 조건이 true 일때 연산을 시작함
int A = 1
if (A == 1) {// 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}else if (A == 2) {// 2차 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}
if else if 중첩문
if문과 else if 문은 무한하게 추가 할수 있다.
int A = 1
if (A == 1) {// 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}if (A == 1) {// 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}else if (A == 2) {// 2차 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}else if (A == 2) {// 3차 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}else if (A == 2) {// 4차 조건식 혹은 조건
System.out.println("조건 충족시 실행됨");
}
switch 문
if 문과 비슷 하지만 좀더 가독성이 좋다.
int cake = 3;
String cakemany = "";
switch (cake) {
case 1: cakemany = "한 조각";
break;
case 2: cakemany = "두 조각";
break;
case 3: cakemany = "세 조각";
break;
case 4: cakemany = "네 조각";
break;
case 5: cakemany = "다섯 조각";
break;
default: monthString = "한 홀 이상이 있다.";
}
System.out.println(cakemany); // 세 조각
반복문
for 문
특정 조건(true)만큼 연산을 반복 수행 할때 사용하는 문맥
기본 for 문과 foreach로 사용 가능함
// 기본 for문
int 변수명 = 조건;
for(int i = 0; i < 조건; i++){
System.out.print('조건이 끝날때 까지 실행됨');
}
//foreach 문
for( int a = 배열){
System.out.println("배열값을 전부 뱉음 "+ a );
}
while 문
특정 조건만(false)큼 연산을 반복 수행 할때 사용하는 문맥
do while 문으로 사용 가능함
//기본 while 문 break나 조건이 없는한 무한 반복한다.
while (true){
System.out.println("실행됨");
break;//
}
do {
System.out.println("실행됨");
break;//
}while (true);
int[] arr = new int[num];
String[] str = new String[num];
순회 방법
for 문을 이용하거나 foreach 문을 이용한다.
배열의 값 하나를 가져오는 방법은 배열명[ 인덱스 값 ]
// 기본 for 문
for (int i = 0; i < 배열명.length; i++) {
배열명 [i]
}
// foreach 문
for (String s : input) {
System.out.println(s);
}
초기화 방법
배열의 초기화는 총 3가지로
중괄호{}를 이용 ,for 문으로 초기화, Arrays.fill를 이용하기
import java.util.Arrays; // Arrays 클래스를 import 해주세요!
//1. 배열에 특정값 대입하며 선언
int[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"a", "b", "c", "d"};
//2-1. for문을 통해 값을 대입
for (int i = 0; i < intArray.length; i++) {
intArray[i] = i;
}
//2-2. 향상된 for문을 통한 배열 출력
for (int i : intArray) {
System.out.print(i); // 01234
}
//3. 배열의 주소를 모두 같은값으로 초기화
Arrays.fill(intArray, 1);//배열의 모든 값을 1로 초기화
for (int i : intArray) {
System.out.print(i); // 11111
}
복사 방법
얕은 복사와 깊은 복사로 나누어 진다.
얕은 복사 는 배열의 주소 값만 변하는것
깊은 복사는 배열의 실제 값이 변하는 것을 말함
// 얕은 복사
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으로 조회됩니다.
깊은 복사는 배열의 실제 값이 변하는 것을 말한다
for 문을 이용하거나 clone이나 Arrays.copyOf를 이용함
int[] a = { 1, 2, 3, 4 };
int[] b = new int[a.length];
for (int i = 0; i < a.length; i++) {
b[i] = a[i]; // 깊은 복사
}
// 2. clone() 메서드
int[] b = a.clone(); // 가장 간단한 방법입니다.
// 하지만, clone() 메서드는 2차원이상 배열에서는 얕은 복사로 동작합니다!!
import java.util.Arrays;// input 필요
// 3. Arrays.copyOf() 메서드
int[] b = Arrays.copyOf(a, a.length); // 배열과 함께 length값도 같이 넣어줍니다.
}}
String str = "ABCD";
// length()
int strLength = str.length();
System.out.println(strLength); // 4 출력
// charAt(int index)
char strChar = str.charAt(2); // 순번은 0부터 시작하니까 2순번은 3번째 문자를 가리킵니다.
System.out.println(strChar); // C 출력
// substring(int from, int to)
String strSub = str.substring(0, 3); // 0~2순번까지 자르기 합니다. (3순번은 제외)
System.out.println(strSub); // ABC 출력
// equals(String str)
String newStr = "ABCD"; // str 값과 같은 문자열 생성
boolean strEqual = newStr.equals(str);
System.out.println(strEqual); // true 출력
// toCharArray()
char[] strCharArray = str.toCharArray(); // String 을 char[] 로 변환
// 반대로 char[] 를 String로 변환하는 방법
char[] charArray = {'A', 'B', 'C'};
String charArrayString = new String(charArray); // char[] 를 String 으로 변환
다차원 배열 ( 배열[ ][ ] ... )
배열이 1열로 된것을 1차원 배열(배열명 [ ]), 그 이상을 다차원 배열 (배열명 [ ] [ ])이라 한다
다 차원 배열의 생성 및 초기화
// 중괄호를 사용해 초기화
int[][] arr = {{1,2,3},{4,5,6}}
// 반복문을 통한 초기화
int[][] array = new int[2][3]; // 최초 선언
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
arr[i][j] = 0; // i, j 는 위 노란색 네모박스 안에있는 숫자를 의미하며 인덱스 라고 부릅니다.
}
}
가변 배열
// 중괄호를 사용해 가변
int[][] arr = {
{1,2,3},
{4,5,6,56,88,123},
{4,5,6,9,10}
}
// 초기화 때를 이용해 사용해 가변
int[][] array = new int[2][]; //
array[0] = new int[2]; // {1,2}
array[1] = new int[4]; // {1,2,3,4}
array[2] = new int[1]; // {1}
2차원 이상 배열
대채로 3차원 까지만 사용하는 경우가 많다.
// 중괄호를 이용한 3차 배열
int[][][] arr = {{// 중괄호가 늘어난다.
{1,2,3},
{4,5,6,56,88,123},
{4,5,6,9,10}
},{
{1,2,3},
{4,5,6,56,88,123},
{4,5,6,9,10}
}}
다차원 이상 배열
대채로 3차원 까지만 사용하는 경우가 많다.
// 중괄호를 이용한 3차 배열
int[][][] arr = {{// 중괄호가 늘어난다.
{1,2,3},
{4,5,6,56,88,123},
{4,5,6,9,10}
},{
{1,2,3},
{4,5,6,56,88,123},
{4,5,6,9,10}
}}
다차원 이상 배열 조회
차원 하나마다 for문을 늘리면 된다.
for (int i = 0; i < array.length; i++) { // 1차원 길이
for (int j = 0; j < array[i].length; j++) { // 2차원 길이
System.out.println(array[i][j]); // 2중 반복문으로 i, j 인덱스 순회
}
}
최대값 최소값 구하기
// 최대값 구하기
int[] arr = { 3, 2, 1, 5, 1 };
// 최대값 초기값 세팅
int max = arr[0];
int min = arr[0];
// 최대값 구하기
for (int num : arr) {
if (num > max) { // 반복문 돌면서 나(max)보다 값이 작으면 저장
max = num;
}if (num < min) { // 반복문 돌면서 나(min)보다 값이 작으면 저장
min = num;
}
}
// 최소값 1 출력
System.out.println(min);
// 최대값 5 출력
System.out.println(max);
Map , 순서가 없는데이터 (Key, Value) 쌍으로 이루어진 집합 중복불가 (key) 중복가능 ( Value)
컬랙션은 기본형 변수가 아닌 참조형 변수를 저장함
List
정적 배열( Array)과 다른 동적배열( ArrayList)로 크기를 자유롭게 변형가능함
// ArrayList
// (사용하기 위해선 import java.util.ArrayList; 를 추가해야합니다.)
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 및 생성
intList.add(1);
intList.add(2);
intList.add(3);
System.out.println(intList.get(0)); // 1 출력
System.out.println(intList.get(1)); // 2 출력
System.out.println(intList.get(2)); // 3 출력
System.out.println(intList.toString()); // [1,2,3] 출력
intList.set(1, 10); // 1번순번의 값을 10으로 수정합니다.
System.out.println(intList.get(1)); // 10 출력
intList.remove(1); // 1번순번의 값을 삭제합니다.
System.out.println(intList.toString()); // [1,3] 출력
intList.clear(); // 전체 값을 삭제합니다.
System.out.println(intList.toString()); // [] 출력
}
}
Set
순서가 없지만 중복이 없도록 유지가능함
생성자가 없어 바로 생성은 불가능하지만 HashSet , TreeSet 로 사용가능함
// Set
// (사용하기 위해선 import java.util.Set; 와 java.util.HashSet; 를 추가해야합니다.)
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<Integer> intSet = new HashSet<Integer>(); // 선언 및 생성
intSet.add(1);
intSet.add(2);
intSet.add(3);
intSet.add(3); // 중복된 값은 덮어씁니다.
intSet.add(3); // 중복된 값은 덮어씁니다.
for (Integer value : intSet) {
System.out.println(value); // 1,2,3 출력
}
// contains()
System.out.println(intSet.contains(2)); // true 출력
System.out.println(intSet.contains(4)); // false 출력
// remove()
intSet.remove(3); // 3 삭제
for (Integer value : intSet) {
System.out.println(value); // 1,2 출력
}
}
}
Queue
선입선출로 들어온 대로 내보낸다.
선입후출로는Stack이 있다.
Set처럼 껍대기가 없어 LinkedList를 이용함
// Queue
// (사용하기 위해선 java.util.LinkedList; 와 import java.util.Queue; 를 추가해야합니다.)
import java.util.LinkedList;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
Queue<Integer> intQueue = new LinkedList<>(); // 선언 및 생성
intQueue.add(1);
intQueue.add(2);
intQueue.add(3);
while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intQueue.poll()); // 1,2,3 출력
}
// 다시 추가
intQueue.add(1);
intQueue.add(2);
intQueue.add(3);
// peek()
System.out.println(intQueue.peek()); // 1 출력 (맨먼저 들어간값이 1 이라서)
System.out.println(intQueue.size()); // 3 출력 (peek() 할때 삭제 안됬음)
// poll()
System.out.println(intQueue.poll()); // 1 출력
System.out.println(intQueue.size()); // 2 출력 (poll() 할때 삭제 됬음)
System.out.println(intQueue.poll()); // 2 출력
System.out.println(intQueue.size()); // 1 출력 (poll() 할때 삭제 됬음)
while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intQueue.poll()); // 3 출력 (마지막 남은거 하나)
}
}
}
Map
key 값과 value로 구분해 넣을 수 있다.
HashMap 과 TreeMap을 이용해 유용하게 사용가능함
// Map
// (사용하기 위해선 import java.util.Map; 를 추가해야합니다.)
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, Integer> intMap = new HashMap<>(); // 선언 및 생성
// 키 , 값
intMap.put("일", 11);
intMap.put("이", 12);
intMap.put("삼", 13);
intMap.put("삼", 14); // 중복 Key값은 덮어씁니다.
intMap.put("삼", 15); // 중복 Key값은 덮어씁니다.
// key 값 전체 출력
for (String key : intMap.keySet()) {
System.out.println(key); // 일,이,삼 출력
}
// value 값 전체 출력
for (Integer key : intMap.values()) {
System.out.println(key); // 11,12,15 출력
}
// get()
System.out.println(intMap.get("삼")); // 15 출력
}
}
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class w01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<>();
int count = 0;
while (true) {
System.out.print("첫 번째 숫자를 입력하세요: ");
int num_1 = sc.nextInt();
System.out.print("두 번째 숫자를 입력하세요: ");
int num_2 = sc.nextInt();
System.out.print("사칙연산 기호를 입력하세요: ");
char num_3 = sc.next().charAt(0);
int result = 0;
switch (num_3) {
case '*': result = num_1 * num_2;
break;
case '-': result = num_1 - num_2;
break;
case '/': result = num_1 / num_2;
break;
case '%': result = num_1 % num_2;
break;
case '+': result = num_1 + num_2;
break;
default:
System.out.println("제대로 사칙연산 기호를 입력해주세요 ");
break;
}
System.out.println("\n결과: " + result);
list.add(result);
count++;
System.out.println(count+"개 저장됨");
System.out.println("가장 먼저 저장된 연산 결과를 삭제하시겠습니까? (remove 입력 시 삭제)");
System.out.println("저장된 연산결과를 조회하시겠습니까? (inquiry 입력 시 조회)");
System.out.print("더 계산하시겠습니까? Y/(exit 입력 시 종료)");
String esc = sc.next();
if (esc.equals("inquiry")){
int count_i = 0;
System.out.println("== 계산 기록 ==============");
for (int i : list) {
count_i++;
System.out.println(count_i+"번 : "+ i);
}
System.out.println("==========================");
}
if (esc.equals("remove")) {
list.remove(0);
count--;
System.out.println(count+"개 남음");
if(count == 0){
continue;
}
}
if (esc.equals("exit")) {
break;
}
System.out.println();
}
}
}
