๐ป Programming/Java
[Java] ์๋ฐ ๋ฐฐ์ด ๋ฆฌ์คํธ ๋งต ์ ์ ๋ ฌํ๊ธฐ (์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์)
ํ๋ก๊ทธ๋๋ฐ์ ํ๋ค๋ณด๋ฉด DB ์กฐํ ์์ ์ ๋ ฌํด์ ์กฐํํด์ค๋ ๋ฐฉ๋ฒ๋ ์๊ณ , ์ ํ๋ฆฌ์ผ์ด์ ๋ ๋ฒจ์์ ์ ๋ ฌํด์ผ ํ ๋๋ ์์ต๋๋ค.
์ค๋์ ์ ํ๋ฆฌ์ผ์ด์ ์์ ๋ฐฐ์ด, ๋ฆฌ์คํธ, ๋งต, ์ ์ ๋ํ์ฌ ๊ฐ๊ฐ ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
1. ๋ฐฐ์ด ์ ๋ ฌํ๊ธฐ
์ฐ์ ์๋์ ๊ฐ์ด int ๋ฐฐ์ด์ด ์๋ค๊ณ ๊ฐ์ ํด๋ณด๊ฒ ์ต๋๋ค.
int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
๋ฐฐ์ด์ ์ ๋ ฌ์ java.util.Arrays ํด๋์ค์ ์๋ sort() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ์ ๋ ฌํ ์ ์์ต๋๋ค.
์ด ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด ๋ชจ๋ primitive ํ์ ์ ๋ํ ์ ๋ ฌ์ด ๊ฐ๋ฅํฉ๋๋ค. ๋ฌผ๋ก ์์ํ์ ์ด ์๋ Object[] ๋ ์ ๋ ฌ์ด ๊ฐ๋ฅํฉ๋๋ค.
int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
Arrays.sort(๋ฐฐ์ด) ํธ์ถ์ ํ๋ฉด ์ธ์๋ก ๋๊ฒจ์ค ๋ฐฐ์ด์ ์ ๋ ฌํด์ค๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ถ๋ ฅ์ ํด๋ณด๋ฉด ์๋์ ๊ฐ์ด ์ ์ ๋ ฌ์ด ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
[1, 5, 7, 66, 88, 89, 123, 200, 255]
๊ทธ๋ผ ์ด ๋ฉ์๋๊ฐ ๋ด๋ถ์ ์ผ๋ก ์ฌ์ฉํ๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ด๋ค ๊ฒ์ผ๊น์?
Java8 ๋ฌธ์์๋ ๋์ผ ํผ๋ด ํต์ํธ(Dual-Pivot Quick Sort) ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ค๊ณ ๋์์์ต๋๋ค.
๋์ผ ํผ๋ด ํต์ํธ๋ ๋ชจ๋ ๋ฐ์ดํฐ ์ ์ ๋ํด์ O(n log(n)) ์ ํผํฌ๋จผ์ค๋ฅผ ๋ณด์ด๊ณ ์ผ๋ฐ์ ์ผ๋ก ๊ธฐ์กด์ One-Pivot ํต์ํธ ์ ๋ ฌ๋ณด๋ค ๋น ๋ฅด๋ค๊ณ ํฉ๋๋ค.
Java7 ๋ฌธ์, Java14 ๋ฌธ์์๋ ๋์ผํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ ๊ฒ์ผ๋ก ๋์์์ต๋๋ค.
1.1 ๋ถ๋ถ์ ๋ ฌ
์ ์์ ๋ ๋ฐฐ์ด์ ์ ์ฒด ์์๋ฅผ ์ ๋ ฌํ๋ ๋ฐ๋ฉด ๋ฐฐ์ด์ ์ผ๋ถ๋ถ๋ง ์ ๋ ฌ์ ํ ์๋ ์์ต๋๋ค.
์ผ๋ถ๋ถ๋ง ์ ๋ ฌํ ๋๋ Arrays.sort(int[] a, int fromIndex, int toIndex) ๋ฉ์๋๋ฅผ ์ด์ฉํ์๋ฉด ๋ฉ๋๋ค.
int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
Arrays.sort(arr, 0, 4);
System.out.println(Arrays.toString(arr));
์ถ๋ ฅ์ ํด๋ณด๋ฉด ์๋์ ๊ฐ์ด 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ 3๋ฒ ์ธ๋ฑ์ค๊น์ง(4๋ exclude์ ๋๋ค) ์ ๋ ฌ์ด ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
[1, 5, 89, 255, 7, 88, 200, 123, 66]
1.2 ๋ณ๋ ฌ ์ ๋ ฌ (ParallelSort)
Arrays.sort()๊ฐ ์ฑ๊ธ์ฐ๋ ๋๋ก ๋์๊ฐ๋ค๋ฉด Arrays.parallelSort()๋ ๋ฉํฐ์ฐ๋ ๋๋ก ๋์์ ํฉ๋๋ค. parallelSort๋ ๋ฐฐ์ด์ sub-array๋ก ๋๋ ๋ค ๊ฐ๊ฐ์ ๋ณ๋์ ์ฐ๋ ๋์์ ์ฒ๋ฆฌ๋ฅผ ํ๊ณ ๊ฐ ์ฐ๋ ๋์์๋ Arrays.sort()๋ฅผ ์คํํ์ฌ ์ ๋ ฌ์ ํ๊ฒ ๋ฉ๋๋ค.
Arrays.parallelSort ์ ๊ฒฐ๊ณผ๋ ๋น์ฐํ Arrays.sort์ ๊ฒฐ๊ณผ์ ๋์ผํฉ๋๋ค. ๋ฉํฐ์ฐ๋ ๋ฉ์ ์ด์ฉํ๋๋์ ์ฐจ์ด๋ง ์กด์ฌํ ๋ฟ์ ๋๋ค.
์ฐธ๊ณ ๋ก Arrays.parallelSort ๋ ๋ถ๋ถ์ ๋ ฌ์ด ๊ฐ๋ฅํฉ๋๋ค. Arrays.parallelSort (int [] a, int fromIndex, int toIndex);
2. List ์ ๋ ฌํ๊ธฐ
๋ฆฌ์คํธ๋ฅผ ์ ๋ ฌํ ๋๋ java.util.Collections.sort(List<T> list) ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
List<Integer> toSortList = Ints.asList(arr); // int[]์ Integer[]๋ก ๋ณํ (๊ตฌ๊ธ guava ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ด์ฉ)
Collections.sort(toSortList);
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ Arrays.sort()๋ฅผ ์ฌ์ฉํ ๊ฒ๊ณผ ๋์ผํฉ๋๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ํฉ๋๋ค. ๋ง์ฝ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ ์ถ๋ค๋ฉด comparator๋ฅผ ์ธ์๋ก ์ ๋ฌ๋ฐ๋ sortโ(List list, Comparator c) ๋ฉ์๋๋ฅผ ์ด์ฉํ ์ ์์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋๋ฌด๋๋ ๊ธฐ๋ณธ์ ์ธ ์๊ธฐ์ง๋ง ์ ๋ ฌ์ ํ๋ ค๋ฉด ๋ ์์(element)๋ฅผ ๋น๊ตํ ์ ์์ด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ฆฌ์คํธ ๋ด์ ๋ชจ๋ ์์๋ค์ด Comparable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ ์์ด์ผ ํฉ๋๋ค.
Collections.sort(List<T> list) ๋ merge sort ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ์ฌ ์ ๋ ฌ์ ํฉ๋๋ค. List.sort(Comparator c)์์ ์ ๊ณตํ๋ ๊ธฐ๋ณธ ์๊ณ ๋ฆฌ์ฆ๊ณผ๋ ์กฐ๊ธ ๋ค๋ฅด๋ค๊ณ ํฉ๋๋ค๋ง, ๋ ์์ข๊ฒ ๋ณํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ ๊ฑด ์๋๊ฒ ์ฃ . ๊ทธ๋ฆฌ๊ณ ๊ธฐ๋ณธ์ ์ผ๋ก List.sort()์์ ์ฌ์ฉํ๋ merge sort๋ ์ด๋์ ๋ ๋ถ๋ถ ์ ๋ ฌ์ด ๋์ด์๋ ๋ฐ์ดํฐ์ ๋ํด์๋ n log(n) ๋ณด๋ค ํจ์ฌ ์ ์ ํ์๋ง ๋น๊ตํ๋ฉฐ(๊ฑฐ์ ์ ๋ ฌ์ด ๋์ด์๋ ์ํ๋ผ๋ฉด ๊ฑฐ์ n๋ฒ์ ๋น๊ต๋ง์ผ๋ก๋ ์ ๋ ฌ ๊ฐ๋ฅ), ๋๋คํ๊ฒ ์์ฌ์๋ ๋ฐ์ดํฐ ์ ์ ๋ํด์๋ ์ ํต์ ์ธ merge sort์ ํผํฌ๋จผ์ค๋ฅผ ๋ธ๋ค๊ณ ํฉ๋๋ค. Java14 Collections.sort() ์ฐธ๊ณ ํ์๋ฉด ์ข์ ๊ฒ ๊ฐ์ต๋๋ค.
๋ง์ฝ ์ญ์(๋ด๋ฆผ์ฐจ์)์ผ๋ก ์ ๋ ฌ์ ํ๊ณ ์ถ์ผ๋ฉด Collections.sort(List list, Comparator c) ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด ๋ฉ๋๋ค.
// ๋ด๋ฆผ ์ฐจ์ ์ ๋ ฌ
Collections.sort(list, Comparator.reverseOrder());
์๋ฐ์์๋ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ์ํด Comparator.reverseOrder() ๋ฉ์๋๋ฅผ ํตํด ๊ธฐ๋ณธ comparator๋ฅผ ์ ๊ณตํด์ฃผ๊ณ ์์ต๋๋ค.
3. Set ์ ๋ ฌํ๊ธฐ
Set์ ๊ธฐ๋ณธ์ ์ผ๋ก ์์๋ฅผ ๋ณด์ฅํ์ง ์์ต๋๋ค. ํ์ง๋ง LinkedHashSet์ ์์๋ฅผ ๋ณด์ฅํ์ฃ . ๋ฐ๋ผ์ Set์ ์ ๋ ฌํ๋ค๋ ๊ฒ์ ์ด LinkedHashSet ์ฒ๋ผ ์์๋ฅผ ๋ณด์ฅํ๋ set ๊ตฌํ์ฒด์ ๋ํ ์๊ธฐ์ ๋๋ค.
Set์ ์ ๋ ฌํ ๋๋ Collections.sort()๋ฅผ ์ด์ฉํฉ๋๋ค. ํ์ง๋ง ํด๋น ๋ฉ์๋๋ List๋ง์ ์ธ์๋ก ์ ๋ฌ๋ฐ๊ณ ์๊ธฐ ๋๋ฌธ์ Set์ ์ ๋ ฌํ๋ ค๋ฉด List๋ก ๋ณ๊ฒฝํ๋ ์์ ์ด ํ์ํฉ๋๋ค.
Set<Integer> set = new LinkedHashSet<>(Ints.asList(arr));
System.out.println(set); // ์ ๋ ฌํ๊ธฐ ์ ์ถ๋ ฅ
List<Integer> list = new ArrayList<>(set);
Collections.sort(list);
set = new LinkedHashSet<>(list);
System.out.println(set); // ์ ๋ ฌ ํ ์ถ๋ ฅ
์์์ ๋ณด๋ฏ์ด list๋ก ๋ณํ ํ ๋ค์ set์ผ๋ก ๋ณํํ์ฌ ์ ๋ ฌ์ ํ ์ ์์ต๋๋ค.
4. Map ์ ๋ ฌํ๊ธฐ
Map์ ์์๋ค์ํผ key์ value ์์ผ๋ก ์ด๋ฃจ์ด์ง ์๋ฃ๊ตฌ์กฐ์ ๋๋ค. ๋ฐ๋ผ์ Map์ ์ ๋ ฌํ ๋๋ key๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ๊ณผ value๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ, ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. ๋ํ, Map๋ Set๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก HashMap ๊ฐ์ ๊ฒฝ์ฐ๋ ์์์๋ ๋ฌด๊ดํ ์๋ฃ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์ ์ ๋ ฌ์ ์ํด์๋ LinkedHashMap์ ์ด์ฉํด์ผ ํฉ๋๋ค.
์ฐ์ key๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด๊ฒ ์ต๋๋ค. Map์ ์ ๋ ฌํ ๋๋ List, Set๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก Collections.sort(List list) ๋ฉ์๋๋ฅผ ์ด์ฉํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ list๋ก ๋ณํ์ ํด์ฃผ์ด์ผ ํ์ฃ . ๊ทธ๋ฆฌ๊ณ ์ ๋ ฌ ํ์๋ ์์์ ๋ณด์ฅ์ ์ํด list๋ฅผ LinkedHashMap์ผ๋ก ๋ณํํด์ฃผ์ด์ผ ํฉ๋๋ค. ๋ํ List.sort(Comparator c)๋ฅผ ์ด์ฉํ ์๋ ์์ต๋๋ค. ์์ ์์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋ํด ๋ชจ๋ ํ์ธํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
// ๊ธฐ๋ณธ ๋ฐ์ดํฐ ์
HashMap<Integer, String> map = new HashMap<>();
map.put(5, "Orange");
map.put(8, "Apple");
map.put(2, "WaterMelon");
map.put(13, "Pear");
map.put(9, "Grape");
map.put(4, "Banana");
// key, value ๋ฅผ ๋ชจ๋ ๊ฐ์ ธ์ค๊ธฐ ์ํด์ entrySet()์ ๋ฆฌ์คํธ๋ก ๋ณํ
List<Map.Entry<Integer, String>> entries = new ArrayList<>(map.entrySet());
// 1. List.sort ๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ
entries.sort(Comparator.comparing(Map.Entry::getKey));
// 2. Collections.sort ๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ
Collections.sort(entries, Comparator.comparing(Map.Entry::getKey));
// ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ LinkedHashMap์ ์ ์ฅ
Map<Integer, String> sortedByKey = new LinkedHashMap<>();
for (Map.Entry<Integer, String> entry : entries) {
sortedByKey.put(entry.getKey(), entry.getValue());
}
// ์ ๋ ฌ๋ ๋ด์ฉ ์ถ๋ ฅ
System.out.println(sortedByKey);
์ ๋ ฌํ ๋ List.sort(Comparator c) ์ Collections.sort(List list)๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ชจ๋ ์๊ฐํด๋๋ ธ์ต๋๋ค.
์ฌ๊ธฐ์ ์ฌ์ฉํ Comparator.comparing() ๋ฉ์๋๋ comparator๋ฅผ ๋ฐํํ๋ ๋ฉ์๋์ ๋๋ค. Comparator.comparing(Map.Entry::getKey) ๋ Map์ key ๊ฐ์ ๋น๊ตํ๋ comparator๋ฅผ ๋ง๋ค์ด์ฃผ์ฃ .
์ ์ฝ๋์์ ์ถ๋ ฅ๋๋ ๋ด์ฉ์ ์๋์ ๊ฐ์ต๋๋ค.
{2=WaterMelon, 4=Banana, 5=Orange, 8=Apple, 9=Grape, 13=Pear}
key ๊ฐ ์์๋๋ก ์ ๋ ฌ์ด ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
๊ทธ๋ผ ์ด๋ฒ์๋ ์ ์ฝ๋๋ฅผ ์กฐ๊ธ ์์ ํ์ฌ value๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
// 1. List.sort ๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ
entries.sort(Comparator.comparing(Map.Entry::getValue));
// 2. Collections.sort ๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ
Collections.sort(entries, Comparator.comparing(Map.Entry::getValue));
Comparator.comparing() ๋ฉ์๋์ ์ธ์๋ก key๊ฐ ์๋ value ๊ฐ์ ๋๊ฒจ์ฃผ๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค.
์์ ๋ ์ฝ๋ ์คํ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
{8=Apple, 4=Banana, 9=Grape, 5=Orange, 13=Pear, 2=WaterMelon}
value๊ฐ์ผ๋ก ๋ฃ์ด์ฃผ์๋ ๊ณผ์ผ๋ช ์์ผ๋ก ์ ๋ ฌ์ด ๋์ด ์ถ๋ ฅ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
5. ์ปค์คํ ๊ฐ์ฒด ์ ๋ ฌํ๊ธฐ
์ด๋ฒ์๋ ์ปค์คํ ๊ฐ์ฒด๋ฅผ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค. ์ฌ์ค ์ปค์คํ ๊ฐ์ฒด๋ฅผ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ด๋ผ๊ณ ๋ฐ๋ก ์๋๊ฑด ์๋๋๋ค. ์ด๋ฏธ ์์์ ์ค๋ช ๋๋ฆฐ ๋ด์ฉ์ค์ comparator๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ ์ด์ฉํด์ผ ํฉ๋๋ค.
์ผ๋จ ์ผํ๋ชฐ์ ํ๋งค์ค์ธ ์ํ์ ๋ํ ๊ฐ์ฒด ์ ์๋ฅผ ํด๋ณด๊ฒ ์ต๋๋ค.
@Getter
@Setter
@AllArgsConstructor
class Product {
String name; // ์ํ ๋ช
int price; // ์ํ ๊ฐ๊ฒฉ
float sellerRating; // ํ๋งค์ ํ์
@Override
public String toString() {
return "{" + this.name + ", " + price + ", " + sellerRating + "}";
}
}
์ด์ ์ด ๊ฐ์ฒด๋ฅผ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด ๊ฐ๊ฒฉ, ํ๋งค์ ํ์ ์ ๊ธฐ์ค์ผ๋ก ๊ฐ๊ฐ ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
// ๊ธฐ๋ณธ ๋ฐ์ดํฐ ์
List<Product> data = new ArrayList<>(Arrays.asList(
new Product("Apple", 100, 4.3f),
new Product("Apple", 200, 3.3f),
new Product("Apple", 150, 4.8f)));
// 1. List.sort ๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๊ฒฉ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
data.sort(Comparator.comparing(Product::getPrice));
System.out.println("\n1. List.sort ๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๊ฒฉ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ");
System.out.println(data);
// 2. List.sort ๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๊ฒฉ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
data.sort(Comparator.comparing(Product::getPrice, Comparator.reverseOrder()));
System.out.println("\n2. List.sort ๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๊ฒฉ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ");
System.out.println(data);
// 3. Collections.sort ๋ฅผ ์ด์ฉํ์ฌ ํ๋งค์ ํธ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
Collections.sort(data, Comparator.comparing(Product::getSellerRating));
System.out.println("\n3. Collections.sort ๋ฅผ ์ด์ฉํ์ฌ ํ๋งค์ ํธ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ");
System.out.println(data);
// 4. Collections.sort ๋ฅผ ์ด์ฉํ์ฌ ํ๋งค์ ํธ์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
Collections.sort(data, Comparator.comparing(Product::getSellerRating, Comparator.reverseOrder()));
System.out.println("\n4. Collections.sort ๋ฅผ ์ด์ฉํ์ฌ ํ๋งค์ ํธ์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ");
System.out.println(data);
Product ๋ฆฌ์คํธ๋ฅผ ํน์ ํ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ์ฝ๋๋ List.sort๋ฅผ ์ฌ์ฉํด๋, Collections.sort๋ฅผ ์ฌ์ฉํด๋ ํ ์ค์ด๋ฉด ๋ฉ๋๋ค. ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ํ๊ณ ์์ ๋๋ Comparator.comparing() ๋ฉ์๋์ Comparator.reverseOrder() ์ธ์๋ฅผ ์ถ๊ฐํด์ฃผ๋ฉด ๋ฉ๋๋ค. ์ฆ, Comparator.comparing(์ ๋ ฌ๊ธฐ์ค, ์ ๋ ฌ์์) ์ด๋ ๊ฒ ์ฌ์ฉํ์๋ฉด ๋๋๊ฑฐ์ฃ .
์, ์ด์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํด๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1. List.sort ๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๊ฒฉ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
[{Apple, 100, 4.3}, {Apple, 150, 4.8}, {Apple, 200, 3.3}]
2. List.sort ๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๊ฒฉ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
[{Apple, 200, 3.3}, {Apple, 150, 4.8}, {Apple, 100, 4.3}]
3. Collections.sort ๋ฅผ ์ด์ฉํ์ฌ ํ๋งค์ ํธ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
[{Apple, 200, 3.3}, {Apple, 100, 4.3}, {Apple, 150, 4.8}]
4. Collections.sort ๋ฅผ ์ด์ฉํ์ฌ ํ๋งค์ ํธ์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
[{Apple, 150, 4.8}, {Apple, 100, 4.3}, {Apple, 200, 3.3}]
Summary
์ฌ๊ธฐ๊น์ง ์๋ฐ์์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด์์ต๋๋ค.
๊ฐ๋ตํ ์์ฝ์ ํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋ฐฐ์ด์ ์ ๋ ฌ -> Arrays.sort() ์ด์ฉ
List ์ ๋ ฌ -> Collections.sort(), List.sort() ์ด์ฉ
Set, Map ์ ๋ ฌ -> List๋ก ๋ณํ ํ Collections.sort(), List.sort() ์ด์ฉ
๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ Comparator.reverseOrder() ์ด์ฉ
'๐ป Programming > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์๋ฐ ๋น๋๊ธฐ ํธ์ถํ๊ธฐ (How to make asynchronous call in java) (0) | 2021.02.19 |
---|---|
SpringBoot์์ ThreadPoolTaskExecutor ์ค์ ํ๊ธฐ (0) | 2021.01.26 |
[Java] ์๋ฐ ์์ธ/์๋ฌ ์ฒ๋ฆฌ ์ํ๊ธฐ (How to improve exception handling) (0) | 2020.12.08 |
[Java] ์๋ฐ 2์ฐจ์ ๋ฐฐ์ด ์์ฑ(์ ์ธ ๋ฐ ์ด๊ธฐํ) (0) | 2020.08.31 |
์ดํด๋ฆฝ์ค์ ์คํ๋งํด์ฆ(STS) ์ค์นํ๊ธฐ (0) | 2020.07.22 |