TIL

[TIL] 240423 <자바> 연산자,조건문,반복문,배열,컬렉션

[3. 연산자]

연산자 우선순위

산술 > 비교 > 논리 > 대입

비트 연산

컴퓨터의 가장 작은 단위가 Bit이기 때문에 연산 중에서 Bit 연산이 가장 빠름

<< : 자릿수를 왼쪽으로 옮기는 횟수만큼 2의 배수로 곱셈 연산과 동일
>> : 자릿수를 오른쪽으로 옮기는 횟수만큼 2의 배수로 나눗셈 연산과 동일

[4. 조건문, 반복문]

if문과 switch문의 차이점

1. if문은 복합 조건(괄호 안에 조건 여러개 지정가능)을 지원 / switch문은 피연산자 한개에 대한 조건만 지원
2. if문은 상대적으로 코드 중복이 많음 / switch문은 코드 중복이 적음

[5. 배열]

참조형 변수들처럼 new 명령을 통해서 생성하며 대괄호 안에 크기를 지정해줌
(참조형 변수이기 때문에 실제 값을 담지 않고 실제 값의 주소값 저장함)

ex) int array[] = new int[8];
초기값은 int는 0, boolean은 false, String은 null 값으로 초기화됨

<배열 초기화 방법>
1. 중괄호 {} 사용
ex) int[] intArray = {1, 2, 3, 4, 5}, String[] stringArray = {"a", "b", "c", "d"};
2. for문 사용
3. Arrays.fill 메소드 사용
ex) Arrays.fill(intArray, 1); //배열의 모든 값을 1로 초기화

<복사>
- 얕은 복사 → 주소값만 복사되고 실제 값은 1개로 유지되어서 요소값 변경 시 같이 변경됨
ex) int[] a = { 1, 2, 3, 4 }; int[] b = a; // 얕은 복사

- 깊은 복사 → 똑같은 실제 값을 가지는 배열 만들고 싶다면 깊은복사해야함
(1) for문 사용
(2) .clone() 사용 (단, 2차원이상 배열에서는 얕은 복사로 동작!)
(3) Arrays.copyOf(복사할배열, 배열.length)

String 배열

 // 선언 후 하나씩 초기화
String[] stringArray = new String[3];
stringArray[0] = "val1";
stringArray[1] = "val2";
stringArray[2] = "val3";
 
// 선언과 동시에 초기화
String[] stringArray1 = new String[]{"val1", "val2", "val3"};
String[] stringArray2 = {"val1", "val2", "val3"};

- char는 기본형 변수(소문자로 시작), String은 참조형 변수(대문자로 시작)이며 실제값의 주소값 저장함
- String을 더 많이 쓰는 이유 : 참조형 변수가 더 많은 기능 보유!

메소드	응답값 타입	기능
.length()	int	문자열 길이 반환
.charAt(int index)	char	해당 인덱스의 문자 반환
.substring(int from, int to)	String	문자열에서 해당 범위(from~to)에 있는 문자열을 반환 (to는 불포함)
.equals(String str)	boolean	문자열 내용이 같으면 결과는 true, 다르면 false 반환
.toCharArray()	char[]	String → char[] 변환
new String(char[] charArr)	String	char[] → String 변환

다차원 배열

가변 배열

행마다 다른 길이의 배열 저장 가능

 // 선언 및 초기화
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}
 
};
 
//.length 사용
for (int i = 0; i < array2.length; i++) { // 1차원 길이
	for (int j = 0; j < array2[i].length; j++) { // 2차원 길이
		System.out.println(array2[i][j]); // 2중 반복문으로 i, j 인덱스 순회
	}
}

[6. 컬렉션]

- 배열보다 다수의 "참조형" 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능 많이 가짐
: 크기 자동조정 / 추가 / 수정 / 삭제 / 반복 / 순회 / 필터 / 포함 확인 등
- 기본형 변수가 아닌 참조형 변수를 저장
- 컬렉션 종류 : List, Set, Queue, Map

List

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

1. ArrayList

Array는 메모리에 연속된 공간을 요청한 사이즈만큼 받아서 실제 값을 저장하는 기본형 변수로 저장하는 정적배열,
ArrayList는 생성시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓고, 값이 추가될 때 더 큰 공간이 필요하면 받아서 저장하는 동적 배열이라 크기를 지정하지 않아도 됨.

