Java知识复习（集合）

1.Collection和Iterator接口

Collection接口是List ，Set ，Queue 接口的父接口 。主要用于盛庄其他对象。
Iterator接口主要用于遍历Collection集合中的元素，Iterator对象被称为迭代器。

public class TestCollection {    public static void main(String[] args) {        Collection<String> collection = new HashSet<>();        collection.add("asas");        collection.add("qwqw");        collection.add("zzzz");        Iterator<String> iterator = collection.iterator();        while (iterator.hasNext()) {            System.out.println(iterator.next());        }    }}

没有集合的Iterator没有存在的价值。
在使用Iterator迭代集合的过程中不可以修改集合元素，会引发java.util.ConcurrentModificationException.

public class TestCollection {    public static void main(String[] args) {        Collection<String> collection = new HashSet<>();        collection.add("asas");        collection.add("qwqw");        collection.add("zzzz");        Iterator<String> iterator = collection.iterator();        while (iterator.hasNext()) {            String s = iterator.next();            System.out.println(s);            collection.add("aaaa");            System.out.println(s);        }    }}

---

2.Set集合

Set集合中的元素没有顺序，不允许包含相同的元素。

Set 存入Set的每个元素必须是唯一的，加入Set的元素必须定义equals()方法确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。 HashSet 为快速查找而设计的Set。存入HashSet的元素必须定义hashCode()方法。 TreeSet 保持次序的Set，底层为树结构。使用 它可以从Set中提取有序的序列。元素必须实现Comparable接口。 LinkedHashSet 具有HashSet的查询速度，且内部使用链表维护元素的顺序（插入的次序）。于是在使用迭代器遍历Set时，结果会按照插入的次序显示。元素也必须定义hashCode()方法

如果没有其他条件限制，默认选择HashSet，因为它对速度进行了优化。

HashSet

HashSet的特点：

• 元素是无序的，顺序有可能发生变化
• HashSet不是线程同步的，如果多个线程同时访问一个HashSet，则需要通过代码来保证同步
• 集合元素值可以是null

判断HashSet元素是否相同的条件是两个对象通过equals()方法比较返回true，并且两个对象的hashCode()方法返回值相等。

重写hashCode()方法的基本规则：

• 程序运行的过程中，同一个对象调用同一个hashCode()方法应该返回相同的值。
• 两个对象通过equals()方法返回true时，这两个对象的hashCode()方法应该返回相等的值。
• 对象中用作equals()比较的Field，都应该用来计算hashCode值。

package com.lwcode.intent;public class Student {    private String name;    private int age;    private double height;    @Override    public int hashCode() {        final int prime = 31;        int result = 1;        result = prime * result + age;        long temp;        temp = Double.doubleToLongBits(height);        result = prime * result + (int) (temp ^ (temp >>> 32));        result = prime * result + ((name == null) ? 0 : name.hashCode());        return result;    }    @Override    public boolean equals(Object obj) {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;        Student other = (Student) obj;        if (age != other.age)            return false;        if (Double.doubleToLongBits(height) != Double.doubleToLongBits(other.height))            return false;        if (name == null) {            if (other.name != null)                return false;        } else if (!name.equals(other.name))            return false;        return true;    }}

---

LinkedHashSet类

LinkedHashSet是HashSet的子类，LinkedHashSet也是根据元素的hashCode值来决定存储位置，同时LinkedHashSet使用了链表来维护元素次序，所以元素在LinkedHashSet中以插入的顺序保存。
LinkedHashSet性能比HashSet略低。

---

TreeSet类
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合中的元素处于排序状态。
TreeSet采用红黑树的数据结构来保存集合元素，TreeSet支持两种排序方法：自然排序和定制排序。（默认为自然排序）

1.自然排序
TreeSet的排序由Comparable接口定义的compareTo()方法决定，该方法返回一个整数值（为正整数则表明大于，0表明等于，负整数表明小于）。
实现了Comparable接口的常用类有：

• BigDecimal、BigInteger及所有数值类型对应的包装类：按数值大小进行比较。
• Character：按字符的UNICODE值比较。
• Boolean：true对应的包装类实例大于false对应包装类的实例。
• String：按字符串中字符的UNICODE值比较。
• Date、Time：Time的时间、日期比Date的时间、日期大。

如果将一个对象添加到TreeSet中，则该对象的类必须实现Comparable接口，否则会抛出异常。

2.定制排序
实现定制排序需要提供一个Comparator对象。由Comparator对象负责元素的排序逻辑。

