Arrays
- Arrays 클래스는 배열을 다루기 편리한 메서드(static) 제공
1. 배열의 출력 - toString( )
2. 배열의 복사 - copyOf( ), copyOfRange( )
-> copyOf( )는 배열 전체를, copyOfRange는 배열의 일부를 복사해서 새로운 배열을 만들어 반환!
3. 배열 채우기 - fill( ), setAll( )
-> 배열의 모든 요소를 지정된 값으로 채운다.
-> setAll은 배열을 채우는데 사용할 함수형 인터페이스를 매개변수로 받는다.
-> 두 번째 코드는 람다식으로
4. 배열의 정렬과 검색 – sort( ), binarySearch( )
-> 이진탐색(binarySearch)은 정렬(sort)되어 있을 때만 사용 가능!
5. 다차원 배열의 출력 – deepToString( )
6. 다차원 배열의 비교 - deepEquals( )
7. 배열을 List로 변환 – asList(Object…, a)
-> 배열을 List에 담아서 반환. 매개변수의 타입이 가변인수라서 배열 생성 없이 저장할 요소들만 나열하는 것도 가능!(가변: 개수가 정해져 있지 않다.)
-> List의 특징은 읽기전용이다. 반환한 List의 크기를 변경할 수 없다.(추가 또는 삭제 불가능, 저장된 내용을 변경 가능)
-> 만약 크기를 변경하고 싶다면, list를 ArrayList 생성자에 넣어서 만들어야 함(새로운 ArrayList 생성!)
예제1)
import java.util.Arrays;
public class Ex11_6 {
public static void main(String[] args) {
int[] arr = {0,1,2,3,4};
int[][] arr2D = {{11,12,13}, {21,22,23}};
System.out.println("arr="+Arrays.toString(arr)); // arr=[0, 1, 2, 3, 4]
System.out.println("arr2D="+Arrays.deepToString(arr2D)); // arr2D=[[11, 12, 13], [21, 22, 23]]
int[] arr2 = Arrays.copyOf(arr, arr.length);
int[] arr3 = Arrays.copyOf(arr, 3);
int[] arr4 = Arrays.copyOf(arr, 7);
int[] arr5 = Arrays.copyOfRange(arr, 2, 4);
int[] arr6 = Arrays.copyOfRange(arr, 0, 7);
System.out.println("arr2="+Arrays.toString(arr2)); // arr2=[0, 1, 2, 3, 4]
System.out.println("arr3="+Arrays.toString(arr3)); // arr3=[0, 1, 2]
System.out.println("arr4="+Arrays.toString(arr4)); // arr4=[0, 1, 2, 3, 4, 0, 0]
System.out.println("arr5="+Arrays.toString(arr5)); // arr5=[2, 3]
System.out.println("arr6="+Arrays.toString(arr6)); // arr6=[0, 1, 2, 3, 4, 0, 0]
int[] arr7 = new int[5];
Arrays.fill(arr7, 9);
System.out.println(Arrays.toString(arr7)); // [9, 9, 9, 9, 9]
// Lambda Expression(람다식)
Arrays.setAll(arr7, i -> (int)(Math.random()*6)+1);
System.out.println(Arrays.toString(arr7));
for(int i:arr7) { // (1) 향상된 for문
char[] graph = new char[i];
Arrays.fill(graph, '*'); // (2)
System.out.println(new String(graph)+i); //(3)
}
String[][] str2D = new String[][] {{"aaa","bbb"},{"AAA","BBB"}};
String[][] str2D2 = new String[][] {{"aaa","bbb"},{"AAA","BBB"}};
System.out.println(Arrays.deepEquals(str2D, str2D2)); // true
char[] chArr = { 'A', 'D', 'C', 'B', 'E' };
System.out.println("chArr="+Arrays.toString(chArr)); // chArr=[A, D, C, B, E]
System.out.println("chArr="+Arrays.binarySearch(chArr, 'B')); // chArr=-2
System.out.println("== After sorting ==");
Arrays.sort(chArr); // binarySearch학기전에는 반드시 정렬!
System.out.println(Arrays.toString(chArr)); // [A, B, C, D, E]
System.out.println("chArr="+Arrays.binarySearch(chArr, 'B')); // chArr=1
}
}
(1) for(int i : arr7) -> 향상된 for문
기본 for문
for(int x=0;x<arr7.length;x++) {
int i = arr7[x];
char[] graph = new char[i];
Arrays.fill(graph, '*');
System.out.println(new String(graph)+i);
}
(2) i의 개수만큼 ‘*’을 생성 만약 arr7[3, 6, 3, 1, 1] 이면
char[3] 배열 생성! -> graph[ ]에 넣어주면 ***이 된다.
char[6] -> ******
char[3] -> ***
char[4] -> *
(3) 문자열 -> 문자배열, 문자배열 -> 문자열
String -> char[ ] : tocharArray( ) 문자열을 배열로 만들려면 tocharArray( )메서드 사용
char[ ] -> String : new String(char[ ]) 문자배열을 문자열로 만들려면 String 생성자 사용
Sysetem.out.println -> graph는 *, i는 숫자 à ***3
Comparator와 Comparable
- 객체 정렬에 필요한 메서드(정렬기준 제공)를 정의한 인터페이스
- Comparable을 구현한 클래스는 기본정렬이 가능함(오름차순)
| Comparable | Comparator |
| 기본 정렬기준을 구현하는 데 사용 (자기 자신과 매개변수를 비교한다.) compareTo( ) 메서드를 반드시 구현 사용 별도의 기준 대상 필요 xx |
기본 정렬기준 외에 다른 기준으로 정렬하고자 할 때 사용 (자기 자신이 아닌 두 매개변수 객체를 비교) compre( ) 메서드를 반드시 구현 별도의 기준 대상 필요 |
| java.lang.Comparable | java.util.Comparator; |
| 자바에서 제공되는 정렬이 가능한 클래스들은 모두 Comparable 인터페이스를 구현하고 있다. |
주로 익명클래스(new Comparator( ){ ... })로 사용되며 내림차순으로 정렬하는 드의 용도로 사용된다. |
- compare( )와 compareTo( )는 두 객체의 비교결과를 반환하도록 작성된다. 같으면 0 왼쪽이 크면 양수(+), 작으면 양수(-) ( 큰 값 - 작은 값 = 양수(+), 작은 값 - 큰 값 = 음수(-) )
- return 값이 양수이면 자리바꾸기!
- ex) 오름차순 일 때 7>5(자리 바꿈) / 내림차순 일 때 5<7 (자리바꿈)
- 정렬(Sort) 1) 두 대상 비교 2) 자리 바꿈
- Comparator 정의하기: Comparator<클래스타입> 클래스명 = new Comparator<클래스타입( )으로 정의, compare메서드를 오버라이드해서 사용한다. 클래스타입 비교대상 2개를 지역변수 o1, o2로 선언하고 return 값으로 음수, 0 양수를 반환
Comparable 사용 예제
1. 기본(오름차순)
import java.util.Arrays;
public class ComparableEx1 {
public static void main(String[] args) {
Student[] stu = new Student[3];
stu[0] = new Student("이자바", 283920);
stu[1] = new Student("김자바", 234932);
stu[2] = new Student("권자바", 304203);
Arrays.sort(stu);
for(Student s : stu)
System.out.println(s);
}
}
class Student implements Comparable<Student> {
String name;
int id;
public Student(String name, int id) {
this.name = name;
this.id = id;
}
public String toString() {
return "이름:" + name + " 학번:" + id;
}
// 학번을 기준으로 오름차순 정렬
public int compareTo(Student stu) {
return Integer.compare(id, stu.id);
}
}
이름:김자바 학번:234932
이름:이자바 학번:283920
이름:권자바 학번:304203
2. 내림차순(매개변수의 순서를 바꿔주면 된다.)
// 학번을 기준으로 내림차순 정렬
public int compareTo(Student stu) {
return Integer.compare(stu.id, id);
}이름:권자바 학번:304203
이름:이자바 학번:283920
이름:김자바 학번:234932
3. Integer.compare의 안에 내부 코드
// 오름차순 정렬
public int compareTo(Student stu) {
return this.id - stu.id;
}
// 내림차순 정렬
public int compareTo(Student stu) {
return stu.id-this.id;
}Comparator 사용 예제
- Comparator interface 구현체를 정의한 후 sort( )함수의 매개변수로 함께 넘기거나 익명클래스를 이용해 사용한다.
1. 나이 기준으로 오름차순
import java.util.Arrays;
import java.util.Comparator;
public class TheGreatestNum {
public static void main(String[] args) {
Student[] stu = new Student[3];
stu[0] = new Student("이자바", 283920, 20);
stu[1] = new Student("김자바", 234932, 24);
stu[2] = new Student("권자바", 304203, 22);
Comparator<Student> comp= new Comparator<Student>() {
public int compare(Student s1, Student s2) {
return Integer.compare(s1.age, s2.age); // 나이 오름차순
}
};
Arrays.sort(stu, comp);
for(Student s : stu)
System.out.println(s);
}
}
class Student {
String name;
int id;
int age;
public Student(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String toString() {
return "이름:" + name + " 학번:" + id + " 나이" + age;
}
}이름:이자바 학번:283920 나이20
이름:권자바 학번:304203 나이22
이름:김자바 학번:234932 나이24
- comparator 객체를 구현하지 않고, Arrays.sort( )함수 호출 시 익명클래스를 만들어 바로 사용한다.
2. 나이는 내림차순으로 정렬하고, 나이가 같은 경우에는 학번 오름차순으로 정렬한다.
Arrays.sort(stu, new Comparator<Student>() {
public int compare(Student s1, Student s2) {
if(s1.age == s2.age) { // 나이가 같은 경우
// return Integer.compare(s1.id, s2.id); // 학번 오름차순
return s1.id-s2.id; // 위 코드와 동일
}
// return Integer.compare(s2.age, s1.age); // 나이 내림차순
return s2.age-s1.age; // 위 코드와 동일
}
});
3. 람다식으로 작성 나이 내림차순과 오름차순
// 나이 내림차순 정렬
Arrays.sort(stu, (s1,s2) -> Integer.compare(s2.age, s1.age));
Arrays.sort(stu, (s1,s2) -> s2.age-s1.age); // 위코드와 동일
// 나이 오름차순 정렬
Arrays.sort(stu, (s1,s2) -> Integer.compare(s1.age, s2.age));
Arrays.sort(stu, (s1,s2) -> s1.age-s2.age); // 위 코드와 동일
예제)
import java.util.Arrays;
import java.util.Comparator;
public class Ex11_7 {
public static void main(String[] args) {
String[] strArr = {"cat", "Dog", "lion", "tiger"};
Arrays.sort(strArr); // (1) String의 comparable구현에 의한 정렬
System.out.println("strArr="+Arrays.toString(strArr)); // strArr=[Dog, cat, lion, tiger]
// (2) 정렬을 하려면 정렬 대상과 정렬 기준이 있어야 함
Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); // 대소문자 구분안함
System.out.println("strArr="+Arrays.toString(strArr)); // strArr=[cat, Dog, lion, tiger]
Arrays.sort(strArr, new Descending()); // (3) 역순 정렬(기본정렬의 반대)
System.out.println("strArr="+Arrays.toString(strArr)); // strArr=[tiger, lion, cat, Dog]
}
}
class Descending implements Comparator {
public int compare(Object o1,Object o2) {
if(o1 instanceof Comparable && o2 instanceof Comparable) { // 비교대상이 Comparable이면
Comparable c1 = (Comparable)o1; // Comparable로 형 변환
Comparable c2 = (Comparable)o2;
return c1.compareTo(c2) * -1; // compareTo()메서드 반환, -1을 곱해서 기본 정렬방식의 역으로 변경한다.
// return c2.compareTo(o1); // c2.compareTo(c1)으로 하면 순서 변경 가능
}
return -1; // 비교대상이 Comparable이 아니면 비교할 수 없어서 -1 반환
}
}
(1)
정렬을 하려면 대상과 기준이 있어야 함(정렬 대상 -> Object[ ] a, 정렬 기준 -> Comparator c)
-> 첫 번째 코드는 대상 밖에 없음
-> class String implements Comparable(String의 Comparable구현에 의한 정렬) -> 기본 정렬 기준, Comparable은 compareTo( )를 기본으로 가지고 있어서 기본 정렬 기준(사전 순서)이 가능함
(2) 정렬대상 strArr, 정렬기준 String.CASE_INSENSITIVE_ORDER
(3) 정렬대상 strArr, 정렬기준 Descending 객체
comparator을 구현하는 Descending 클래스 생성
정렬기준을 둔다 -> Comparator 인터페이스의 compare( )메서드를 완성해서 사용한다!
_> compare( )의 매개변수가 Object타입이기 때문에 compareTo( )를 바로 호출할 수 없기 때문에 먼저 Comparable로 형변환해야 함( compareTo의 반환값은 int)
-> 기본정렬기준 * -1 하면 역순으로 변경 가능( 양수 -> 음수, 0 -> 0, 음수 -> 양수 )
아니면 c2.compareTo(c1)으로 하면 순서 변경 가능
Integer와 Comparable(참고)
Integer클래스의 실제 코드
-> Comparable 인터페이스를 구현함! (CompareTo 포함)
<참고할만한 블로그>
'멀티캠퍼스 풀스택 과정 > Java의 정석' 카테고리의 다른 글
| 자바의 정석8-6 HashMap, Hashtable, Collections 요약 (0) | 2022.01.10 |
|---|---|
| 자바의 정석8-5 HashSet, TreeSet (0) | 2022.01.10 |
| 자바의 정석8-3 스택과 큐/Iterator, ListIterator, Enumeration (0) | 2022.01.10 |
| 자바의 정석8-2 ArrayList, LinkedList (0) | 2022.01.08 |
| 자바의 정석8-1 컬렉션프레임워크(List, Set, Map) (0) | 2022.01.08 |
