API常用对象--集合类（集合框架）

数值很多用数组存。组数很多用二维素组。

数据很多用对象封装，对象很多用集合类存对象。

集合就是容器，集合本身也是对象（能存储对象的对象）。

集合是可变长度的

数组是固定长度的（存对象也可以）

集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
就使用集合容器进行存储。

集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。 






集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。


框架的顶层Collection接口：


Collection的常见方法：


1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):



2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();

3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。 


4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！


5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。 



-------------------------------
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。




List:特有的常见方法：有一个共性特点就是都可以操作角标。

1，添加
void add(index,element);
void add(index,collection);




2，删除；
Object remove(index):




3，修改：
Object set(index,element);



4，获取：
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);


list集合是可以完成对元素的增删改查。

List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！（同步就是加一个锁Sychronized，不同步就是不加锁）
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

LinkedList:


addFirst();
addLast():
jdk1.6
offerFirst();
offetLast();


getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():

removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。 
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。




|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。 
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。 

TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。






if(this.hashCode()== obj.hashCode() && this.equals(obj))






哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。


2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。


注意：如果哈希值不同，是不需要判断equals。

集合类特点：

集合类Collection接口的一些方法：

方法演示：ArrayList是Collection接口的已知实现子类。

（增加，删除）

import java.util.ArrayList;
import java.util.Collection;


public class CollectionDemo {


/**
* @param args
*/
public static void main(String[] args) {
Collection coll = new ArrayList();

// show(coll);

Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
show(c1,c2);

}

public static void show(Collection c1,Collection c2){

//给c1添加元素。
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");

//给c2添加元素。
c2.add("abc1");
c2.add("abc2");
c2.add("abc3");
c2.add("abc4");
c2.add("abc5");

System.out.println("c1:"+c1);
System.out.println("c2:"+c2);

//演示addAll

// c1.addAll(c2);//将c2中的元素添加到c1中。


//演示removeAll
// boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
// System.out.println("removeAll:"+b);

//演示containsAll
// boolean b = c1.containsAll(c2);
// System.out.println("containsAll:"+b);

//演示retainAll
boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
//和removeAll功能相反 。
System.out.println("retainAll:"+b);
System.out.println("c1:"+c1);


}

public static void show(Collection coll){

//1,添加元素。add.
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll);


//2，删除元素。remove
// coll.remove("abc2");//会改变集合的长度 

//清空集合.
// coll.clear();

System.out.println(coll.contains("abc3"));


System.out.println(coll);

}

}

取出集合中元素：迭代器演示：（迭代器的基本使用方法）

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;


public class IteratorDemo {


/**
* @param args
*/
public static void main(String[] args) {


Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");

// System.out.println(coll);

//使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
// Iterator it = coll.iterator();
// while(it.hasNext()){//while循环之后 it还能用。
// System.out.println(it.next());
// }

for(Iterator it = coll.iterator(); it.hasNext(); ){//for循环之后it消失了，省的占用内存。

System.out.println(it.next());
}

// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());//java.util.NoSuchElementException

}

}

迭代器的基本原理：

迭代器就是实现了Iterator接口，每一个容器中的内部对象 。（通过内部类来实现的，如果一个事物在直接访问另外一个事物的成员这个时候用内部类来实现）

集合类的主要体系：

Collection接口：

子接口 --List接口：

子接口 --Set接口：

Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。

List的子接口ListIterator解决了 集合类和迭代器并发的问题，ListIterator。

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




public class ListDemo2 {


/**
* @param args
*/
public static void main(String[] args) {


List list = new ArrayList();
// show(list);


list.add("abc1");
list.add("abc2");
list.add("abc3");

System.out.println("list:"+list);
ListIterator it = list.listIterator();//获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查。
//注意：只有list集合具备该迭代功能.


while(it.hasNext()){

Object obj = it.next();

if(obj.equals("abc2")){
it.set("abc9");
}
}
// System.out.println("hasNext:"+it.hasNext());
// System.out.println("hasPrevious:"+it.hasPrevious());


while(it.hasPrevious()){
System.out.println("previous:"+it.previous());
}
System.out.println("list:"+list);




/*Iterator it = list.iterator();
while(it.hasNext()){

Object obj = it.next();//java.util.ConcurrentModificationException
//在迭代器过程中，不要使用集合操作元素，容易出现异常。
//可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。 

if(obj.equals("abc2")){
list.add("abc9");
}
else
System.out.println("next:"+obj);
}
System.out.println(list);
*/


}


public static void show(List list) {

list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");

Iterator it = list.iterator();
while(it.hasNext()){
System.out.println("next:"+it.next());
}

//list特有的取出元素的方式之一。

for(int x=0; x<list.size(); x++){
System.out.println("get:"+list.get(x));
}
}

}