public class TreeSetTest {    public static void main(String[] args) {        TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {            @Override            public int compare(Integer o1, Integer o2) {                // 采用倒序排序                return o1 > o2 ? -1 : o1 < o2 ? 1 : 0;            };        });        treeSet.add(23);        treeSet.add(-2);        treeSet.add(2);        treeSet.add(2);        System.out.println(treeSet);//[23, 2, -2]    }}

TreeSet判断两个元素相等的标准：通过Comparator比较两个元素返回值为0，则不会添加第二个元素。

---

EnumSet类

• EnumSet中的所有元素必须是指定枚举类型的枚举值。
• EnumSet也是有序的，以枚举值在Enum类内的定义顺序来决定元素的顺序。
• EnumSet中不能加入null。
• EnumSet通过static方法来创建对象。

public class EnumSetTest {    public static void main(String[] args) {        EnumSet<Test> enumSet = EnumSet.allOf(Test.class);        System.out.println(enumSet);// [FIRST, SECOND, THIRD]    }}enum Test {    FIRST, SECOND, THIRD}

---

Set实现类的性能

• HashSet的性能总是比TreeSet好（特别是常用的添加、查询等操作）。
• 只有当需要一个保持排序的Set集合时才应该用TreeSet。
• LinledHashSet在普通的插入、删除等操作比HashSet要慢一点，因为维护链表有额外的开销。有了链表，遍历LinkedHashSet会更快。
• EnumSet性能最好，不过EnumSet中只能保存同一个枚举类的枚举值。
• HashSet、TreeSet和EnumSet都是线程不安全的。

---

3.List集合

List是有序集合，所以List集合里有一些方法可以根据索引来操作集合元素。（具体方法可参考api文档）。

ArrayList和Vector类

• 两个都是基于数组实现的List类，底层是一个Object类型的数组
• 两个对象使用initialCapacity参数来设置数组长度，默认长度为10，当添加的元素超过数组的长度时，initialCapacity参数会自动增加。
• ArrayList是线程不安全的，速度快；Vector是线程安全的，速度慢。

ArrayList与LinkedList类

• ArrayList底层是数组，所以查询速度快，但是添加和删除等操作性能比较差。
• LinkedList底层是双向循环列表，查询速度慢，但是添加和删除等操作性能高。

---

4.Queue集合

队列通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。

PriorityQueue实现类

一个基于优先级堆的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。优先级队列不允许使用 null 元素。依靠自然顺序的优先级队列还不允许插入不可比较的对象（这样做可能导致 ClassCastException）。

Deque接口
一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

ArrayDeque实现类
数组双端队列没有容量限制；它们可根据需要增加以支持使用。它们不是线程安全的；在没有外部同步时，它们不支持多个线程的并发访问。禁止 null 元素。此类很可能在用作堆栈时快于 Stack，在用作队列时快于 LinkedList。

public class TestDemo01 {    public static void main(String[] args) {        Deque<Integer> deque = new ArrayDeque<>();        for (int i = 0; i < 7; i++) {            deque.addFirst(i);        }        for (int i = 10; i < 15; i++) {            deque.addLast(i);        }        System.out.println(deque);// [6, 5, 4, 3, 2, 1, 0, 10, 11, 12, 13, 14]        while (deque.size() != 0) {            //14 6 13 5 12 4 11 3 10 2 0 1             System.out.print(deque.removeLast() + " ");            System.out.print(deque.removeFirst() + " ");        }    }}

---

5.Map集合

Map集合保存的是具有映射关系的键值对，Map中的key不可以重复，通过key来找到对应的value值，value值可以相同。

实现类 解释 HashMap Map基于散列的实现（取代了Hashtable）。插入和查询键值对的开销是固定的。可以通过构造器设置容量和负载因子，以调整容器的性能 LinkedHashMap 类似于HashMap，性能比HashMap略低，取出元素的顺序为插入时的顺序。它内部使用链表维护顺序，所以在迭代访问时速度更快。 TreeMap 基于红黑树的实现。元素的排序由Comparable或Comparator决定。TreeMap是唯一的带有subMap()方法的Map，可以返回一个子树。 WeakHashMap 弱键映射，允许释放映射所指向的对象，专为解决特殊问题设计。 ConcurrentHashMap 一种线程安全的Map，不涉及同步加锁。 IdentityMap 使用==代替equa()对key进行比较的散列映射，专为解决特殊问题设计。

HashMap与Hashtable类

• Hashtable是线程安全的，性能比HashMap略低，HashMap是线程不安全的。如果多个线程访问同一个Map集合，用Hashtable更好
• Hashtable的key和value都不可以为null，HashMap可以使用null作为key或value。
• 用作key的对象必须实现hashCode()方法和equals()方法。

LinkedHashMap类

LinkedHashMap使用双向链表，可以记住key-value对的顺序。
LinkedHashMap需要维护插入的顺序，性能比HashMap略低，但在迭代访问全部元素时有较好的性能。

Properties类

Properties类是Hashtable类的子类。

