Collection接口

Collection<E>接口，常见的三个已实现接口是List<E>、Set<E>、Map<E>。

通用的常见方法

• add()添加一个元素，可以指定脚标
• addAll()将一个collection放入
• clear()清除
• remove()删除元素，返回该元素
• retainAll()将两个collection取交集
• removeAll()删除两个集合相同的部分
• iterator()返回该集合的迭代器
• toArray()转为数组

// 部分通用方法演示
import java.util.ArrayList;
import java.util.List;

public class CollectionDemo {
    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>();
        a.add(1);
        a.add(2);
        a.add(3);
        List<Integer> b = new ArrayList<>(a); // 用另一个集合来初始化
        b.add(4);
        b.add(5);
        b.add(6); // b现在是[1, 2, 3, 4, 5, 6]
        b.clear(); // b现在为空
        b.addAll(a); // 将另一个集合全放入
        b.forEach(System.out::println);
        b.remove(2); // 移走了元素'3'
        System.out.println(b.contains(2));
        System.out.println(a.retainAll(b));
        a.forEach(System.out::println); // a和b取交集，只剩下1、2
        System.out.println("------------");
        a.add(3);
        a.removeAll(b);
        // a移走了和b相同的部分1、2，只剩3
        a.forEach(System.out::println);
    }
}

遍历集合的几个方法

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CollectionDemo {
    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>();
        a.add(1);
        a.add(2);
        a.add(3);
        a.add(0, 0); // 指定下标加入元素
        // 三种方法打印每个元素
        // 迭代器的用法
        for (Iterator<Integer> it=a.iterator(); it.hasNext();) {
            System.out.println(it.next());
        }
        for (Integer each : a) {
            System.out.println(each);
        }
        a.forEach(System.out::println);
    }
}

迭代过程中若还进行了set、add操作，可能会发生异常，普通的Iterator不适用了，换用ListIterator it = a.listIterator();。

List<E>

三个已实现类有ArrayList 、Vector、LinkedList。他们的区别如下：

• Vector的内部是数组数据结构，是同步的，线程安全，速度慢效率低。
• ArrayList可以看做Vector的替代，不同步，线程不安全，速度快效率高，一般用这个就行。
• LinkedList具有链表的数据结构，增删元素速度很快。数组增删元素，要顺延之后所有的元素，速度慢；但是数组查找速度快，根据下标能快速索引。注意，LinkedList也不是同步的。

ArrayList的部分方法已经在上面的例子演示过了，其他常用方法如可用get(index)方法来获取元素，类似下标索引。indexOf(object o)可以获取指定元素的首次出现的下标，set()指定脚标处的元素，hasNext()判断是否还有下个元素的修改。

LinkedList还有其独特的方法。比如addFirst/addLast分别在表头和表尾添加元素。removeFirst/removeLast分别移除第一个和最后一个元素。indexOf/lastIndexOf指定元素首次出现/最后一次出现的下标。getFirst/getLast获取第一个/最后一个元素。等等。

Set<E>

List里面存放的元素可以重复，但是Set里面存放的元素不允许重复。通常使用的有HashSet和TreeSet。

• HashSet内部是哈希表结构，即先判断哈希值（hashCode）是否相同，再判断内容是否相同（equals）而ArrayList只判断equals()

• TreeSet默认按照自然顺序对其中的元素进行排序，也可以实现Comparator接口，对里面的元素进行指定顺序的排序。

  List<Integer> b = new ArrayList<>();
  b.add(3);
  b.add(1);
  b.add(2);
  Set<Integer> a = new TreeSet<>(b);
  a.forEach(System.out::println); // 打印自然顺序的1、2、
  
  class Abc implements Comparator {}
  Set<Integer> a = new TreeSet(new Abc()); // 传入一个比较器，在初始化的时候就具有比较功能
  

Map<K, V>

常用的是Hashtable、HashMap、TreeMap