add(값) :추가, set(순번,값) :값 수정, remove(순번) :삭제 , toString() :[전체값출력] , clear() :전체값 삭제

 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 출력
        
        //intList.toString() : 전체 값을 대괄호로 묶어서 출력
		System.out.println(intList.toString()); // [1,2,3] 출력
		
        
        //intList.set(수정할 순번, 수정할 값)
		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()); // [] 출력 (비어있음)
	}
}

2. LinkedList

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

값을 나누어 담기 때문에 모든 값을 조회하는 속도가 느리지만, 값을 중간에 추가/삭제 시 속도 빠름

add(값) :추가, add(순번,값) : 중간에 추가, set(순번,값) :값 수정, remove(순번) :삭제 ,
toString() :[전체값출력] , clear() :전체값 삭제

 import java.util.LinkedList;
 
public class Main {
 
	public static void main(String[] args) {
		LinkedList<Integer> linkedList = new LinkedList<>(); // 선언 및 생성
 
		linkedList.add(1);  // 값 추가
		linkedList.add(2);
		linkedList.add(3);
 
		System.out.println(linkedList.get(0)); // 1 출력
		System.out.println(linkedList.get(1)); // 2 출력
		System.out.println(linkedList.get(2)); // 3 출력
		System.out.println(linkedList.toString()); // [1,2,3] 출력 (속도 느림)
 
		// ⭐ 값 중간에 추가 가능 ⭐ 
		linkedList.add(2, 4); // 2번 순번에 4 값을 추가 (속도 빠름)
		System.out.println(linkedList); // [1,2,4,3] 출력
 
		linkedList.set(1, 10); // 1번순번의 값을 10으로 수정
		System.out.println(linkedList.get(1)); // 10 출력
 
		linkedList.remove(1); // 1번순번의 값을 삭제 (속도 빠름)
		System.out.println(linkedList); // [1,4,3] 출력
 
		linkedList.clear(); // 전체 값 삭제
		System.out.println(linkedList); // [] 출력 (비어있음)
	}
}

3. Stack (LIFO)

최근 저장된 데이터를 나열하고 싶거나 데이터의 중복 처리를 막고 싶을 때 사용

push(값) :추가, peek() :맨위값 조회, pop() :맨위값 꺼냄

 import java.util.Stack;
 
public class Main {
 
	public static void main(String[] args) {
		Stack<Integer> intStack = new Stack<Integer>(); // 선언 및 생성
		
		intStack.push(1);  //값 추가  
		intStack.push(2);
		intStack.push(3);
 
		while (!intStack.isEmpty()) { // 다 지워질때까지 출력
        	
            // pop() : 맨 위값 꺼내고 삭제
		    System.out.println(intStack.pop()); // 3,2,1 출력
		}
 
		// 다시 값 추가
		intStack.push(1);
		intStack.push(2);
		intStack.push(3);
		
		// peek() : 맨 위값 조회
		System.out.println(intStack.peek()); // 3 출력
		System.out.println(intStack.size()); // 3 출력 (peek() 할때 삭제 안됐음)
		
		// pop() : 맨 위값 꺼내고 삭제
		System.out.println(intStack.pop()); // 3 출력
		System.out.println(intStack.size()); // 2 출력 (pop() 할때 삭제 됐음)		
		
		System.out.println(intStack.pop()); // 2 출력
		System.out.println(intStack.size()); // 1 출력 (pop() 할때 삭제 됐음)		
 
		while (!intStack.isEmpty()) { // 다 지워질때까지 출력
		    System.out.println(intStack.pop()); // 1 출력 (마지막 남은거 하나)
		}
	}
}

Queue (FIFO)

생성자가 없는 인터페이스 (LinkedList 사용)

add(값) :추가, peek() :맨아래값 조회, poll() :맨아래값 꺼냄

 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()) { // 다 지워질때까지 출력
        
        	// poll() : 맨 아래 값 꺼냄
			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()는 삭제X 조회만!)
 
		// 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 출력 (마지막 남은거 하나)
		}
	}
}

