Collection

////////////2016-11-9 ~ 2016-11-11///////////

int study_data(){

Collection接口：

Collection是最基本的集合接口，

所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这 个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。

典型的用法如下：

Iterator it = collection.iterator();// 获得一个迭代子

while(it.hasNext()) {

    Object obj = it.next();// 得到下一个元素

}

List接口：

List继承自Collection接口。List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

跟Set集合不同的是，List允许有重复元素。对于满足e1.equals(e2)条件的e1与e2对象元素，可以同时存在于List集合中。当然，也有List的实现类不允许重复元素的存在。

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类：

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法。insert方法能插入元素在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

List list = Collections.synchronizedList(newLinkedList(...));

ArrayList类：

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并 没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Set接口:

Set继承自Collection接口。Set是一种不能包含有重复元素的集合，即对于满足e1.equals(e2)条件的e1与e2对象元素，不能同时存在于同一个Set集合里，换句话说，Set集合里任意两个元素e1和e2都满足e1.equals(e2)==false条件，Set最多有一个null元素。

因为Set的这个制约，在使用Set集合的时候，应该注意：

1，为Set集合里的元素的实现类实现一个有效的equals(Object)方法。

2，对Set的构造函数，传入的Collection参数不能包含重复的元素。

HashSet类:

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证集合的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

HashSet不是同步的，需要用以下语句来进行S同步转换：

Set s = Collections.synchronizedSet(new HashSet(...));

TreeSet：

Comparable排序：由类实现Comparable接口，重写CompareTo方法进行排序

public int compareTo(Dog o) {

    return name.compareTo(o.name);

}

Set set4 = new TreeSet();

Comparator排序：自己定义一个实现了 Comparator接口的排序方法进行排序

class AgeNameComparator implements Comparator{

    public int compare(Dog o1, Dog o2) {

        if(o1.age == o2.age)return o1.name.compareTo(o2.name);

        else if(o1.age < o2.age)return -1;

        else return 1;

    }

}

Set set5 = new TreeSet(new AgeNameComparator());

Map：

map作为一个重要的数据结构，最大的优点是支持随机访问。即通过key随机访问值。

在java中的map是一个接口，不能直接实例化，所以需要把实现了map的实现类对象给map赋值。比如可以这样实例化一个map：

Map map = new HashMap();

当map中不存在对应的键时返回null

HashMap实现的map实例是无序的

TreeMap：

Comparable排序：

Map map3 = new TreeMap();

System.out.println("这是一个放入引用数据类型的TreeMap(Comparable排序):");

for(Map.Entry entry:map3.entrySet()){

        System.out.println(entry);

    }

}

Comparator排序：

ValueComparator value = new ValueComparator(map3);

TreeMap map4 = new TreeMap(value);

System.out.println("这是一个放入引用数据类型的TreeMap(Comparator排序):");

map4.putAll(map3);

for(Map.Entry entry:map4.entrySet()){

          System.out.println(entry);

 }

int misson(){

已知有一个Worker类，包括name(String), age(int)和salary(double)三个属性，toString()方法，以及一个work()方法，work方法打印如下格式的句子：

#姓名#开始工作。。。

#姓名#完成工作。。。

任务：

1) 完成一个list，在List 中增加3个工人，基本信息如下：

姓名 年龄 工资

张三 18 3000

李四 25 3500

王五 22 3200

2) 在李四之前插入一个工人，信息为：

姓名：赵六，年龄：24，工资3300

3) 删除王五 的信息

4) 利用for 循环遍历，打印List 中所有工人的信息

5) 利用迭代遍历，对List 中所有的工人调用work 方法。

6) 为Worker 类重写equals 方法，当姓名、年龄、工资全部相等时候才返回true

代码如下：

public class Worker {

    String name;

    int age;

    double salary;

    public Worker(String name,int age,double salary){

        this.name = name;

        this.age = age;

        this.salary = salary;

     }

    public void work(){

        System.out.println(name+"开始工作----");

        System.out.println(name+"完成工作----");

    }

    public String toString(){

        return "[name="+name+",age="+age+",salary="+salary+"]";

    }

    public boolean equals(Object o){

        if(!(o instanceof Worker)){

        return false;

        }else if(o == this){

            return true;

        }else{

            return this.name==((Worker)o).name&&this.age==((Worker)o).age&&

            this.salary==((Worker)o).salary;

        }

     }

}

TestWorker:

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class TestWorker {

    public static void main(String[] args) {

        Listworklist = new ArrayList();

        System.out.println("在List 中增加3个工人");        

        Worker w = new Worker("张三",18,3000);        

        Worker w1 = new Worker("李四",25,3500);       

        Worker w2 = new Worker("王五",22,3200);        

        System.out.println("==================");        

        worklist.add(w);

        worklist.add(w1);

        worklist.add(w2);

        System.out.println("在李四之前插入一个工人赵六");

        Worker w3 = new Worker("赵六",24,3300);

        worklist.add(1,w3);

        System.out.println("==================");

        System.out.println("删除王五 的信息");

        worklist.remove(w2);

        System.out.println("==================");

        System.out.println("利用for 循环遍历，打印List 中所有工人的信息:");

        for(Worker worker:worklist){

            System.out.println(worker);

        }

        System.out.println("==================");

        System.out.println("利用迭代遍历，对List 中所有的工人调用work 方法:");

        Iteratorit = worklist.iterator();

        while(it.hasNext()){

            it.next().work();

        }

        System.out.println("==================");

        System.out.println("为Worker 类重写equals 方法，当姓名、年龄、工资全部相等时候才返回true:");

        Worker w4 = new Worker("王五",22,3200);

        Worker w5 = new Worker("王五",23,3200);

        System.out.println(w4.equals(w2));

        System.out.println(w5.equals(w2));

      }   

 }

}