• value put(key, value)返回前一个被替代的value，若无前一个返回null
• remove(key)删除该件对应的键值对。
• get(key)获取该键对应的值。
• values()获取全部值放入一个Collection。
• Set<E> keys = a.keyset()取出所有的key放入一个Set中
• Set<Map.Entry<K, V>> kv = a.entrySet()

Map<String, Integer> a = new HashMap<>();
     a.put("a", 1);
     a.put("b", 2);
     a.put("c", 3);
     Set<String> keys = a.keySet();
// 只能获取键
     for (String key : keys) {
         System.out.println(a.get(key));
     }
// Map.Entry<K, V>可以获取键和值
     Set<Map.Entry<String, Integer>> kv = a.entrySet();
     for (Map.Entry<String, Integer> me : kv) {
         System.out.println(me.getKey() + " : " + me.getValue());
     }

• HashMap内部数据结构是哈希表，不同步，允许null
• Hashtable内部数据结构是哈希表，同步，不允许null（其下的properties可以用来储存键值配置文件信息）
• TreeMap内部数据结构是二叉树，不同步，可对键排序

总结

• 需要唯一吗？是的话用Set，否则List。List里需要频繁增删吗？是的话LinkedList，否则ArrayList。
• 需要顺序吗？是的话Tree，否则Hash（无序）。
• 看到array就要想到数组、查询、脚标。
• 看到Link就想起链表，add、get、remove等方法都有first和last操作。
• 看到Hash就想到覆盖hashcode()和equals()方法
• 看到Tree就想到二叉树，可实现排序。和两个接口有关，一个需要implements Comparable并覆盖compareTo()，另外一个implements Comparator，覆盖compare()。
  注意：遍历集合是为了更方便操作每个元素，其实可以直接写System.out.println()里面放List，Map， Set的实例都可以，因为重写了toString方法，所以看起来很美观。

泛型

public class TemplateDemo<Element> {
  // 用的类的泛型参数
    public Element show(Element e) {
        System.out.println(e);
        return e;
    }
  // 可以和类的泛型参数不一样
    public <T> T run(T t) {
        System.out.println(t);
        return t;
    }
  // 静态方法不能使用类的泛型参数（Element），因为静态方法无需使用对象
    public static Element ss( ) {
        //false
    }
  // 但是静态方法可以使用和类不一样泛型参数
   public static <T> T run_2(T t) {
        System.out.println(t);
        return t;
    }
  // 通配符'?',可匹配任意类型
  List<?> a = new ArrayList<>();
}

泛型限定

• 上限：<? extends E>，接收E或者E的子类。
• 下限：<? super E>，接收E或者E的父类。

Collections、Arrays工具类

顾名思义，类中包含了许多操作集合、数组的功能。

Collections

• Collections.sort()可对传入的集合排序，还可传入一个比较器。
• Collections.binarySearch()可直接使用二分查找。
• Collections.max/min()可快速找出集合中的最大/最小值。
• Collections.fill()可以给集合中每个元素初始化为相同的值。
• Collections.shuffle()随机打乱顺序。
• Collections.synchronizedList()返回一个同步（线程安全）的List。

Arrays

• Arrays.asList()数组转为列表。
• Arrays.binarySearch()当然也可以直接使用二分查找。
• copyOf()复制数组，可指定长度。copyOfRange()指定范围截取数组复制。
• Arrays.sort()当然也有排序。
• Arrays.toString()可以直接打印数组

可变参数，用...表示，可代表任意个参数，必须作为最后一个参数

 public static int add(int a, int ...arr) {
        int sum = a;
        for (int each :arr) {
            sum += each;
        }
        return sum;
    }

    public static void main(String[] args) {
        int val = add(3, 4, 5, 6);
        System.out.println(val); // 18
    }

Math类

• sin/cos/tan、PI、pow、max/min、abs都是常用的数学计算方法。
• Math.ceil()/floor()分别是向上和向下取整。
• Math.round()是四舍五入。
• Math.random()随机产生0.0~1.0之间的小数。

by @suhaiyu

2017.1.8