java中有序的map java有序的list

List、Set和Map的区别

	List	Set	Map
元素顺序	有序	无序	key无序、value无序
元素是否可重复	可重复	不可重复	key不可重复、value可重复

List

注意：List中存储的元素有序，指的是读出的顺序与存入的顺序是一致的，这叫做有序。比如说List添加了元素1,3,2，那么循环遍历List读出的元素顺序也是1,3,2，而不是1,2,3，这才叫List的存储元素有序。

public class Demo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        // 读入的顺序是：1，3，2
        list.add(1);
        list.add(3);
        list.add(2);
        // 取出的顺序也是：1，3，2
        System.out.println(list);
    }
}
/**
 * 打印结果：
 * [1, 3, 2]
 */

而元素可重复，指添加到List集合中的元素可以是重复的元素，重复的元素可以是值相等的基本数据类型数据，也可以是重写equals和hashCode方法的对象。

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Demo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        // 添加重复元素
        list.add(1);
        list.add(1);
        list.add(2);
        System.out.println(list);

        // 添加重复对象
        List<Person> personList = new ArrayList<>();
        Person p1 = new Person("张三");
        Person p2 = new Person("张三");
        personList.add(p1);
        personList.add(p2);
        System.out.println(personList);
    }
}
/**
 * 打印结果：
 * [1, 1, 2]
 * [Person{name='张三'}, Person{name='张三'}]
 */

Set

注意：Set存储的元素是无序的，这里的无序指的是存入的顺序与输出的顺序可能是不一致的。例如存入的元素顺序是1,3,2，那么输出的元素顺序可能是1,2,3或者其他，这取决于hashCode值。因为元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，所以输出顺序是按照hashCode值来的。

public class Demo {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        // 输入元素的顺序是：1,3,2
        set.add(1);
        set.add(3);
        set.add(2);
        // 输出元素的顺序是：1,2,3
        System.out.println(set);
    }
}
/**
 * 打印结果：
 * [1, 2, 3]
 */

Set存储的元素是不允许重复的，无论是基本数据类型的元素还是对象。

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Demo {
    public static void main(String[] args) {
        // 存入基本数据类型的重复元素
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(1);
        set.add(2);
        System.out.println(set);

        // 存入重写了equals和hashCode方法的对象
        Set<Person> personSet = new HashSet<>();
        personSet.add(new Person("张三"));
        personSet.add(new Person("张三"));
        personSet.add(new Person("李四"));
        System.out.println(personSet);
    }
}
/**
 * 打印结果：
 * [1, 2]
 * [Person{name='李四'}, Person{name='张三'}]
 */

Map

Map存储的元素是键值对（key-value），键和值都是无序的，即存入顺序与输出顺序可能都不一样。

public class Demo {
    public static void main(String[] args) {
        // key可能是无序的，value也可能是无序的
        /*
            键key输入顺序是：3,2,1
            值value输入顺序是：a,b,c
         */
        Map<Integer,String> map=new HashMap<>();
        map.put(3,"a");
        map.put(2,"b");
        map.put(1,"c");
        System.out.println(map.keySet());// 打印键
        System.out.println(map.values());// 打印值
    }
}
/**
 * 打印结果：
 * [1, 2, 3]
 * [c, b, a]
 */

Map中要求键（key）不重复，但允许值（value）重复。

public class Demo {
    public static void main(String[] args) {
        // 如果键名重复，那么只会保存一个，即会去重
        Map<Integer,Integer> map=new HashMap<>();
        map.put(1,1);
        map.put(1,2);
        map.put(1,3);
        System.out.println(map);
        // 如果键值重复，那么是可以的
        Map<Integer,Integer> map2=new HashMap<>();
        map2.put(1,1);
        map2.put(2,1);
        map2.put(3,1);
        System.out.println(map2);
    }
}
/**
 * 打印结果：
 * {1=3}
 * {1=1, 2=1, 3=1}
 */