面试的时候经常会被问道这样一个问题：Java集合中哪些是有序的，哪些不是？
我们通常的回答是List、LinkedHashMap、LinkedHashSet、TreeMap、TreeSet是有序的，List、LinkedHashMap、LinkedHashSet、LinkedHashSet在遍历时会保持添加的顺序，TreeMap、TreeSet在遍历时会以自然顺序（Comparable接口的compareTo）输出。下面分别测试了一下
新建一个User类作为Map的键，还有四个填充Map、Set的方法
/**
* 实现了Comparable接口，重写了compareTo
*/
class User implements Comparable<User> {
private String name;
// 省略getter、setter、构造方法
@Override
public int compareTo(User o) {
return this.getName().compareTo(o.getName());
}
}
public static void fillMapByString(Map<String, String> map) {
map.put("33", "33");
map.put("aa", "aa");
map.put("gg", "gg");
map.put("dd", "dd");
map.put("11", "11");
map.put("ee", "ee");
map.put("aa", "aaaa");
}
public static void fillMapByUser(Map<User, String> map) {
map.put(new User("33"), "33");
map.put(new User("aa"), "aa");
map.put(new User("gg"), "gg");
map.put(new User("dd"), "dd");
map.put(new User("11"), "11");
map.put(new User("ee"), "ee");
map.put(new User("aa"), "aaaa");
}
public static void fillSetByString(Set<String> set) {
set.add("33");
set.add("aa");
set.add("gg");
set.add("dd");
set.add("11");
set.add("ee");
set.add("aa");
}
public static void fillSetByUser(Set<User> set) {
set.add(new User("33"));
set.add(new User("aa"));
set.add(new User("gg"));
set.add(new User("dd"));
set.add(new User("11"));
set.add(new User("ee"));
set.add(new User("aa"));
}
testTreeMap1的结果可以看出TreeMap在遍历时会以自然顺序输出。这个自然顺序指的是键的自然顺序，是由String类的compareTo方法决定的。
testTreeMap2的输出顺序与testTreeMap1的输出顺序一致，是因为User类实现了Comparable接口，重写了compareTo，而compareTo中直接以String类型的name属性排序
。
这里还有另一个问题，testTreeMap1、testTreeMap2中的Map都填充了7个元素，但两个方法的输出都是6个，并且都是后面的 aa的值覆盖了前面的 aa的值。
我们知道
HashMap判断两个键是否相同是依赖于键的hashCode、equals方法，但是我没有重写User的hashCode、equals方法，所以说两个new User("aa")是不同的对象，不应该被覆盖。那么现在真相就只剩一个了，TreeMap判断键是否相同不是依赖于键的hashCode、equals方法,而是键的compareTo方法，这个猜想也在TreeMap的put方法源码中得到了证实，有兴趣的同学可以去瞅一瞅。
public static void testTreeMap1() {
TreeMap<String, String> map = new TreeMap<String, String>();
fillMapByString(map);
System.out.println("===============testTreeMap1===================");
System.out.println(map.size() + "个元素：");
for (Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
public static void testTreeMap2() {
TreeMap<User, String> map = new TreeMap<User, String>();
fillMapByUser(map);
System.out.println("===============testTreeMap2===================");
System.out.println(map.size() + "个元素：");
for (Entry<User, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
图片失效请点击
TreeSet的输出顺序、元素格式和TreeMap是一样的，因为TreeSet底层就是由TreeMap实现的。
public static void testTreeSet1() {
TreeSet<String> set = new TreeSet<String>();
fillSetByString(set);
System.out.println("===============testTreeSet1===================");
System.out.println(set.size() + "个元素：");
for (String s : set) {
System.out.println(s);
}
}
public static void testTreeSet2() {
TreeSet<User> set = new TreeSet<User>();
fillSetByUser(set);
System.out.println("===============testTreeSet2===================");
System.out.println(set.size() + "个元素：");
for (User user : set) {
System.out.println(user);
}
}
图片失效请点击t
由结果可以看出LinkedHashMap可以保持元素的添加顺序。
从元素个数来看，testLinkedHashMap1保留了6个元素，是因为两个键"aa".equals("aa") == true，所以后面的覆盖了前面的；testLinkedHashMap2保留了7个元素，是因为new User("aa").equals(new User("aa")) == false，没有产生覆盖。
public static void testLinkedHashMap1() {
LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
fillMapByString(map);
System.out.println("===============testLinkedHashMap1===================");
System.out.println(map.size() + "个元素：");
for (Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
public static void testLinkedHashMap2() {
LinkedHashMap<User, String> map = new LinkedHashMap<User, String>();
fillMapByUser(map);
System.out.println("===============testLinkedHashMap2===================");
System.out.println(map.size() + "个元素：");
for (Entry<User, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
图片失效请点击
从下图可以看出LinkedHashSet可保留的元素的插入顺序，并且元素个数和LinkedHashMap的结果一样，这是因为LinkedHashSet内部是以LinkedHashMap实现的。
public static void testLinkedHashSet1() {
LinkedHashSet<String> set = new LinkedHashSet<String>();
fillSetByString(set);
System.out.println("===============testLinkedHashSet1===================");
System.out.println(set.size() + "个元素：");
for (String s : set) {
System.out.println(s);
}
}
public static void testLinkedHashSet2() {
LinkedHashSet<User> set = new LinkedHashSet<User>();
fillSetByUser(set);
System.out.println("===============testLinkedHashSet2===================");
System.out.println(set.size() + "个元素：");
for (User user : set) {
System.out.println(user);
}
}
图片失效请点击
https://gitee.com/zhaobingshuang/codes/mpcjd01zfnxv42kasw98g99