常見類型相互轉換和排序

https://blog.csdn.net/xHibiki/article/details/82938480
https://blog.csdn.net/my_precious/article/details/53010232

---

轉換

Array<->List

// Array->List
Integer[] arr = {1,2,3};
List list = Arrays.asList(arr);

// List->Array
Integer[] arr1 = (Integer[]) list.toArray(new Integer[list.size()]);

String->Array/List

String str = "a,b,c";

// String->Array
String[] arr = str.split(",");

// String->List
List list = Arrays.asList(str.split(","));

Set<->Array/List

String[] arr = new String[]{"aaa", "bbb", "ccc"};
List list = Arrays.asList(arr);

// Array->Set
Set<String> set = new HashSet<>(Arrays.asList(arr));

// Set->Array
Object[] arr2 = set.toArray();

// List->Set
Set result = new HashSet(list);

// Set->List
List<String> list2 = new ArrayList<>(set);

Integer[]<->int[]<->List

int[] arr = {4, 5, 3, 6, 2, 5, 1};

// int[] -> Integer[]
Integer[] arr0 = Arrays.stream(arr).boxed().toArray(Integer[]::new);

// int[] -> List<Integer>
List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());

// Integer[] 轉 int[]
int[] arr1 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();

// List<Integer> -> int[]
int[] arr2 = list1.stream().mapToInt(Integer::valueOf).toArray();

---

排序

數組排序

Integer[] arr = {2,5,3,10,6};

// 升序排序 2 3 5 6 10 
Arrays.sort(arr);

// 降序排序 10 6 5 3 2 
Arrays.sort(arr, Collections.reverseOrder());

// 自定義排序,eg:奇數前偶數後 5 3 10 6 2 
Arrays.sort(arr, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		if((o1-o2)%2 == 0){
			return 0;
		}else {
			return (o1%2 == 0) ? 1 : -1;
		}
	}
});

二維數組排序

int[][] arr = {{3,14},{71,29},{23,64},{2,19}};

// 按第一個元素升序排序 {2,19}{3,14}{23,64}{71,29}
Arrays.sort(arr,Comparator.comparingInt(o -> o[0]));

// 按第二個元素升序排序 {3,14}{2,19}{71,29}{23,64}
Arrays.sort(arr,Comparator.comparingInt(o -> o[1]));

// 按第二個元素降序排序 {23,64}{71,29}{2,19}{3,14}
Arrays.sort(arr,Comparator.comparingInt(o -> -o[1]));

鏈表排序

List<Integer> list = new ArrayList<Integer>();
list.add(2); 
//...

// 升序排序 2 3 5 6 10 
Collections.sort(list);

// 降序排序 10 6 5 3 2 
Collections.reverse(list);

// 自定義排序 方法一：Collections.sort(List,Comparator)
Collections.sort(list, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		// o1排後面返回1
		return o1 - o2;

	}
});

// 自定義排序 方法二：list.sort(Comparator)
list.sort(new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		return o1 - o2;
   }
});

Map排序

Map<String,Integer> map = new HashMap<String,Integer>();
map.put("aaa",1);
map.put("bbb",2);
map.put("ccc",3);

按key排序

// 得到HashMap中的keySet,轉換爲數組,用Arrays.sort()排序
Set keys = map.keySet();
Object[] keyArray = keys.toArray();
Arrays.sort(keyArray);

// 遍歷
for(Object key:keyArray){
	// 利用HashMap.get(key)得到鍵對應的值
	System.out.println(key+" : "+map.get(key));
}

按value排序

// 得到HashMap的entrySet，轉換爲List
List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());

// 排序方法一：Collections.sort(List,Comparator)
Collections.sort(list, 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());
	}
});

// 排序方法二：list.sort(Comparator)
list.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());
	}
});

// 遍歷方法一：for
for (int i = 0; i < list.size(); i++) {
	System.out.println(list.get(i).getKey()+" : "+list.get(i).getValue());
}

// 遍歷方法二：for-each
for (Map.Entry<String, Integer> mapping : list){
	System.out.println(mapping.getKey()+" : "+mapping.getValue());
}