Set

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

그냥 Set으로도 쓸 수 있지만 HashSet, TreeSet 등으로 응용하여 사용가능
- HashSet : 가장 빠름, 순서 전혀 예측불가
- TreeSet : 정렬된 순서대로 보관하며 정렬 방법 지정가능
- LinkedHashSet : 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능
- 보통 HashSet 쓰는데, 순서보장 필요 시 LinkedHashSet 사용
생성자가 없는 인터페이스

add(값) :추가, remove(값) :삭제, contains(값) :포함 확인으로 boolean반환

 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() : 해당 값이 포함되어있는지 boolean값 반환
		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 출력
		}
	}
}

Map

순서가 없는 (Key,Value)쌍으로 이루어진 데이터의 집합 (Key값 중복 허용X)

key값 기준으로 value 조회 (key값 중복X!)
그냥 Map으로도 쓸 수 있지만 HashMap, TreeMap 등으로 응용하여 사용가능
- HashMap : 중복 허용X, 순서보장X, key와 value로 null 허용
- TreeMap : key값 기준 정렬 가능, 저장 시 정렬(오름차순)하기 때문에 저장시간 다소 오래걸림

put(key,value) :key에 value값 추가, get(key) :key에 대한 value값 조회, keySet() :전체 key값들 조회,
values() :전체 value값들 조회, remove(key) :key에 대한 value값 삭제

 import java.util.Map;
 
public class Main {
 
	public static void main(String[] args) {
		Map<String, Integer> intMap = new HashMap<>(); // 선언 및 생성
 
		//  put(key,value) : 값 추가 
		intMap.put("일", 11);
		intMap.put("이", 12);
		intMap.put("삼", 13);
		intMap.put("삼", 14); // 중복 Key값은 덮어씀
		intMap.put("삼", 15); // 중복 Key값은 덮어씀
 
 
		// key 값 전체 출력
        // intMap.keySet() : 전체 key값들 조회
		for (String key : intMap.keySet()) { 
			System.out.println(key); // 일,이,삼 출력
		}
 
		// value 값 전체 출력
        // intMap.values() : 전체 value값들 조회
		for (Integer key : intMap.values()) {
			System.out.println(key); // 11,12,15 출력
		}
 
 
		// get(key) : key에 대한 value값 조회
		System.out.println(intMap.get("삼")); // 15 출력
        
		// remove(key) : key에 대한 value값 삭제
		intMap.remove("삼"); // 15 삭제
	}
}

길이값 반환

1. length

배열의 길이 조회
arrays(int[], double[], String[])

2. length()

문자열의 길이 조회
String related Object(String, StringBuilder etc)

3. size()

컬렉션 타입 목록의 길이 조회
Collection Object(ArrayList, Set etc)

Contents

[3.연산자]

연산자우선순위

비트연산

[4.조건문,반복문]

if문과switch문의차이점

[5.배열]

String 배열

다차원 배열

가변배열

[6.컬렉션]

List

Queue(FIFO)

Set

Map

길이값반환

1.length

2.length()

3.size()

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

새소식

인기 검색어

[TIL] 240423 <자바> 연산자,조건문,반복문,배열,컬렉션

[3. 연산자]

연산자 우선순위

비트 연산

[4. 조건문, 반복문]

if문과 switch문의 차이점

[5. 배열]

String 배열

다차원 배열

가변 배열

[6. 컬렉션]

List

Queue (FIFO)

Set

Map

길이값 반환

1. length

2. length()

3. size()

