一、Collections.sort()排序
1. 若需要排序的元素实现了Comparable接口,则可以直接使用Colletions.sort()或者Arrays.sort()进行排序,其中源码Collections.class,如下
public static <T extends Comparable<? super T>> void sort(List<T> paramList) { paramList.sort(null); }
此外,"实现了Comparable接口的类的对象"可以用作"有序映射(如TreeMap)"中的键或"有序集合(TreeSet)"中的元素,而不需要指定比较器。
代码案列:
package com.itheima.course.collection;
/**
* @description 实现了Comparable接口的类
* @author ...
* @date 2021-02-07 16:58:25
*/
public class SortA implements Comparable<SortA> {
private String name;
private Integer order;
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the order
*/
public Integer getOrder() {
return order;
}
/**
* @param order the order to set
*/
public void setOrder(Integer order) {
this.order = order;
}
@Override
public String toString() {
return "SortA [name=" + name + ", order=" + order + "]";
}
@Override
public int compareTo(SortA sortA) {
// 升序
return this.order.compareTo(sortA.getOrder());
// return this.order - sortA.getOrder();
// return Integer.compare(this.order, sortA.getOrder());
// 倒序
// return sortA.getOrder().compareTo(this.order); // return sortA.getOrder() - this.order;
// return Integer.compare(sortA.getOrder(), this.order);
}
}
/**
*
*/
package com.itheima.course.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @description 测试类
* @author ...
* @date 2021-02-07 17:11:07
*/
public class SortATest {
public static void main(String[] args) {
// String 排序
List<String> lists = new ArrayList<String>();
lists.add("5");
lists.add("2");
lists.add("9");
// lists中的对象String 本身含有compareTo方法,所以可以直接调用sort方法,按自然顺序排序,即升序排序
Collections.sort(lists);
System.out.println("String 排序后: " + lists.toString());
// 结果 String 排序后: [2, 5, 9]
// 第一种方法示例:
List<SortA> listA = new ArrayList<SortA>();
SortA a1 = new SortA();
a1.setName("a");
a1.setOrder(2);
SortA a2 = new SortA();
a2.setName("b");
a2.setOrder(1);
SortA a3 = new SortA();
a3.setName("c");
a3.setOrder(5);
listA.add(a1);
listA.add(a2);
listA.add(a3);
// list中的对象A实现Comparable接口
Collections.sort(listA);
System.out.println("排序后: " + listA);
// 结果排序后: [SortA [name=b, order=1], SortA [name=a, order=2], SortA [name=c,
// order=5]]
}
}
2. 若需要排序的元素未实现Comparable接口,则我们可使用Comparator 比较器接口。
我们若需要控制某个类的次序,而该类本身不支持排序(即没有实现Comparable接口);那么,我们可以建立一个“比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。也就是说,我们可以通过“实现Comparator类来新建一个比较器”,然后通过该比较器对类进行排序。
- Collections.sort(list, new PriceComparator())
- 参数一:需要排序的list
- 参数二:比较器,实现Comparator接口的类,返回一个int型的值,就相当于一个标志,告诉sort方法按什么顺序来对list进行排序。
- Comparator是个接口,可重写compare()及equals()这两个方法,用于比较功能;如果是null的话,就是使用元素的默认顺序,如a,b,c,d,e,f,g,就是a,b,c,d,e,f,g这样,当然数字也是这样的。
- compare(a,b)方法:根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
- equals(obj)方法:仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true。
package com.itheima.course.collection;
/**
* @description 实体类
* @author ...
* @date 2021-02-07 17:16:12
*/
public class SortB {
private String name;
private Integer order;
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the order
*/
public Integer getOrder() {
return order;
}
/**
* @param order the order to set
*/
public void setOrder(Integer order) {
this.order = order;
}
@Override
public String toString() {
return "SortB [name=" + name + ", order=" + order + "]";
}
}
/**
*
*/
package com.itheima.course.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* @description SortB测试类
* @author ...
* @date 2021-02-07 17:18:09
*/
public class SortBTest {
public static void main(String[] args) {
// 示例:
List<SortA> listA = new ArrayList<SortA>();
SortA a1 = new SortA();
a1.setName("a");
a1.setOrder(2);
SortA a2 = new SortA();
a2.setName("b");
a2.setOrder(1);
SortA a3 = new SortA();
a3.setName("c");
a3.setOrder(5);
listA.add(a1);
listA.add(a2);
listA.add(a3);
Collections.sort(listA, new Comparator<SortA>() {
public int compare(SortA s1, SortA s2) {
/**
* 升序排的话就是第一个参数.compareTo(第二个参数); 降序排的话就是第二个参数.compareTo(第一个参数);
*/
return s2.getOrder().compareTo(s1.getOrder());
}
});
System.out.println("降序排序后: " + listA.toString());
// 结果
// 降序排序后: [SortA [name=c, order=5], SortA [name=a, order=2], SortA [name=b, order=1]]
}
}
二、Collections.sort()和Arrays.sort()排序案列
package com.itheima.course.collection;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;
/**
* @description 测试主类
* @author ...
* @date 2021-02-03 08:43:19
*/
public class TestMain {
/**
* 按ASCII码升序排序 Arrays.sort
*
* @param data 待排序数据
* @return 排序后数据
*/
public static String arraysSort(final Map<String, String> data) {
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[keySet.size()]);
Arrays.sort(keyArray);
// 构造URL 键值对的格式
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
// 参数值为空,则不参与签名
if (data.get(k).trim().length() > 0) {
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
}
if (sb.length() > 0) {
sb.deleteCharAt(sb.length() - 1);
}
return sb.toString();
}
/**
* 按ASCII码降序排序 Collections.sort
*
* @param data 待排序数据
* @return 排序后数据
*/
public static String collectionssSort1(final Map<String, String> data) {
Set<String> keySet = data.keySet();
String[] keyArray = keySet.toArray(new String[keySet.size()]);
List<String> keyList = Arrays.asList(keyArray);
Collections.sort(keyList, new Comparator<String>() {
@Override
public int compare(String paramT1, String paramT2) {
return paramT2.compareTo(paramT1);
}
});
// 构造URL 键值对的格式
StringBuilder sb = new StringBuilder();
for (String k : keyArray) {
// 参数值为空,则不参与签名
if (data.get(k).trim().length() > 0) {
sb.append(k).append("=").append(data.get(k).trim()).append("&");
}
}
if (sb.length() > 0) {
sb.deleteCharAt(sb.length() - 1);
}
return sb.toString();
}
/**
* 按ASCII码降序排序 Collections.sort
*
* @param data 待排序数据
* @return 排序后数据
*/
public static String collectionssSort2(final Map<String, String> data) {
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(data.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
@Override
public int compare(Entry<String, String> paramT1, Entry<String, String> paramT2) {
return (paramT1.getKey()).toString().compareTo(paramT2.getKey());
}
});
// 构造URL 键值对的格式
StringBuilder sb = new StringBuilder();
for (Map.Entry<String, String> item : list) {
String key = item.getKey();
String value = item.getValue();
// 参数值为空,则不参与签名
if (value != null && (!"".equals(value.trim()))) {
sb.append(key).append("=").append(value.trim()).append("&");
}
}
if (sb.length() > 0) {
sb.deleteCharAt(sb.length() - 1);
}
return sb.toString();
}
public static void main(String[] args) {
Map<String, String> sortMap = new HashMap<String, String>();
sortMap.put("zx", "123");
sortMap.put("zz", "456");
sortMap.put("aa", "789");
// 按ASCII码升序排序
System.out.println(arraysSort(sortMap));
System.out.println("按ASCII码降序排序 Collections.sort: " + collectionssSort1(sortMap));
System.out.println("按ASCII码降序排序 Collections.sort: " + collectionssSort2(sortMap));
/*
* 结果:
* aa=789&zx=123&zz=456
* zz=456&zx=123&aa=789
* aa=789&zx=123&zz=456
*/
// 目的: 比较器Comparator的
@SuppressWarnings(value = { "unused" })
Comparator<Integer> comp = new Comparator<Integer>() {
@Override
public int compare(Integer paramT1, Integer paramT2) {
return paramT1 - paramT2;
}
};
Set<Integer> set = new TreeSet<Integer>(comp);
set.add(33);
set.add(10);
set.add(55);
System.out.println(set);
}
}