集合（一）

    在前面的学习过成中我们已经掌握了对数据的存储，我们只学到了数组的存储。数组的优点是查找快，但是一个数组被定义后，长度是不能改变的，并且增加和删除元素比较麻烦。因此我们引入了集合的使用。

    注意：集合中只能存放引用数据类型。一般的基本数据类型都是自动装箱成包装类存放在集合中。

一个一个存储的类型结构图如图所示：

  Collection 表示一组对象，它是集中、收集的意思。Collection接口的两个子接口是List、Set接口。

Collection可以通过它的实现类来创建对象，它存放的是无序和可重复的对象。

public class Test {
public static void main(String[] args) {
/*常用的方法如下：
* Collection接口：
* 增加：add(E e) addAll(Collection<? extends E> c) 
* 删除：clear()  remove(Object o) 
* 修改：
* 查看：iterator()  size() 
* 判断：contains(Object o)  isEmpty()
*/
//Collection col=new Collection();//接口不可以创建对象。
Collection col=new ArrayList();
col.add(12);//接口中只能存放引用数据类型：12会进行自动装箱 ：Integer i=12 + add(i)
col.add(46);
col.add(3);
col.add(88);
System.out.println(col);//[12, 46, 3, 88]
Collection col2=new ArrayList();
col2.add("java");
col2.add("html");
col2.add("servlet");
col.addAll(col2);
System.out.println(col);
col2.clear();
System.out.println(col2);//[]
System.out.println(col2.isEmpty());
System.out.println(col.isEmpty());

col.remove(46);
System.out.println(col);
System.out.println(col.size());

System.out.println(col.contains("java2222"));


//对集合进行遍历：（查看集合中所有元素）
//1.for循环：
// for(int i=0;i<=col.size()-1;i++){
// col.
// }无法使用普通for循环，，没有按索引取元素的方法
//2.foreach：
for(Object o:col){
System.out.print(o+"\t");
}
System.out.println("-------------");
//3.iterator()---迭代器原理
Iterator it = col.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}

}

1.List是有序可重复的容器

    List 的常用方法---常用的实现类有三个--1.ArrayList---2.LinkedList---3.Vector

具体方法的使用参考：http://www.sxt.cn/Java_jQuery_in_action/nine-list.html

ArrayList底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。

我们可以看出ArrayList底层使用Object数组来存储元素数据。所有的方法，都围绕这个核心的Object数组来开展。

我们知道，数组长度是有限的，而ArrayList是可以存放任意数量的对象，长度不受限制，那么它是怎么实现的呢?本质上就是通过定义新的更大的数组，将旧数组中的内容拷贝到新数组，来实现扩容。 ArrayList的Object数组初始化长度为10，如果我们存储满了这个数组，需要存储第11个对象，就会定义新的长度更大的数组，并将原数组内容和新的元素一起加入到新数组中

 LinkedList底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。

      双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。 所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。

自己模仿链表写一个MyLinkedList:

首先定义节点类：public class Node {
private Object previous;
private Object obj;
private Object next;
public Object getPrevious() {
return previous;
}
public void setPrevious(Object previous) {
this.previous = previous;
}
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
public Object getNext() {
return next;
}
public void setNext(Object next) {
this.next = next;

}

然后定义链表：public class MyLinkedList {
private Node first;
private Node last;
public Node getFirst() {
return first;
}
public void setFirst(Node first) {
this.first = first;
}
public Node getLast() {
return last;
}
public void setLast(Node last) {
this.last = last;
}
public void add(Object o){

if(first==null){//如果你添加的是第一个节点：
Node n=new Node();
n.setPrevious(null);
n.setObj(o);
n.setNext(null);

first=n;
last=n;


}else{//从第二个节点之后的所有节点都走这个分支
Node n=new Node();
n.setPrevious(last);
n.setObj(o);
n.setNext(null);

last.setNext(n);
last=n;
}
}

public static void main(String[] args) {
MyLinkedList ml=new MyLinkedList();
ml.add("aa");
ml.add("bb");
ml.add("cc");
System.out.println("---");

}

选择建议：如何选用ArrayList、LinkedList、Vector、

      1. 需要线程安全时，用Vector。

      2. 不存在线程安全问题时，并且查找较多用ArrayList(一般使用它)。

      3. 不存在线程安全问题时，增加或删除元素较多用LinkedList。

Set接口：

Set接口继承自Collection，Set接口中没有新增方法，方法和Collection保持完全一致。我们在前面通过List学习的方法，在Set中仍然适用。因此，学习Set的使用将没有任何难度。

      Set容器特点：无序、不可重复。无序指Set中的元素没有索引，我们只能遍历查找;不可重复指不允许加入重复的元素。更确切地讲，新元素如果和Set中某个元素通过equals()方法对比为true，则不能加入;甚至，Set中也只能放入一个null元素，不能多个。

      Set常用的实现类有：HashSet、TreeSet等，我们一般使用HashSet。

HashSet: HashSet是采用哈希算法实现，底层实际是用HashMap实现的(HashSet本质就是一个简化版的HashMap)，因此，查询效率和增删效率都比较高

TreeSet:TreeSet底层实际是用TreeMap实现的，内部维持了一个简化版的TreeMap，通过key来存储Set的元素。 TreeSet内部需要对存储的元素进行排序，因此，我们对应的类需要实现Comparable接口。这样，才能根据compareTo()方法比较对象之间的大小，才能进行内部排序。

注意：

 (1) 由于是二叉树，需要对元素做内部排序。 如果要放入TreeSet中的类没有实现Comparable接口，则会抛出异常：java.lang.ClassCastException。

(2) TreeSet中不能放入null元素。