팁 *** 정렬/변환

여러가지 경우에따라 정렬하는 법에 대해 정리해 보았습니다.

 

종종 정렬을 해야할 경우 아래의 방법을 사용하면 보다 편리하게 정렬할 수 있습니다.

 

여기서 중요한 포인트를 알아보겠습니다.

 

1. int[]의 경우 Arrays.sort를 이용하여 오름차순으로 정렬하기 위해서는 Integer[]로 변환 후 정렬해야합니다.

2. 배열을 출력하기 위해서는 Arrays.toSring(arr)를 사용합니다.

3. map의 key값 기준 정렬하기 TreeMap을 사용합니다.

3. map의 value값 기준 정렬하기 위해서는 entrySet애 Comparator 인터페이스를 사용합니다.

   - Comparator 인터페이스를 생성하여 compare 오버라이드 하여 재정의하여 사용합니다.

4. ArrayList<String[]>에 존재하는 인덱스 기준으로 정렬할때는 Collectinos.sort에 Comparator인터페이스를 사용합니다.

5. List <-> 배열 형변환 : String, int일때 방법이 다릅니다.

 

import java.util.*;
import java.util.Map.Entry;

public class Main {
	public static void main(String[] args) throws Exception {
		String[] stArr = {"가","다","나","마","라"};
		int[] intArr = {5,1,3,2,4};
		Integer[] integerArr = new Integer[intArr.length];
		
		Arrays.sort(stArr); 
		System.out.println("String[] 오른차순 정렬 : " + Arrays.toString(stArr)); 
		
		Arrays.sort(stArr, Collections.reverseOrder()); 
		System.out.println("String[] 내림차순 정렬 : " + Arrays.toString(stArr)); 
		
		Arrays.sort(intArr); 
		System.out.println("int[] 오른차순 정렬 : "+ Arrays.toString(intArr)); 
		
		integerArr = Arrays.stream(intArr).boxed().toArray(Integer[]::new);
		Arrays.sort(integerArr, Collections.reverseOrder()); 
		System.out.println("int[]     -> integer[] 변환 후 내림차순 정렬 : " + Arrays.toString(integerArr)); 
		
		intArr = Arrays.stream(integerArr).mapToInt(Integer::intValue).toArray();
		System.out.println("integer[] -> int[] 변환 후 출력            : " + Arrays.toString(intArr)); 
		
		System.out.println(); 
		
		ArrayList<String> stringList = new ArrayList<String>();
		stringList.add("가");
		stringList.add("다");
		stringList.add("나");
		stringList.add("마");
		stringList.add("라");
		
		Collections.sort(stringList);
		System.out.println("ArrayList<String>  오름차순 출력 : " + stringList.toString());
		
		Collections.sort(stringList, Collections.reverseOrder());
		System.out.println("ArrayList<String>  내림차순 출력 : " + stringList.toString()); 
		
		ArrayList<Integer> integerList = new ArrayList<Integer>();
		integerList.add(5);
		integerList.add(3);
		integerList.add(4);
		integerList.add(1);
		integerList.add(2);
		
		Collections.sort(integerList);
		System.out.println("ArrayList<Integer> 오름차순 출력 : " + integerList.toString()); 
		
		Collections.sort(integerList, Collections.reverseOrder());
		System.out.println("ArrayList<Integer> 내림차순 출력 : " + integerList.toString()); 
		
		System.out.println();
		
		TreeMap<String, Object> tMap = new TreeMap<String, Object>();
		tMap.put("가", 5);
		tMap.put("라", 2);
		tMap.put("다", 4);
		tMap.put("나", 1);
		tMap.put("마", 3);
		System.out.println("TreeMap<String, Object>  Key   기준 오름차순 출력 : " + tMap.toString()); 
		
		TreeMap<String, Object> tMapR = new TreeMap<String, Object>(Comparator.reverseOrder());
		tMapR.put("가", 5);
		tMapR.put("라", 2);
		tMapR.put("다", 4);
		tMapR.put("나", 1);
		tMapR.put("마", 3);
		System.out.println("TreeMap<String, Object>  Key   기준 내림차순 출력 : " + tMapR.toString());
		
		HashMap<String, Integer> vMap = new HashMap<String, Integer>();
		vMap.put("가", 5);
		vMap.put("라", 2);
		vMap.put("다", 4);
		vMap.put("나", 1);
		vMap.put("마", 3);
		List<Map.Entry<String, Integer>> entryList1 = new LinkedList<>(vMap.entrySet());
		entryList1.sort(new Comparator<Map.Entry<String, Integer>>() {
		    @Override
		    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
		    	return o1.getValue().compareTo(o2.getValue());
		    }
		});
		System.out.println("HashMap<String, Integer> value 기준 오름차순 출력 : " + entryList1.toString()); 
		
