java 重新学习 （五）

Set 集合

一、HashSet按照Hash算法存储集合元素（hashCode方法获取hashCode值，根据hashCode值获取元素位置，通过equals判断对象是否相等并且hashCode值是否相等），因此具有很好的查找和存取的性能。排列顺序不固定，非线程安全，集合元素可以为空，不允许重复。

二、LinkedHashSet（HashSet子类）链表维护元素次序（因此插入，删除性能低于HashMap），迭代访问Set里的全部元素性能较好，不允许重复。

三、iterator（foreach）迭代某个集合时，迭代内集合不可以remove操作集合本身，但是可以通过iterator的remove方法移除集合元素。

四、TreeSet（SortedSet） 按照自然排序和定制排序排序。默认采用自然排序（升序）。对象添加到TreeSet时，该对象必须实现Comparable接口，否则ClassCastException异常。

五、TreeSet结合判断两个对象是否相等的唯一标准是：两个对象通过compareTo方法比较是否返回0。、

六、TreeSet自然排序，元素必须实现Comparable接口  TreeSet ts = new TreeSet();  ts.add(new Student());  Student 类必须实现Comparable；

//对象类
public class Father implements Comparable<Father> {
    private String  name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Father() {
        System.out.println("父类无参构造");
    }
    public Father(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Father [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(Father o) {
        Father father = o;
        return this.name.compareTo(father.getName());
    }

}

//验证排序
        @Test
    public void method2(){
        TreeSet<Father> fathers = new TreeSet<>();
        fathers.add(new Father("a",10));
        fathers.add(new Father("c",10));
        fathers.add(new Father("b",10));
        for (Father father : fathers) {
            System.out.println(father);
        }
    }
输出结果为
Father [name=a, age=10]
Father [name=b, age=10]
Father [name=c, age=10]

TreeSet自然排序

　　TreeSet定制排序，创建集合时，TreeSet ts = new TreeSet ( (o1,o20 -> {   compareTo自定义  }）；通过Comparator与TreeSet整合完成自定义排序

    @Test
    public void method4(){
        TreeSet<Father> fathers = new TreeSet<>((x,y)->{
            return x.getAge().compareTo(y.getAge());
        });
        fathers.add(new Father("a",29));
        fathers.add(new Father("b",24));
        fathers.add(new Father("c",12));
        for (Father father : fathers) {
            System.out.println(father);
        }
    }
//输出结果
Father [name=c, age=12]
Father [name=b, age=24]
Father [name=a, age=29]

可以对比上面的自然排序，虽然Father类已经设置了自然排序，但是我在声明Set集合时，声明了定制排序，所以输出结果并没有按照上面自然排序的name来排序，而是按照age来排序的

TreeSet定制排序

七、EunmSet不允许null值。

八、HashSet性能比TreeSet好(特别是最常用的添加，查询等操作)，TreeSet（SortedSet实现类）需要额外的红黑树算法来维护元素的次序。

九、Set的三个实现类都是线程不安全的。TreeSet  HashSet EnumSet

List集合

一、List有序集合，有序，List判断对象是否相等，通过equals返回true判断，通过sort方法实现函数式接口Comparator来实现数组排序

二、ArrayList基于数组实现的List类(动态可分配的，超过数组容量，会在底层重新分配一个新的数组来存储数据),ArrayList非线程安全，Vector线程安全，Vector提供一个Stack的子类。

三、Queue 先进先出，PriorityQueue违背了先进先出原则。ArrayDeque实现了Deque接口，它是基于数组的双端队列

四、数组形式保存集合元素的例如ArrayList ,ArrayDeque, 随机访问元素性能较好。LinkedList这种链式存储数据的在删除，插入较快，随机访问元素性能较差;:LinkedList实现了Deque接口，所以是双端队列。

Map

一、HashMap非线程安全，允许key值重复。Hashtable线程安全，不允许key值为空.。判断元素不重复跟Set一样，key值得equals方法返回true，hashCode方法获取的值相等。

二、LinkedHashMap 迭代输出元素时，会按添加key-value的殊勋输出。

三、Properties类是Hashtable的子类，相当于一个key，value都是String类型的Map。

四、TreeMap存储key-value对时，需要根据key对节点进行排序，TreeMap可以保证所有的key-value对处于有序状态，两种排序方式

　　自然排序：所有的key必须实现Comparable接口，而且所有的key应该是同一个类的对象。

public class Father implements Comparable<Father> {
    private String  name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Father() {
        System.out.println("父类无参构造");
    }
    public Father(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Father [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(Father o) {
        Father father = o;
        return this.name.compareTo(father.getName());
    }
}

//测试方法
    @Test
    public void method5(){
        Map<Father, String> map = new TreeMap<>();
        map.put(new Father("c",23), "父亲3");
        map.put(new Father("b",28), "父亲2");
        map.put(new Father("a",54), "父亲1");

        Set<Father> sets = map.keySet();
        for (Father father : sets) {
            System.out.println("father对象"+father+"----------father值"+map.get(father));
        }
    }

//输出结果
father对象Father [name=a, age=54]----------father值父亲1
father对象Father [name=b, age=28]----------father值父亲2
father对象Father [name=c, age=23]----------father值父亲3

TreeMap的自然排序

　定制排序：创建TreeMap时传入一个Comparator对象，该对象负责对TreeMap中所有的key进行排序。采用定制排序不要求Map的key实现Comparable接口

    @Test
    public void method6(){
        Map<Father, String> map = new TreeMap<>((x,y)->{
            return x.getAge().compareTo(y.getAge());
        });
        map.put(new Father("a",54), "父亲1");
        map.put(new Father("b",28), "父亲2");
        map.put(new Father("c",23), "父亲3");

        Set<Father> sets = map.keySet();
        for (Father father : sets) {
            System.out.println("father对象"+father+"----------father值"+map.get(father));
        }
    }

//输出结果  区别TreeMap的自然排序  这回按照定制的age来排序了
father对象Father [name=c, age=23]----------father值父亲3
father对象Father [name=b, age=28]----------father值父亲2
father对象Father [name=a, age=54]----------father值父亲1

TreeMap的定制排序

Map的集中遍历方式  转载自https://www.cnblogs.com/homeword/p/7396414.html

public class LambdaMap {

    private Map<String, Object> map = new HashMap<>();

    @Before
    public void initData() {
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        map.put("key4", 4);
        map.put("key5", 5);
        map.put("key5", 'h');
    }

    /**
     * 遍历Map的方式一
     * 通过Map.keySet遍历key和value
     */
    @Test
    public void testErgodicWayOne() {
        System.out.println("---------------------Before JAVA8 ------------------------------");
        for (String key : map.keySet()) {
            System.out.println("map.get(" + key + ") = " + map.get(key));
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.keySet().forEach(key -> System.out.println("map.get(" + key + ") = " + map.get(key)));
    }

    /**
     * 遍历Map第二种
     * 通过Map.entrySet使用Iterator遍历key和value
     */
    @Test
    public void testErgodicWayTwo() {
        System.out.println("---------------------Before JAVA8 ------------------------------");
        Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Object> entry = iterator.next();
            System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue());
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.entrySet().iterator().forEachRemaining(item -> System.out.println("key:value=" + item.getKey() + ":" + item.getValue()));
    }

    /**
     * 遍历Map第三种
     * 通过Map.entrySet遍历key和value，在大容量时推荐使用
     */
    @Test
    public void testErgodicWayThree() {
        System.out.println("---------------------Before JAVA8 ------------------------------");
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue());
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.entrySet().forEach(entry -> System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue()));
    }

    /**
     * 遍历Map第四种
     * 通过Map.values()遍历所有的value，但不能遍历key
     */
    @Test
    public void testErgodicWayFour() {
        System.out.println("---------------------Before JAVA8 ------------------------------");
        for (Object value : map.values()) {
            System.out.println("map.value = " + value);
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.values().forEach(System.out::println); // 等价于map.values().forEach(value -> System.out.println(value));
    }

    /**
     * 遍历Map第五种
     * 通过k,v遍历，Java8独有的
     */
    @Test
    public void testErgodicWayFive() {
        System.out.println("---------------------Only JAVA8 ------------------------------");
        map.forEach((k, v) -> System.out.println("key:value = " + k + ":" + v));
    }
}

//通过查看第五种 java源代码，还是通过KeySet()方法实现遍历的。

Map的集中遍历方式

五、WeekHashMap 中每个key对象支持有对实际对象的弱引用，当垃圾回收了该key值所对应的实际对象后，WeakHashMap会自动删除该key对应的key-value.

六、IdentityHashMap实现机制与HashMap基本相似，但它处理两个key相等时比较必须 key1==key2 才行，不像HashMap只需要保证key1.equals(key2)并且他们的hashCode值相等。

七、各类Map性能分析

　　1.HashMap 与Hashtable实现机制几乎一样，但是HashMap要快，LinkedHashMap比HashMap慢一点因为要维护底层链表。

　　2.TreeMap比HashMap和Hashtable都要慢，因为底层是红黑树实现的，插入删除操作更慢。但是优势是可以排序

　　3.EnumMap速度最快但是它只能使用同一个枚举类的枚举值作为key

八、Collections集合操作工具类

　　1.synchronizedXXX解决线程安全问题

　　2.java9  List.of() Set.of() Map.of()快速创建集合对象。

Set本身不保证顺序这是正确的(它无下标,无位置,必须用迭代器取元素,它只能加 减和删 不能查),但是它的
实现类就一定了(因为子类是父接口的扩展啊),例如:HashSet就无序,但TreeSet它的直接父类是SortedSet,它里面的元
素是有序的(你从它们的名字上就可以看出来),它的排序标准是Comparator
或Comparable 里的compare() 或compareTo()方法(如果TreeSet里要添加的元素是你自己定义的类型话Comparator
和Comparable这两个接口你一定要实现一个,顺便重写里面的方法)

同理Map也是。