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()
数组	对每个元素进行上述操作