๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๊ฐ๋ฐ์๋ก์ ์ฐ๋ฆฌ์๊ฒ ํ์ํ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ๊ธฐ๋ฅ ์ค ํ๋๋ ์ ๋ ฌ์
๋๋ค. ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ ์ ์์ผ๋ฏ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ต์ ํํ์ฌ ํจ์ฌ ๋ ๋น ๋ฅด๊ฒ ์คํํ๊ณ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ๋ณด๋ค ํจ์ฌ ์งง์ ์๊ฐ ๋ด์ ์ฐพ์ ์ ์์ต๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ๊ฑธ๋ฆด ๊ฒ์
๋๋ค. ์ค๋ ๊ฐ์์์๋ Java Collections sort()์ ๋ํด ์ด์ผ๊ธฐํ๊ฒ ์ต๋๋ค. ๋น ๋ฅธ ์ฌ๊ณ ์คํ: ๋ํ ๋ช
๋ถ๋ฅผ ํตํด ์ด๋ฆ์ ๊ฒ์ํ๋ค๊ณ ์์ํด ๋ณด์ญ์์ค. ์ด ํ๊ต์๋ ์๋ง ๋ช
์ ํ์์ด ์์ ์ ์์ต๋๋ค. ์ ๊ณต๋ ๋ช
๋จ์ด ์ํ๋ฒณ ์์๊ฐ ์๋ ๊ฒฝ์ฐ ์ํ๋ ์ด๋ฆ์ ์ฐพ์ ๋๊น์ง ๋ชจ๋ ํ์ด์ง๋ฅผ ๋๊ธฐ๊ณ ๋งค์ฐ ์ฃผ์ ๊น๊ฒ ์ดํด๋ณด๊ณ ์ด๋ฆ์ ๊ฑด๋๋ฐ์ง ์์๋์ง ํ์ธํด์ผ ํฉ๋๋ค. ๋ฐ๋ฉด์ ๋ช
๋จ์ด ์ํ๋ฒณ ์์ผ๋ก ๋์ด ์๋ค๋ฉด ๋ ์๊ฒฉํ๊ฒ ๊ฒ์ํด์ผ ํ ๋ฟ๋ง ์๋๋ผ ๊ทธ๋ฌ๋ ๋์ผํ ์ฒซ ๊ธ์๋ก ๋ช
๋จ์ ์น์
์ผ๋ก ์ฝ๊ฒ ์ด๋ํ ์ ์์ผ๋ฉฐ ์ฐพ๊ณ ์๋ ์ฌ๋์ ์ฐพ์ ๋๊น์ง ๊ณ์ํด์ ํ์ด์ง๋ฅผ ํฌ๊ฒ ๋์ฝํ ์ ์์ต๋๋ค. ์์
ํ๋ ๋ฐ์ดํฐ๊ฐ ๋ง์์๋ก ๋ฐ์ดํฐ๋ฅผ ์ต๋ํ ํจ๊ณผ์ ์ด๊ณ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ์ค์ํฉ๋๋ค. ์ด ๊ธฐ์ฌ์์๋ Collections ์ ๋ ฌ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ฌ Java์์ List ๊ตฌํ(ArrayList ํฌํจ)์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
Java ์ปฌ๋ ์ ์ ๋ ฌ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ฌ Java์์ ArrayList๋ฅผ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ
Java Collections.sort ๋ฉ์๋์ ๋ํด ์ด์ผ๊ธฐํด ๋ด ์๋ค. java.util ํจํค์ง์๋ ArrayList๋ฅผ ํฌํจํ์ฌ ๊ฐ๋ฐ์๊ฐ ์์ฃผ ์ฌ์ฉํ๋ ๋ง์ ์ ์ฉํ ์ ํธ๋ฆฌํฐ์ ํจํค์ง๊ฐ ํฌํจ๋์ด ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ ๊ฐ๋จํ ํ๋ก๊ทธ๋จ์ด ์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค.import java.util.*;
import java.io.*;
class Main{
public static void main(String[] args){
List<String> colors = new ArrayList<String>();
colors.add("Red ");
colors.add("Orange");
colors.add("Green");
colors.add("Blue");
}
}
์์ ๋ชฉ๋ก์ ์ํ๋ฒณ์์ผ๋ก ์ธ์ํ ์ ์๊ธฐ๋ฅผ ์ํฉ๋๋ค. ์ด๋ป๊ฒ ํ ์ ์์ต๋๊น? java.util.Collections๋ฅผ ์ฌ์ฉํ๋ฉด ์ ๋ ฌ์ด ๊ฐ๋จํฉ๋๋ค.
Collections.sort(colors);
์ง์! ์ด์ ์์ ๋ชฉ๋ก์ด ์ ์๋ฆฌ์ ์ ๋ ฌ๋์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ด ๋ชฉ๋ก์ ์ธ์ํ๋ ๊ฒฝ์ฐ:
System.out.println(colors);
๊ทธ๋ฌ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋ํ๋ฉ๋๋ค.
[Blue, Green, Orange, Red]
์ผ๋ง๋ ์ฌ์ ์ต๋๊น?! Collections.sort()๋ฅผ ์ฌ์ฉํ์ฌ Integers, Floats ๋๋ ํด๋น ๋ฌธ์ ์ ๋ํ ๋ค๋ฅธ ๊ฐ๋จํ ๋ฐ์ดํฐ ์ ํ์ ๋ชฉ๋ก์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ๊ฒ๋ ์ฝ์ต๋๋ค. ํ์ง๋ง ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์? ์ด๊ฒ์ด ์๋ฏธ๊ฐ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ถ๋ช
ํ ์์ต๋๋ค. ํน์ ์์
์ ๋ํ ์ํ ์ ์ ๋ชฉ๋ก์ด ์๊ณ ์ต๊ณ ์ ์๋ฅผ ๋ฐ์ ํ์์ด ๋๊ตฌ์ธ์ง ์์๋ด๊ณ ์ถ๋ค๊ณ ์์ํด ๋ณด์ญ์์ค. ๋ชฉ๋ก์ ๋ด๋ฆผ์ฐจ์(๊ฐ์ฅ ๋์ ์ ์๋ถํฐ)์ผ๋ก ์ ๋ ฌํ์ฌ ์ํ๋ ๋ต๋ณ์ด ๋งจ ์์ ์ค๋๋ก ํ๋ ๊ฒ์ด ํจ์ฌ ๋ ํฉ๋ฆฌ์ ์
๋๋ค. ๊ณ ๋ง๊ฒ๋ Collections.sort()๋ ์ ํ์ ๋ ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก ๋ฎ์ด์จ์ ๋ค์๊ณผ ๊ฐ์ด ํ ์ ์์ต๋๋ค.
sort(List l, Comparator c)
๊ทธ๋ฌ๋ ๋น๊ต๊ธฐ๊ฐ ๋ฌด์์
๋๊น? ๋น๊ต๊ธฐ๋ ๋จ์ํ ๋ ์
๋ ฅ์ ๋น๊ตํ๊ณ ์ด๋ค ์
๋ ฅ์ด ๋จผ์ ์ค๋์ง๋ฅผ ๋ํ๋ด๋ ์ซ์๋ฅผ ๋ฐํํ๋ ํจ์์
๋๋ค. ์์ ๋ฐ์ดํฐ ์ ํ์ ArrayList๋ฅผ ์ ๋ ฌํ๋ ๊ฒฝ์ฐ Java Collections๋ ์ด๋ฏธ reverseOrder() ๋น๊ต์๋ฅผ ์ ๊ณตํฉ๋๋ค. ๋ค์๊ณผ ๊ฐ์ด ํธ์ถํ ์ ์์ต๋๋ค.
Collections.sort(colors, Collections.reverseOrder());
์ด์ ์์์ด ์ ์๋ฆฌ์์ ์ญ์ผ๋ก ์ ๋ ฌ๋์์ผ๋ฏ๋ก ์ธ์ํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค.
[Red, Orange, Green, Blue]
์ปฌ๋ ์ ์ ์ฌ์ฉํ์ฌ Java์์ ๊ธฐ๋ณธ์ด ์๋ ๋ฐ์ดํฐ ์ ํ์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ
์ง๊ธ๊น์ง Collections.sort() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ Java์์ ๋ฌธ์์ด ๋๋ int์ ArrayList๋ฅผ ์ ๋ ฌํ๋ ๊ฒ์ด ํ ์ค์ ์ฝ๋๋งํผ ์ฝ๋ค๋ ๊ฒ์ ํ์ธํ์ต๋๋ค. ๊ทธ๋ฌ๋ ์ข ์ข ArrayList๋ ๊ธฐ๋ณธ์ด ์๋ ๋ฐ์ดํฐ ์ ํ์ ์ ์ฅํฉ๋๋ค. ๋ ๋ณต์กํ ์์ฑ์ด ์๋ ๋ฐ์ดํฐ๋ก ์์ ํ๋ ๊ฒฝ์ฐ ์ด๋ฌํ ๊ฐ์ฒด๋ฅผ ๋ํ๋ด๋ ํด๋์ค์ ํด๋น ์์ฑ์ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด๋ฅผ ์๋ก ๋น๊ตํ๋ ๋ฐฉ๋ฒ์ ์์ฑํ๊ณ ์ถ์ ๊ฒ์ ๋๋ค. ์ด์ ๋ํ ์๋ฅผ ์ดํด๋ณด๊ธฐ ์ํด ์์ ๋ชฉ๋ก์ ์ ๋ ฌํ๋ ์๋ฅผ ๋ค์ ์ดํด๋ณด๊ฒ ์ต๋๋ค. ์ด๋ฒ์๋ ๋ฌธ์์ด์ ์ ๋ ฌํ๋ ๋์ Color ๊ฐ์ฒด๋ฅผ ์ ๋ ฌํ ๊ฒ์ ๋๋ค. ๊ธฐ๋ณธ Color ํด๋์ค๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.public class Color{
private int r;
private int g;
private int b;
private String name;
Color(String name, int red, int green, int blue){
this.name = name;
this.r = red;
this.g = green;
this.b = blue;
}
}
Color ํด๋์ค๊ฐ Collections.sort()์ ํธํ๋๋๋ก ํ๋ ค๋ฉด Collections๊ฐ Color ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๊ณ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ์ดํดํ ์ ์๋๋ก ๋ ๊ฐ์ง ์์ ์์ ์ด ํ์ํฉ๋๋ค.
- Color๋ฅผ Comparable ๊ฐ์ฒด๋ก ๋ง๋ค๊ธฐ(add implements Comparable<Object>)
- ํด๋์ค์ compareTo ๋ฉ์๋ ์ฌ์ ์(public int compareTo(Object o) ์ฌ์ ์)
public class Color implements Comparable<Object>{
private int r;
private int g;
private int b;
private String name;
Color(int red int green, int blue, String name){
this.r = red;
this.g = green;
this.b = blue;
this.name = name;
}
@Override
public int compareTo(Object o) {
Color c = (Color) o;
return this.name.compareTo(c.name);
}
}
Color์ compareTo ๋ฉ์๋๋ ๋จ์ํ String์ compareTo ๋ฉ์๋๋ฅผ ํธ์ถํฉ๋๋ค. ์ ๋ ฌ์ ์ํ๋ฒณ์์ผ๋ก ์ํ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋นจ๊ฐ์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ค๋ฉด return ๋ฌธ์ return this.r - cr๋ก ๋ฐ๊ฟ ์ ์์ต๋๋ค. (๋
น์ ๊ฐ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ค๋ฉด return cg - this.g;๊ฐ ๋ฉ๋๋ค.) ์ด์ ์ ํ๋ฅผ ๊ฑธ๋ฉด
Collections.sort(colors);
Collections๊ฐ Color ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ ๋ฐฉ๋ฒ์ ์ดํดํ๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด์ด ์๋ ์์์ ArrayList์์ ์๋ํฉ๋๋ค. ๊ฐ์ฒด๊ฐ Comparable<Object>๋ฅผ ๊ตฌํํ์ง ์๋๋ก ํ๋ ค๋ฉด ํด๋์ค์ ๋ํ ๋น๊ต๊ธฐ๋ฅผ ์์ฑํ๊ณ ์ด๋ฅผ 2-๋งค๊ฐ๋ณ์ Collections.sort() ๋ฉ์๋์ ์ ๋ฌํ ์ ์์ต๋๋ค. ๋น๊ต๊ธฐ๋ public int compare(Object one, Object two) ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๊ณ Collections.sort() ๋ฉ์๋๋ ์ ๋ ฌํ๋ ๋์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ ๋ฐ ์ด ๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. SortByName ๋ฐ SortByRed ๋น๊ต๊ธฐ์ ์๋ ์๋์ ๊ตฌํ๋ฉ๋๋ค.
class SortByName implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.name.compareTo(b.name);
}
}
class SortByRGB implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.r - b.r;
}
}
์ด๊ฒ์ผ๋ก ์ด์ ์ ํํ ์ ์์ต๋๋ค.
Collections.sort(colors, new SortByName());
Color ํด๋์ค๊ฐ ์ค์ ๋ก Comparable์ ๊ตฌํํ์ง ์์๋ ์ฌ์ ํ ์๋ํฉ๋๋ค. ๊ฒฝ์ฐ์ ๋ฐ๋ผ ๋๋ค ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ด ์์
์ด ์ธ๋ผ์ธ์ผ๋ก ์ํ๋๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. ๋๋ค ํจ์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ด๋ฅผ ํธ์ถํ๋ ์ฝ๋ ์ค ๋ด์์ ์ ์ํ ์ ์๋ ์ด๋ฆ ์๋ ํจ์์
๋๋ค. ํ๋์ ํน์ ์ธ์คํด์ค์ ๋ํด์๋ง ํจ์๋ฅผ ํธ์ถํด์ผ ํ๊ณ ๋ค๋ฅธ ๊ณณ์์ ์ ์ฒด ๊ฐ๋ณ ํจ์๋ฅผ ์ ์ํ๊ณ ์ถ์ง ์์ ๋ ์ ์ฉํฉ๋๋ค. SortByName ๋น๊ต๊ธฐ๋ ๋ค์๊ณผ ๊ฐ์ด ๋๋ค ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ธ๋ผ์ธ์ผ๋ก ์ ์ํ ์ ์์ต๋๋ค.
Collections.sort(colors, (a, b)-> {
return a.name.compareTo(b.name)});
์ง์ํ์
จ๊ฒ ์ง๋ง (a, b)๋ ๋๋ค ํจ์(๋น๊ตํ ๋ ๊ฐ์ฒด)์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ํ๋
๋๋ค. ->๋ ๋ค์ ์ค๋ ๊ฒ์ด ๋๋ค ํจ์ ์ ์์์ ๋ํ๋
๋๋ค. ๊ทธ๊ฒ ๋ค์ผ! ์ด์ Collections ํจํค์ง๋ฅผ ์ฌ์ฉํ์ฌ Java์์ ArrayList๋ฅผ ์ ๋ ฌํ๋ ๊ฐ์ฅ ์ธ๊ธฐ ์๋ ๋ฐฉ๋ฒ์ ๋ณด์์ต๋๋ค.