- 배열
- 선언
ㄴ 타입 [ ] 변수;
ㄴ 타입 변수 [ ];
ㄴ 한번에 많은 양의 데이터를 다루거나 계산할 때 사용
// 배열 선언
// 일반적인 선언방식
int[] intArray; // 정수 배열
long[] longArray;
double[] doubleArray; // 실수 배열
char[] charArray; // 문자 배열
String[] stringArray; // 문자열 배열
// 2번째 선언방식
int intArray[]; // 정수 배열
long longArray[];
double doubleArray[]; // 실수 배열
char charArray[]; // 문자 배열
String stringArray[]; // 문자열 배열
- 생성
ㄴ new [ ]
ㄴ new 명령어로 생성하고 통에 몇개를 담을지 미리 정의해주는 것
// 배열 생성
//배열 생성후 초기화하면 배열의 주소가 할당된다.
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}
- 순회
ㄴ 배열의 값을 하나 뽑아서 조회하는 방법은 해당 배열변수 뒤에 순번을 대괄호 [ ]로 감싸서 명시
ㄴ 배열을 순회하는 방법은 반복문을 사용하는 것이 가장 일반적인 방법
ㄴ 반복문 안에서 단건 조회했던것처럼 대괄호 [ ] 안에 반복문 순번값 i 를 넣어줌 [ i ]
// 배열 단건조회
int[] intArray = new int[3]; // 모두 0으로 초기화된 사이즈8의 배열 생성
// 배열에서 2번쨰 순번의 값을 출력해본다. (0부터 순번이 시작하므로 2번째 순번은 1)
System.out.println(intArray[1]);
// 출력
0//배열 순회
//길이가 8인 정수배열 선언
int[] intArray = new int[3];
// 배열이 초기화된 값을 출력해본다.
for(int i=0; i<intArray.length; i++) { // .length 는 배열의 길이
System.out.println(intArray[i]);
}
// 출력
0
0
0
- 초기화
ㄴ = { ... }
ㄴ 배열을 초기화할 때 3가지의 방법
1. 중괄호{ }를 사용해서 초기화
2. 반복문 for문을 사용해서 초기화(또는 향상된 for문)
3. Arrays.fill 메소드를 사용해 초기화(Arrays 클래스는 Java에서 기본 제공하는 메소드가 담긴 클래스)
// 배열 초기화
import java.util.Arrays; // Arrays 클래스를 import 해주세요!
public class Main {
public static void main(String[] args) {
//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
}
System.out.println(); // 줄바꿈
//3. 배열의 주소를 모두 같은값으로 초기화
Arrays.fill(intArray, 1);//배열의 모든 값을 1로 초기화
for (int i : intArray) {
System.out.print(i); // 11111
}
}
}
// 출력
01234
11111
- 복사
ㄴ 얕은 복사
# 배열 변수간에 대입 연산자 = 를 사용해서 복사를 하게 되면 주소값만 복사됨
# 주소값만 복사되고 실제값은 1개로 유지되는걸 얕은 복사라고 함
# 주소값만 복사된다는건 변수명은 서로 다르지만 같은 값을 보고 있다는 것을 뜻함
// 얕은 복사
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문을 통해서 하나씩 꺼내서 복사해주는 방법과 여러 메서드를 사용하는 방법이 있음
// 깊은 복사
int[] a = { 1, 2, 3, 4 };
int[] b = new int[a.length];
for (int i = 0; i < a.length; i++) {
b[i] = a[i]; // 깊은 복사
}
b[0] = 3; // b 배열의 0번째 순번값을 3으로 수정했습니다. (1 -> 3)
System.out.println(a[0]); // 출력 1 <- 깊은 복사를 했기때문에 a 배열은 그대로 입니다.
// 깊은 복사 메서드
// 1. clone() 메서드
int[] a = { 1, 2, 3, 4 };
int[] b = a.clone(); // 가장 간단한 방법입니다.
// 하지만, clone() 메서드는 2차원이상 배열에서는 얕은 복사로 동작합니다!!
// 깊은 복사 메서드
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
// 2. Arrays.copyOf() 메서드
int[] a = { 1, 2, 3, 4 };
int[] b = Arrays.copyOf(a, a.length); // 배열과 함께 length값도 같이 넣어줍니다.
}
}
- String 배열
- 선언, 생성, 초기화
ㄴ String 배열 선언과 생성
// String 배열을 아래와 같이 선언과 생성할 수 있습니다.
String[] stringArray = new String[3];
ㄴ 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"};
ㄴ String 기능 활용(= char 배열)
# 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으로 복사해서 반환. |
// String 기능 활용하기
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 으로 변환
- 다차원 배열
- 선언 : int [ ] [ ] array , int array[ ] [ ], int[ ] array[ ]
- 생성: int[ ] [ ] array = new int [ ] [ ];
- 초기화 2가지 방법
1. 중괄호를 사용해 선언과 동시에 초기화
int[][] array = {
{1, 2, 3},
{4, 5, 6}
};
2. 선언/생성 이후 반복문을 통해 초기화
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;
}
}
- 가변 배열
- Java에서는 2차원 배열을 생성할 때 열의 길이를 생략하여 행마다 다른 길이의 배열을 요소로 저장할 수 있음
- 행마다 다른 길이의 배열을 저장할 수 있는 배열을 가변 배열이라고 함
// 가변 배열
// 선언 및 초기화
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차원 배열 조회
int[][] array = {
{10, 20, 30},
{10, 20, 30, 40},
{10, 20}
};
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 인덱스 순회
}
}
// 출력
10
20
30
10
20
30
40
10
20// 최대값 구하기
int[] arr = { 3, 2, 1, 5, 1 };
// 최대값 초기값 세팅
int max = arr[0];
// 최대값 구하기
for (int num : arr) {
if (num > max) { // 반복문 돌면서 나(max)보다 값이 작으면 저장
max = num;
}
}
// 최대값 5 출력
System.out.println(max);
///////////////////////////////////
// 최소값 구하기
int[] arr = { 3, 2, 1, 5, 1 };
// 최소값 초기값 세팅
int min = arr[0];
// 최소값 구하기
for (int num : arr) {
if (num < min) { // 반복문 돌면서 나(min)보다 값이 작으면 저장
min = num;
}
}
// 최소값 1 출력
System.out.println(min);
- 컬렉션
- 종류 : List, Queue, Set, Map
- Collection은 기본형 변수가 아닌 참조형 변수를 저장
- List : 순서가 있는 데이터의 집합(데이터 중복 허용, 배열과 비슷)
- ArrayList
ㄴ 배열(Array)처럼 일렬로 데이터를 저장하고 조회하여 순번값(인덱스)로 값을 하나씩 조회할 수 있음
ㄴ 배열처럼 크기가 정해져있지않고 필요할때마다 크기가 점점 더 늘어남
ㄴ 기능
# 선언 : ArrayList<Integer> intList 형태로 선언
# 생성 : new ArrayList<Integer>( ); 형태로 생성
# 초기화 : 사이즈를 지정하는 것이 없기 때문에 초기화가 필요 없음
# 값 추가 : intList.add( {추가할 값} ) 형태로 값을 추가
# 값 수정 : intList.set( {수정할 순번}, {수정할 값} ) 형태로 값을 수정
# 값 삭제 : intList.remove( {삭제할 순번} ) 형태로 값을 삭제
# 전체 출력 : intList.toString() 형태로 전체 값을 대괄호 [ ]로 묶어서 출력
# 전체 제거 : intList.clear() 형태로 전체 값을 삭제
* Array와 ArrayList의 차이점
- 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()); // [] 출력
}
}
- LinkedList
ㄴ 기본적인 기능은 ArrayList와 동일하지만 LinkedList는 값을 나누어 담기 때문에 모든 값을 조회하는 속도가 느림
ㄴ 그러나 값을 중간에 추가하거나 삭제할 때에는 속도가 빠름
ㄴ 기능
# 선언 : LinkedList<Integer> LinkedList 형태로 선언
# 생성 : new LinkedList<Integer>(); 형태로 생성
# 초기화 : 사이지를 지정하는 것이 없기 때문에 초기화가 필요 없음
# 값 추가 : linkedList.add( {추가할 값} ) 형태로 값을 추가
# 값 중간에 추가 : linkedList.add( {추가할 순번}, {추가할 값} ) 형태로 값을 중간에 추가
# 값 수정 : linkedList.set( {수정할 순번}, {수정할 값} ) 형태로 값을 수정
# 값 삭제 : linkedList.remove( {삭제할 순번} ) 형태로 값을 삭제
# 전체 출력 : linkedList.toString() 형태로 전체 값을 대괄호 [ ]로 묶어서 출력
# 전체 제거 : linkedList.clear() 형태로 전체 값을 삭제
// LinkedList
// (사용하기 위해선 import java.util.LinkedList; 를 추가해야합니다.)
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); // [] 출력
}
}
- Stack
ㄴ 값을 수직으로 쌓아놓고 넣었다가 빼서 조회하는 형식으로 데이터를 관리
ㄴ 나중에 들어간 것이 가장 먼저 나온다(Last-In-First-out)
ㄴ 기능
# 선언 : Stack<Integer> intStack 형태로 선언
# 생성 : new Stack<Integer>(); 형태로 생성
# 추가 : intStack.push({추가할 값}) 형태로 값을 추가
# 조회 : intStack.peek() 형태로 맨 위값을 조회
# 꺼내기 : intStack.pop() 형태로 맨 위값을 꺼냄
// Stack
// (사용하기 위해선 import java.util.Stack; 를 추가해야합니다.)
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()) { // 다 지워질때까지 출력
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 : 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합
- First In First Out : 먼저 들어간 순서대로 값을 조회할 수 있음
- 따라서 기능(add( )), 조회(peek() ), 꺼내는(poll( )) 기능만 존재
- 생성자가 없는 껍데기라서 바로 생성할 수 없음(껍데기 = 인터페이스)
- 생성자가 존재하는 클래스인 LinkedList 를 사용하여 Queue를 생성해서 받을 수 있음
- 기능
ㄴ 선언 : Queue<Integer> intQueue 형태로 선언
ㄴ 생성 : new LinkedList<Integer>(); 형태로 생성
ㄴ 추가 : intQueue.add( {추가할 값} ) 형태로 값을 맨 위에 추가
ㄴ 조회 : intQueue.peek() 형태로 맨 아래값을 조회
ㄴ 꺼내기 : intQueue.poll() 형태로 맨 아래값을 꺼냄(꺼내고나면 삭제됨)
// 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 출력 (마지막 남은거 하나)
}
}
}
- Set : 순서가 없는 데이터의 집합(데이터 중복 허용 안함) - 순서없고 중복없는 배열
- 순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지할 수 있음
- Set은 그냥 Set으로 쓸수도 있지만 HashSet, TreeSet 등으로 응용하여 사용할 수 있음
- 생성자가 없는 껍데기라서 바로 생성할 수 없음(껍데기 = 인터페이스)
- 생성자가 존재하는 클래스인 HashSet를 사용하여 Set를 생성해서 받을 수 있음
- 기능
ㄴ 선언 : Set<Integer> intSet 형태로 선언
ㄴ 생성 : new HashSet<Integer>(); 형태로 생성
ㄴ 추가 : intSet.add( {추가할 값} ) 형태로 값을 맨 위로 추가
ㄴ 조회 : intSet.get( {조회할 순번} ) 형태로 순번에 있는 값을 조회
ㄴ 삭제 : intSet.remove( {삭제할 값} ) 형태로 삭제할 값을 직접 지정
ㄴ 포함확인 : intSet.contains( {포함확인 할 값} ) 형태로 해당값이 포함되어있는지 boolean 값으로 응답
- HashSet : 가장 빠르며 순서를 전허 예측할 수 없음
- TreeSet : 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
- LinkedHashSet : 추가된 순서 또는 가장 최근에 접근한 순서대로 접근 가능
// 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 출력
}
}
}
- 유지할 점
-
- 문제점
- - 노력할 점
-
'개발공부 > Java／Spring' 카테고리의 다른 글
| [TroubleShooting] Unsupported class file major version 64 & IntelliJ h2 연결 (0) | 2023.04.14 |
|---|---|
| 객체지향 & JVM (1) | 2023.04.09 |
| 내가 정리한 Java의 기초(1) (0) | 2023.04.04 |
| 토이프로젝트 UBS (0) | 2023.03.30 |
| 토이프로젝트 1일차 (0) | 2023.03.27 |
댓글