당신이 좋아할만한 콘텐츠

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역

	// 선언 후 하나씩 초기화
	String[] stringArray = new String[3];
	stringArray[0] = "val1";
	stringArray[1] = "val2";
	stringArray[2] = "val3";

	// 선언과 동시에 초기화
	String[] stringArray1 = new String[]{"val1", "val2", "val3"};
	String[] stringArray2 = {"val1", "val2", "val3"};

	// 선언 및 초기화
	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}

	};

	//.length 사용
	for (int i = 0; i < array2.length; i++) { // 1차원 길이
	for (int j = 0; j < array2[i].length; j++) { // 2차원 길이
	System.out.println(array2[i][j]); // 2중 반복문으로 i, j 인덱스 순회
	}
	}

	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 출력

	//intList.toString() : 전체 값을 대괄호로 묶어서 출력
	System.out.println(intList.toString()); // [1,2,3] 출력


	//intList.set(수정할 순번, 수정할 값)
	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()); // [] 출력 (비어있음)
	}
	}

	import java.util.LinkedList;

	public class Main {

	public static void main(String[] args) {
	LinkedList<Integer> linkedList = new LinkedList<>(); // 선언 및 생성

	linkedList.add(1); // 값 추가
	linkedList.add(2);
	linkedList.add(3);

	System.out.println(linkedList.get(0)); // 1 출력
	System.out.println(linkedList.get(1)); // 2 출력
	System.out.println(linkedList.get(2)); // 3 출력
	System.out.println(linkedList.toString()); // [1,2,3] 출력 (속도 느림)

	// ⭐ 값 중간에 추가 가능 ⭐
	linkedList.add(2, 4); // 2번 순번에 4 값을 추가 (속도 빠름)
	System.out.println(linkedList); // [1,2,4,3] 출력

	linkedList.set(1, 10); // 1번순번의 값을 10으로 수정
	System.out.println(linkedList.get(1)); // 10 출력

	linkedList.remove(1); // 1번순번의 값을 삭제 (속도 빠름)
	System.out.println(linkedList); // [1,4,3] 출력

	linkedList.clear(); // 전체 값 삭제
	System.out.println(linkedList); // [] 출력 (비어있음)
	}
	}

	import java.util.Stack;

	public class Main {

	public static void main(String[] args) {
	Stack<Integer> intStack = new Stack<Integer>(); // 선언 및 생성

	intStack.push(1); //값 추가
	intStack.push(2);
	intStack.push(3);

	while (!intStack.isEmpty()) { // 다 지워질때까지 출력

	// pop() : 맨 위값 꺼내고 삭제
	System.out.println(intStack.pop()); // 3,2,1 출력
	}

	// 다시 값 추가
	intStack.push(1);
	intStack.push(2);
	intStack.push(3);

	// peek() : 맨 위값 조회
	System.out.println(intStack.peek()); // 3 출력
	System.out.println(intStack.size()); // 3 출력 (peek() 할때 삭제 안됐음)

	// pop() : 맨 위값 꺼내고 삭제
	System.out.println(intStack.pop()); // 3 출력
	System.out.println(intStack.size()); // 2 출력 (pop() 할때 삭제 됐음)

	System.out.println(intStack.pop()); // 2 출력
	System.out.println(intStack.size()); // 1 출력 (pop() 할때 삭제 됐음)

	while (!intStack.isEmpty()) { // 다 지워질때까지 출력
	System.out.println(intStack.pop()); // 1 출력 (마지막 남은거 하나)
	}
	}
	}

	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()) { // 다 지워질때까지 출력

	// poll() : 맨 아래 값 꺼냄
	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()는 삭제X 조회만!)

	// 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 출력 (마지막 남은거 하나)
	}
	}
	}

	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() : 해당 값이 포함되어있는지 boolean값 반환
	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 출력
	}
	}
	}

	import java.util.Map;

	public class Main {

	public static void main(String[] args) {
	Map<String, Integer> intMap = new HashMap<>(); // 선언 및 생성

	// put(key,value) : 값 추가
	intMap.put("일", 11);
	intMap.put("이", 12);
	intMap.put("삼", 13);
	intMap.put("삼", 14); // 중복 Key값은 덮어씀
	intMap.put("삼", 15); // 중복 Key값은 덮어씀


	// key 값 전체 출력
	// intMap.keySet() : 전체 key값들 조회
	for (String key : intMap.keySet()) {
	System.out.println(key); // 일,이,삼 출력
	}

	// value 값 전체 출력
	// intMap.values() : 전체 value값들 조회
	for (Integer key : intMap.values()) {
	System.out.println(key); // 11,12,15 출력
	}


	// get(key) : key에 대한 value값 조회
	System.out.println(intMap.get("삼")); // 15 출력

	// remove(key) : key에 대한 value값 삭제
	intMap.remove("삼"); // 15 삭제
	}
	}