		List<Map.Entry<String, Integer>> entryList2 = new LinkedList<>(vMap.entrySet());
		entryList2.sort(new Comparator<Map.Entry<String, Integer>>() {
		    @Override
		    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
			return o2.getValue().compareTo(o1.getValue());
		    }
		});
		System.out.println("HashMap<String, Integer> value 기준 내림차순 출력 : " + entryList2.toString()); 
		
		System.out.println();
		
		ArrayList<String[]> stArrList = new ArrayList<String[]>();
		stArrList.add(new String[] {"라", "1"});
		stArrList.add(new String[] {"다", "2"});
		stArrList.add(new String[] {"가", "3"});
		stArrList.add(new String[] {"나", "5"});
		stArrList.add(new String[] {"마", "4"});
		Collections.sort(stArrList, new Comparator<String[]>() {
			@Override
			public int compare(String[] o1, String[] o2) {
				return o1[0].compareTo(o2[0]);
			}
		});
		System.out.print("ArrayList<String[]> index[0] 오름차순 출력 : "); 
		
		for(String[] a : stArrList) {
			System.out.print(a[0] + " ");	
		}
		
		System.out.println();
		
		Collections.sort(stArrList, new Comparator<String[]>() {
			@Override
			public int compare(String[] o1, String[] o2) {
				return o2[1].compareTo(o1[1]);
			}
		});
		System.out.print("ArrayList<String[]> index[1] 내림차순 출력 : "); 
		
		for(String[] a : stArrList) {
			System.out.print(a[1] + " ");	
		}
		 
		System.out.println();
		System.out.println();
		
		ArrayList<String> stringList2 = new ArrayList<>(Arrays.asList(stArr)) ;
		System.out.println("String[]           -> ArrayList<String>  : " + stringList2.toString());
		
		String[] arr = stringList2.toArray(new String[stringList2.size()]);
		System.out.println("ArrayList<String>  -> String[]           : " + Arrays.toString(arr));
		
		System.out.println();
		
		integerArr = Arrays.stream(intArr).boxed().toArray(Integer[]::new);
		ArrayList<Integer> integerList2 = new ArrayList<>(Arrays.asList(integerArr)) ;
		System.out.println("int[]              -> ArrayList<Integer> : " + integerList2.toString());

		int[] arr2 = integerList2.stream().mapToInt(i -> i).toArray();
		System.out.println("ArrayList<Integer> -> int[]              : " + Arrays.toString(arr2));
	}
}

[결과]

String[] 오름차순 정렬 : [가, 나, 다, 라, 마]
String[] 내림차순 정렬 : [마, 라, 다, 나, 가]
int[] 오름차순 정렬 : [1, 2, 3, 4, 5]
int[]     -> integer[] 변환 후 내림차순 정렬 : [5, 4, 3, 2, 1]
integer[] -> int[] 변환 후 출력            : [5, 4, 3, 2, 1]

ArrayList<String>  오름차순 출력 : [가, 나, 다, 라, 마]
ArrayList<String>  내림차순 출력 : [마, 라, 다, 나, 가]
ArrayList<Integer> 오름차순 출력 : [1, 2, 3, 4, 5]
ArrayList<Integer> 내림차순 출력 : [5, 4, 3, 2, 1]

TreeMap<String, Object>  Key   기준 오름차순 출력 : {가=5, 나=1, 다=4, 라=2, 마=3}
TreeMap<String, Object>  Key   기준 내림차순 출력 : {마=3, 라=2, 다=4, 나=1, 가=5}
HashMap<String, Integer> value 기준 오름차순 출력 : [나=1, 라=2, 마=3, 다=4, 가=5]
HashMap<String, Integer> value 기준 내림차순 출력 : [가=5, 다=4, 마=3, 라=2, 나=1]

ArrayList<String[]> index[0] 오름차순 출력 : 가 나 다 라 마 
ArrayList<String[]> index[1] 내림차순 출력 : 5 4 3 2 1 

String[]           -> ArrayList<String>  : [마, 라, 다, 나, 가]
ArrayList<String>  -> String[]           : [마, 라, 다, 나, 가]

int[]              -> ArrayList<Integer> : [5, 4, 3, 2, 1]
ArrayList<Integer> -> int[]              : [5, 4, 3, 2, 1]