...
배열 자료형
배열(array)은 프로그래밍에서 필수로 등장하는 요소이며 정말 자주 쓰이는 자료형이다.
배열은 하나의 블록안에 여러 데이터들을 모아 집합시켜 저장함으로써 데이터를 구조적으로 다루는데 도와준다. 배열을 구성하는 각각의 값을 배열 요소(element)라고 하며, 배열에서의 위치를 가리키는 숫자를 인덱스(index)라고 칭한다.
배열 선언 & 초기화
자바(Java)의 배열은 코드를 보면 볼 수 있듯이 배열을 선언할때 미리 공간의 갯수(길이)를 지정해야 한다. 이는 곧 공간의 제약이 생겨 데이터를 저장하는데 애로사항이 있을 수 있다는 뜻이기도 하다.
자바스크립트나 파이썬의 배열 같은경우 유기적으로 늘어나는 특성 때문에 배열에 데이터를 저장하는데 있어 공간을 따진적이 없었기 때문에 적응이 힘들 수도 있다. 하지만 사실 자바스크립트의 배열도 공간의 제약이 있으며 단지 프로그래밍 하기 편하게 내부적으로 배열을 늘였다 줄였다 자동으로 해주기 때문에 못느끼는 것일 뿐이다. 단지 자바는 수동으로 해줘야 한다는 차이점만 있다.
이처럼 배열의 길이는 고정되어 있게 프로그래밍 상에서 설계 되었기 때문에 만일 배열의 길이를 처음부터 지정하지 않으면 컴파일 오류가 발생하게 된다. 그리고 배열의 타입(int)도 지정해 주어 배열에 저장할 데이터의 자료형을 명시해 주어야 한다. 이렇게 생성한 배열은 인덱스(index) 번호를 통해 배열을 접근 할 수 있다.
// int 형 배열 선언 & 초기화
int[] score = new int[5]; // int 타입의 값 5개가 저장될 빈 공간 생성
score[0] = 10; // 각 빈공간에 값을 초기화
score[1] = 20;
score[2] = 30;
score[3] = 40;
score[4] = 50;
// for문으로 배열을 순차적으로 순회에 값을 넣어주는 방법도 있다.
for(int i = 0 ; i < score.length ; i++){
number[i] = i * 10;
}
// 처음부터 선언 + 초기화를 한번에 진행
int[] score2 = {10, 20, 30, 40, 50};// String 형 배열 선언 & 초기화
String[] name = new String[3]; // String 타입의 값 3개가 저장될 빈 공간 생성
name[0] = "wi"; // 각 빈공간에 값을 초기화
name[1] = "kim";
name[2] = "park"
// 처음부터 선언 + 초기화를 한번에 진행
String[] strArr2 = {"wi", "kim", "park"};
배열 출력
프로그래밍 도중 만일 내가 만든 배열의 상태를 보기 위해 콘솔에 배열 내용물을 출력하고 싶을 때 어떻게 할까?
지금까지 변수를 출력 하듯이 System.out.println() 으로 배열 변수를 출력해보면 이상한 값이 출력되게 된다.
int[] iArr = {100, 95, 80, 70, 60};
System.out.println(iArr); // [I@7ad041f3
// [I : 배열 integer
// @7ad041f3 : 주소값사실 이 값은 메모리에 있는 배열의 주소값(타입@주소)을 가리키는 것이다.
자바스크립트 처럼 console.log() 로 간편하게 출력하면 좋겠지만 자바의 언어 설계 상 어쩔수 없다.
따라서 for 문을 이용해서 배열 각 원소들을 순회하여 출력하도록 하드코딩 해주거나, 아니면 자바에서 제공해주는 Arrays.toString() 메서드를 이용해서 배열을 문자열 형식으로 만들어 출력할 수도 있다.
Arrays 클래스는 프로그램을 개발하는 데 사용할 수 있는 유용한 유틸리티 클래스가 다수 포함되어 있는 java.util 패키지에 속해 있으며, 배열을 다루기 위한 다양한 메소드가 포함되어 있다.
Arrays 클래스의 모든 메소드는 static 메소드이므로 따로 객체를 생성하지 않고도 바로 사용할 수 있는 특징이 있다.
다만 Arrays 클래스의 메소드를 사용하고 싶다면 상단에 반드시 import 문으로 java.util 패키지를 불러와야 한다.
import java.util.Arrays; // Arrays.toString()을 사용하기 위한 import
class Test{
public static void main(String[] args) {
int[] iArr = {100, 95, 80, 70, 60};
// 루프문으로 직접 배열 원소 출력
for(int i = 0 ; i < iArr.length; i++){
System.out.println(iArr[i]);
}
// Arrays.toString() 메서드 사용하여 심플하게 바로 출력
System.out.println(Arrays.toString(iArr)); // [100, 95, 80, 70, 60]
}
}다만char형 배열은 예외인데, 문자 같은 경우println으로 바로 출력이 가능하다.
배열 복사
앞서 배열은 고정된 크기라고 했었다.
그런데 배열을 만들고 나서 데이터를 적재하다보니 배열 공간이 부족해질수 있는 상황이 올 수 도 있다.
그러면 배열을 확장 시켜주어야 하는데 어떻게 해결을 해야 할까?
배열은 한번 선언되고 나면 공간 자체를 직접 늘릴수는 없기 때문에 간접적인 방법으로 배열을 확장해야 된다.
따로 공간이 큰 배열을 새로 만들어 주고 기존의 배열의 내용을 새로 만든 배열에 복사하는 식으로 하여 배열을 간접적으로 확장하는 방법이다.
다만, 이러한 작업은 비용이 많이 들기 때문에 처음부터 배열의 길이를 넉넉하게 잡는 것이 베스트이다.
배열을 복사하는 방법은 for문으로 순회해 직접 한땀 한땀 복사하도록 지정해주거나, 자바에서 제공해주는 System.arraycopy() 메서드나 Arrays.copyOf() 메서드를 사용하면 된다.
Arrays.copyOf는System.arraycopy를 래핑한 함수일뿐이다. 즉, 둘이 동일하다고 보면된다.
다만Arrays.copyOf가 좀더 직관적이라 이쪽이 더 많이 사용되는 편이다.
import java.util.Arrays;
class Test{
public static void main(String[] args) {
int[] arr1 = {10, 20, 30, 40, 50};
int[] arr2 = new int[arr1.length * 2]; // 우선 초기 배열보다 길이가 두배인 새로운 배열을 선언
// 루프문으로 순회하여 복사
for(int i = 0 ; i < arr1.length ; i++) { // arr1의 길이만큼 반복문 실행
arr2[i] = arr1[i]; // arr1배열의 원소값을 순회하며 arr2배열에 저장
}
arr1 = arr2; // 원래의 배열을 가리키고있던 참조변수 arr1이 새로 복사된 arr2 배열을 가리키도록 한다.
}
}class Test{
public static void main(String[] args) {
int[] arr1 = {10, 20, 30, 40, 50};
int[] arr2 = new int[arr1.length * 2]; // 우선 초기 배열보다 길이가 두배인 새로운 배열을 선언
// System.arraycopy() 메서드 사용
System.arraycopy(arr1, 0, arr2, 0, arr1.length); // arr1의 index 0부터 arr1.length 전체 길이 만큼 arr2의 index 0 부터 붙여넣는다.
/*
- 첫번째 인자 : 복사할 배열
- 두번째 인자 : 복사를 시작할 배열의 위치
- 세번째 인자 : 붙여넣을 배열
- 네번째 인자 : 복사된 배열값들이 붙여질 시작위치 (차례대로 붙여 넣어진다)
- 다섯번째 인자 : 지정된 길이만큼 값들이 복사된다.
*/
}
}import java.util.Arrays;
class Test{
public static void main(String[] args) {
int[] arr1 = {10, 20, 30, 40, 50};
int[] arr2 = new int[arr1.length * 2]; // 우선 초기 배열보다 길이가 두배인 새로운 배열을 선언
// Array.copyOf() 메서드 사용
arr2 = Arrays.copyOf(arr1, arr1.length); // arr1 배열을 arr1.length 전체 길이만큼 전체 복사해서 arr2에 할당
System.out.println(Arrays.toString(arr2)); // [10, 20, 30, 40, 50]
arr2 = Arrays.copyOfRange(arr1, 1, 3); // 배열요소 시작점, 끝점 지정. 1, 2 만 복사해서 반환
System.out.println(Arrays.toString(arr2)); // [10, 20, 30, 40, 50]
}
}for문 보다 메서드를 이용하는게 거의 두배 정도로 빠르게 복사한다고 한다
배열 정렬
Arrays.sort() 메서드를 이용해 배열을 정렬할 수 있다.
이때 정렬된 배열을 새로 반환하는 것이 아닌, 자기 자신 배열을 정렬시킨다.
import java.util.Arrays;
class Test{
public static void main(String[] args) {
int[] arr = { 3,2,0,1,4 };
// 오름차순 정렬
Arrays.sort(arr); // 자기 자신 배열을 정렬 시킴 (정렬된 배열을 반환하는 것이 아니다)
System.out.println(Arrays.toString(arr)); // [0,1,2,3,4]
// 내림차순 정렬
Arrays.sort(arr, Collections.reverseOrder()); // 배열을 내림차순으로 정렬할 때는 Collections 클래스의 reverseOrder() 함수를 사용
System.out.println(Arrays.toString(arr)); // [4,3,2,1,0]
// 배열 일부부만 정렬
int[] arr = { 3,2,0,1,4 };
Arrays.sort(arr, 0, 3); // 배열 요소 0, 1, 2 만 정렬
System.out.println(Arrays.toString(arr)); // [0, 2, 3, 1, 4]
}
}
배열 비교
만일 두개의 배열의 구성이 같은지 같지 않은지 비교하기 위해서 일일히 for문으로 순회하여 원소를 비교하는 식으로도 구현을 할 수 있지만, 역시 Arrays.equals() 메소드를 이용하면 간단히 처리할 수 있다.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[] arr1 = { "홍길동", "임꺽정", "박혁거세", "주몽", "고담덕" };
String[] arr2 = { "홍길동", "임꺽정", "박혁거세", "주몽", "고담덕" };
String[] arr3 = { "홍길동", "임꺽정", "박혁거세", "주몽" };
System.out.println("arr1 == arr2 : " + Arrays.equals(arr1, arr2)); // arr1 == arr2 : true
System.out.println("arr1 == arr3 : " + Arrays.equals(arr1, arr3)); // arr1 == arr3 : false
}
}다차원 배열
다차원 배열이란 2차원 이상의 배열을 의미하며, 배열 요소로 또 다른 배열을 가지는 배열을 의미한다고 보면 된다.
간단히 말하자면, 1차원 배열은 배열 요소로 '단일값'을 가지는 배열이라면, 2차원 배열은 배열 요소로 '1차원 배열'을 가지는 배열이며, 3차원 배열은 배열 요소로 2차원 배열을 가지는 배열 인 식으로 순차적으로 생각하면 된다.
메모리의 용량이 허용하는 한 차원의 제한은 없지만 주로 1차원과 2차원 배열이 많이 사용된다.
2차원 배열 생성
2차원 배열은 어렵게 생각할 필요없이 엑셀과 같은 테이블 형태의 데이터를 담기위해 사용하는 배열이라고 보면 된다.
테이블 형태의 데이터는 행(row)과 열(column)로 구성되어 있다.
즉, 행(row)은 곧 1차원 배열이며, 이 행이 여러개 있으면 곧 열(colums)이 되며 2차원 배열이 되는 것이다.
2차원 배열 선언법도 간단하게 생각하면 된다.
1차원 배열은 대괄호 [] 를 1번만 썼다면, 2차원은 대괄호 [][] 를 2번 쓰면 된다.
예를 들어 new int[4][3] 첫번째 배열 길이 [4] 는 세로(열) 갯수를 나타내며 두번째 배열 길이 [3] 은 가로(행) 갯수를 나타내는 것으로 보면 된다.
즉, 길이가 3인 1차원 배열이 총 4개 존재하여 4x3 정방 행렬이 구성되는 것이 2차원 배열인 것이다.
// 배열을 선언하고 따로따로 데이터를 적재
int[][] score = new int[4][3];
score[0][1] = 10;
score[0][1] = 20;
...
score[1][0] = 10;
score[1][1] = 20;
...
score[2][0] = 10;
score[2][1] = 20;
...
score[3][0] = 10;
score[3][1] = 20;
// 혹은 한번에 2차원 배열을 지정하여 선언할 수 있다.
int[][] arr2 = {
{10,20,30},
{10,20,30},
{10,20,30},
{10,20,30}
}
2차원 배열 출력
2차원 배열 출력도 1차원 같이 for문으로 배열을 순회해 출력하도록 지정하면 된다.
int[][] arr2 = {
{10,20,30},
{40,50,60},
{70,80,90},
{100,200,300}
};
for(int i = 0 ; i < number.length ; i++) { // 먼저 열 부분을 순회하고
for(int j = 0 ; j < number[i].length ; j++) { // 행 부분을 순회하며 각 원소를 출력
System.out.print(number[i][j]);
}
}다만 성능상 중첩 for문을 이용하기 보단, 위에서 1차원 배열을 Arrays.toString() 메서드를 통해 루프문 없이 한방에 출력했던 것 처럼, Arrays.deeptoString() 메서드를 통해 2차원 배열을 한방에 출력 할 수 있다.
// 1차원 배열 한방 출력
int[] arr = {0,1,2,3,4};
System.out.println(Arrays.toString(arr)); // [0, 1, 2, 3, 4]
// 2차원 배열 한방 출력
int[][] arr2 = {
{10,20,30},
{40,50,60},
{70,80,90},
{100,200,300}
};
System.out.println(Arrays.deepToString(arr2)); // [[10, 20, 30], [40, 50, 60], [70, 80, 90], [100, 200, 300]]
2차원 배열 비교
1차원 배열을 비교할때 Arrays.equals() 메소드를 사용했다면, 2차원 배열은 Arrays.deepEquals() 메소드를 사용하면 된다.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[][] arr1 = {
{ "홍길동", "임꺽정" },
{ "박혁거세", "주몽", "고담덕" }
};
String[][] arr2 = {
{ "홍길동", "임꺽정" },
{ "박혁거세", "주몽", "고담덕" }
};
String[][] arr3 = {
{ "홍길동" },
{ "주몽", "고담덕" }
};
System.out.println("arr1 == arr2 : " + Arrays.deepEquals(arr1, arr2)); // arr1 == arr2 : true
System.out.println("arr1 == arr3 : " + Arrays.deepEquals(arr1, arr3)); // arr1 == arr3 : false
}
}
가변 배열
2차원 배열이 테이블 형태라고 해서 반드시 가로와 세로가 똑같은 정방 행렬이 필요가 없다.
자바에서의 다차원 배열은 마지막 차수의 길이를 다르게 지정할 수 있기 때문에, 각 요소로 들어가는 1차원 배열의 길이를 각기 다르게 해도 2차원 배열 데이터를 생성하는데 문제가 없다.
이를 가변 배열이라고 불리운다.
int[][] score = {
{100, 100, 100, 100},
{20, 20, 20},
{30, 30},
{40, 40},
{50, 50, 50}
}
객체 배열
보통 배열에 정수나 문자를 적재하여 꺼내 써왔을 것인데, 객체 자체도 배열에 넣어 사용할수 있다.
객체 역시 하나의 자료형으로 취급되기 때문이다.
// myObject 클래스
class myObject{
int id;
String description;
myObject(int id, String description) {
this.id = id;
this.description = description;
}
}
// myObject 클래스를 담을 수 있는 공간 3개 크기의 객체 배열 생성
myObject[] arrayObj = new myObject[3];
// 객체 배열 초기화
arrayObj[0] = new myObject(101, "first");
arrayObj[1] = new myObject(102, "second");
arrayObj[2] = new myObject(103, "third");
// 객체 배열 사용
System.out.println(arrayObj[0].description); // "first array, John"
/* ************************************ */
// 객체 배열 선언 + 초기화 한번에
myObject[] arrayObj2 = {
new myObject(101, "first"),
new myObject(101, "second"),
new myObject(101, "third")
};먼저 myObject[] arrayObj = new myObject[3] 로 myObject 타입의 배열을 생성해준다.
그리고 각 배열 공간에 new 생성자로 객체를 만들어 할당해 준다.
그러면 비로소 배열에 객체가 적재가 되어 객체 배열로서 사용을 할 수 있는 것이다.
객체 배열 복사
기본 타입의 배열일 경우 Arrays.copyOf 나 Arrays.copyOfRange 메서드를 통하여 간단하게 배열 복사가 가능했다.
객체로 이루어진 배열도 마찬가지로 가능하지만, 여기서 조심해야 할 점이 있다.
배열 자체는 복사가 되지만, 배열 내용물 객체는 참조 복사(주소 복사)가 되기 때문이다.
즉, 배열 내용물은 여전히 같은 객체 주소를 가리키기 때문에 객체도 복사 되었는 줄 알고 복사한 객체의 멤버를 변경하면 복사된 멤버에 객체도 변경되는 꼴이 된다.
class myObject{
int id;
String description;
myObject(int id, String description) {
this.id = id;
this.description = description;
}
}
myObject[] arrayObj = {
new myObject(101, "first"),
new myObject(101, "second"),
new myObject(101, "third")
};
System.out.println(Arrays.toString(arrayObj)); // [main$1myObject@251a69d7, main$1myObject@7344699f, main$1myObject@6b95977]
myObject[] arrayObj2; // 복사할 배열
arrayObj2 = arrayObj.clone(); // 배열을 복사해도 내용물 객체의 주소는 똑같다.
System.out.println(Arrays.toString(arrayObj2)); // [main$1myObject@251a69d7, main$1myObject@7344699f, main$1myObject@6b95977]
System.out.println(arrayObj[0].id); // 101
arrayObj2[0].id = 999; // 복사한 arrayObj2의 첫째 객체의 멤버를 변경
System.out.println(arrayObj2[0].id); // 999
System.out.println(arrayObj[0].id); // 999 : arrayObj1 의 첫째 겍체의 멤버도 변경됨
따라서 완전한 깊은 복사를 이행하기 위해서는 어쩔수 없이 for문으로 수동으로 해주는 수 밖에 없다.
class myObject{
int id;
String description;
myObject(int id, String description) {
this.id = id;
this.description = description;
}
}
myObject[] arrayObj = {
new myObject(101, "first"),
new myObject(102, "second"),
new myObject(103, "third")
};
System.out.println(Arrays.toString(arrayObj)); // [main$1myObject@251a69d7, main$1myObject@7344699f, main$1myObject@6b95977]
myObject[] arrayObj2 = new myObject[3];
for(int i = 0; i < arrayObj.length; i++) {
arrayObj2[i] = new myObject(arrayObj[i].id, arrayObj[i].description);
}
// 배열 내용물 객체의 @주소가 달라짐을 볼 수 있다.
System.out.println(Arrays.toString(arrayObj2)); // [main$1myObject@7e9e5f8a, main$1myObject@8bcc55f, main$1myObject@58644d46]
System.out.println(arrayObj[0].id); // 101
arrayObj2[0].id = 999; // 복사한 arrayObj2의 첫째 객체의 멤버를 변경
System.out.println(arrayObj2[0].id); // 999
System.out.println(arrayObj[0].id); // 101
객체 배열 정렬
다음과 같이 이름과 나이 데이터를 갖는 User 객체 배열이 있다. 이 배열 내의 객체들을 정렬하기 위해서는 정렬 기준이 필요한데 name 을 이용해 이름순으로 정렬할 수도 있고, age 를 이용해 나이순으로 정렬할 수 도 있다.
import java.util.*;
public class main {
public static void main(String[] args) {
class User {
String name;
int age;
User(String name, int price) {
this.name = name;
this.price = price;
}
}
User[] users = {
new User("홍길동", 32),
new User("김춘추", 64),
new User("임꺽정", 48),
new User("박혁거세", 14),
}
}
}객체 배열을 정렬하기 위해서는 꽤나 고급 지식들이 요구된다. 이 포스팅에서는 Comparable 인터페이스 와 Comparator 클래스를 이용한 객체 배열 정렬 방법을 간단히 소개해본다.
Comparable 사용
자바에서는 같은 타입의 인스턴스를 서로 비교해야 할때 Comparable 인터페이스를 구현해서 compareTo() 메소드를 오버라이딩 정의하고 사용한다.
기본 타입은 물론 Boolean을 제외한 래퍼 클래스나 String, Time, Date와 같은 클래스의 인스턴스는 모두 정렬 가능하다.
import java.util.Arrays;
public class main {
public static void main(String[] args) {
// 클래스에 Comparable<> 인터페이스를 구현한다
class User implements Comparable<User> {
String name;
int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(User user) {
// 비교 로직을 구현
if (this.age < user.age) {
return -1;
} else if (this.age == user.age) {
return 0;
} else {
return 1;
}
}
}
User[] users = {
new User("홍길동", 32),
new User("김춘추", 64),
new User("임꺽정", 48),
new User("박혁거세", 14),
};
Arrays.sort(users); // 나이순 정렬
// Arrays.sort(users, Collections.reverseOrder()); // 역순 정렬
for (User u : users) { // 출력
System.out.println(u.name + " " + u.age + "세");
}
}
}박혁거세 14세
홍길동 32세
임꺽정 48세
김춘추 64세
Comparator 사용
Comparator 인터페이스 도 Comparable 인터페이스와 같이 객체를 정렬하는 데 사용되는 인터페이스 이다.
다만 익명 객체를 이용해 좀더 유기적으로 다양하게 속성을 받아 정렬할 수 있어서 좀 더 간편하게 객체 비교 정렬이 가능하다.
import java.util.Arrays;
import java.util.Comparator; // Comparator 클래스를 불러온다
public class main {
public static void main(String[] args) {
class User {
String name;
int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
}
User[] users = {
new User("홍길동", 32),
new User("김춘추", 64),
new User("임꺽정", 48),
new User("박혁거세", 14),
};
// Arrays.sort(배열, new Comparator<>() { ... });
Arrays.sort(users, new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
return Integer.compare(u1.age, u2.age); // Integer 클래스에 정의된 compare 함수로 두 가격 정수 원시값을 비교
}
});
// java8 람다식으로 다음과 같이 축약이 가능
Arrays.sort(users, (u1, u2) -> Integer.compare(u1.age, u2.age)); // 나이순 정렬
// 출력
for (User u : users) {
System.out.println(u.name + " " + u.age + "세");
}
}
}박혁거세 14세
홍길동 32세
임꺽정 48세
김춘추 64세
만일 나이순이 아닌 이름(문자열)순으로 정렬하려면 compare() 대신 compareTo() 메서드로 가능하다.
import java.util.Arrays;
import java.util.Comparator; // Comparator 클래스를 불러온다
public class main {
public static void main(String[] args) {
class User {
String name;
int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
}
User[] users = {
new User("홍길동", 32),
new User("김춘추", 64),
new User("임꺽정", 48),
new User("박혁거세", 14),
};
// Arrays.sort(배열, new Comparator<>() { ... });
Arrays.sort(users, new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
return u1.name.compareTo(u2.name);
}
});
// java8 람다식으로 다음과 같이 축약이 가능
Arrays.sort(users, (u1, u2) -> u1.name.compareTo(u2.name)); // 이름순 정렬
// 출력
for (User u : users) {
System.out.println(u.name + " " + u.age + "세");
}
}
}김춘추 64세
박혁거세 14세
임꺽정 48세
홍길동 32세
여러 조건 비교 (comparing / thenComparing)
만약 나이순으로 정렬했는데 나이가 같은 사람이 있을 경우 추가적으로 이름순으로 정렬해줄 필요가 있을 것이다.
즉, 객체의 여러 속성을 이용하여 정렬하기 위해 Comparator의 comparing() 과 thenComparing() 을 이용해 체이닝하여 구현이 가능하다.
이때 객체의 속성을 가져올때 getter / setter을 이용해 가져와주어야 한다.
import java.util.Arrays;
import java.util.Comparator;
public class main {
public static void main(String[] args) {
class User {
private String name;
private int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return this.age;
}
public String getName() {
return this.name;
}
}
User[] users = {
new User("홍길동", 30),
new User("김춘추", 60),
new User("임꺽정", 30),
new User("김좌진", 20),
new User("주몽", 50),
new User("심사임당", 30),
};
Arrays.sort(users, Comparator.comparing(User::getAge)); // 나이순 정렬
for (User u : users) { System.out.println(u.name + " " + u.age + "세"); } // 출력
System.out.println("\n");
Arrays.sort(users, Comparator.comparing(User::getName)); // 이름순 정렬
for (User u : users) { System.out.println(u.name + " " + u.age + "세"); }
System.out.println("\n");
Arrays.sort(users, Comparator.comparing(User::getAge).thenComparing(User::getName)); // 먼저 나이순 정렬하고 나이가 같으면 따로 이름순 정렬
for (User u : users) { System.out.println(u.name + " " + u.age + "세"); }
}
}김좌진 20세
홍길동 30세
임꺽정 30세
심사임당 30세
주몽 50세
김춘추 60세
김좌진 20세
김춘추 60세
심사임당 30세
임꺽정 30세
주몽 50세
홍길동 30세
김좌진 20세
심사임당 30세
임꺽정 30세
홍길동 30세
주몽 50세
김춘추 60세# 참고자료
https://www.youtube.com/watch?v=dYXpWCdF_k4&list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp&index=48
https://smoothiecoding.kr/%ec%9e%90%eb%b0%94-%ea%b0%9d%ec%b2%b4-%eb%b0%b0%ec%97%b4/?_ga=2.93147037.1664097096.1662455406-1481525809.1661302656
https://choichumji.tistory.com/119
이 글이 좋으셨다면 구독 & 좋아요
여러분의 구독과 좋아요는
저자에게 큰 힘이 됩니다.