    public void initParam(String file) {        Properties properties = new Properties();        try {            properties.load(new FileInputStream(file));            driver = properties.getProperty("driver");            url = properties.getProperty("url");            user = properties.getProperty("user");            pass = properties.getProperty("pass");            Class.forName(driver);        } catch (FileNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();        } catch (ClassNotFoundException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }    }

Properties也可以吧key-value以XML文件的形式保存起来。

SortedMap接口和TreeMap实现类

TreeMap是一个红黑树数据结构，每个key-value对作为红黑树的一个节点。
TreeMap也有两种排序方式：自然排序与定制排序。（与TreeSet相同）。
如果使用自定义类作为key，则重写该类的equals()方法和compareTo()方法时应该保持一致的返回结果，equals()返回true时，compareTo()应该返回0.

自定义简单的Map

public class MyMapTest {    public static void main(String[] args) {        MyMap<String, Integer> map = new MyMap<>(5);        map.put("a", 1);        map.put("b", 2);        map.put("c", 3);        map.put("d", 4);        map.put("e", 5);        try {            map.put("f", 6);        } catch (Exception e) {            System.out.println("超过Map长度");//超过Map长度        }        /*         *  a--->1            b--->2            c--->3            d--->4            e--->5         */        System.out.println(map);        System.out.println(map.get("d"));//4    }}class MyMap<K, V> {    private Object[][] pairs;// 存放键值对的数组    private int index = 0;// 索引    public MyMap(int length) {        pairs = new Object[length][2];// Map的长度    }    public void put(K key, V value) {        if (index > pairs.length)            throw new ArrayIndexOutOfBoundsException();        pairs[index] = new Object[] { key, value };// 将key和value放入数组        index++;    }    public V get(K key) {        for (int i = 0; i < index; i++) {            if (key.equals(pairs[i][0]))                return (V) pairs[i][1];        }        return null;// 没有找到key    }    @Override    public String toString() {        StringBuilder sb = new StringBuilder();        for (int i = 0; i < index; i++) {            sb.append(pairs[i][0].toString());            sb.append("--->");            sb.append(pairs[i][1].toString());            if (i < index - 1)                sb.append("\r\n");        }        return sb.toString();    }}

---

6.操作集合的工具类Collections

排序操作

具体方法可参考api文档。

public class TestDemo01 {    public static void main(String[] args) {        List<Integer> list = new ArrayList<>();        list.add(23);        list.add(-3);        list.add(9);        list.add(-10);        System.out.println(list);// [23, -3, 9, -10]        Collections.reverse(list);// 反转list集合元素顺序        System.out.println(list);// [-10, 9, -3, 23]        Collections.sort(list);// 按自然排序        System.out.println(list);// [-10, -3, 9, 23]        Collections.shuffle(list);// 随机排序，每次都不一样        System.out.println(list);// [-10, 9, 23, -3],[-10, -3, 23, 9]...    }}

查找、替换操作

public class TestDemo01 {    public static void main(String[] args) {        List<Integer> list = new ArrayList<>();        list.add(23);        list.add(-3);        list.add(9);        list.add(-10);        System.out.println(list);// [23, -3, 9, -10]        // 输出集合中最大的        System.out.println(Collections.max(list));// 23        // 输出集合中最小的        System.out.println(Collections.min(list));// -10        Collections.replaceAll(list, -10, 0);// 将-10替换成0        System.out.println(list);// [23, -3, 9, 0]        list.add(23);        // 判断23出现的次数        System.out.println(Collections.frequency(list, 23));//2    }}

同步控制

将线程不安全的实现类包装成线程同步的集合，解决了线程安全问题。

public class TestDemo01 {    public static void main(String[] args) {        List<String> list = Collections.synchronizedList(new ArrayList<>());        Set<String> set = Collections.synchronizedSet(new HashSet<>());        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());    }}

---

正确的equals()方法必须满足下列5个条件：

1. 自反性。对任意x，x.equals(x); 一定返回true
2. 对称性。对任意x,y,如果 x.equals(y); 返回true，则y.equals(x); 一定返回true
3. 传递性。对任意x,y,z,如果x.equals(y); 返回true，y.equals(z); 返回true，则x.equals(z); 一定返回true
4. 一致性。对任意x,y,如果对象中的equals()方法没有改变，则无论调用x.equals(y); 多少次，返回的结果应该保持一致。
5. 对任何不是null的x，x.equals(null); 返回的一定是false。

如何重写hashCode()方法：

1. 给int变量result赋予某个非0值常量
2. 为每个可以做equals()操作的域f计算出一个int散列码c
3. 合并计算得到的散列码：result=17*result+c;
4. 返回result；
5. 检查hashCode()最后生成的结果，确保相同对象返回相同的值

域类型 计算方式 boolean c=(f?0:1) byte,char,short,int c=(int)f long c=(int)(f^(f>>>32)) float c=Float.floatToIntBits(f) double long l = Double.doubleToLongBits(f);c=(int)(l^(l>>>32)) Object,其equals()调用这个域的equals() c=f.hashCode() 数组 对每个元素进行上述操作