（参考http://blog.csdn.net/zhongkelee/article/details/46801449 点击打开链接，以此为模板 自己做了整理、修改）
目录
集合：通常情况下，把具有某种相同性质的一类东西，汇聚成的集体，称为集合。比如，用Java编程的所有程序员，全体中国人等。在数学中的定义是，由一个或多个确定的元素所构成的整体叫做集合。
Java中的集合：是一种工具包，就像是一个容器，里面存储着任意数量的具有共同属性的对象。它包含了集合、链表、队列、栈、映射等常用的数据结构。Java集合可以划分为4个部分：List列表、Set集合、Map映射、Iterator迭代器、Enumeration枚举类、工具类（Arrays和Connections）。其实，可以把一个集合类看成一个微型数据库，操作不外乎“增删改查”四种，我们在学习使用一个具体的集合类时，需要把这四个操作的时空复杂度弄清楚了，基本上就可以说掌握这个类了。
集合与数组的比较：数组中的元素可以是基本数据类型，也可以是对象（实际上数组中保存的是对象的引用变量），而集合中只能保存对象（实际上也是保存对象的引用变量，但通常习惯上认为集合类中保存的是对象）。数组的长度是固定的，而集合长度可变。数组只能通过下标访问数组元素，且类型固定，而有的集合可以通过任意类型查找所映射的具体对象。
集合框架：集合框架是为表示和操作Java中的集合而规定的一种统一的、标准的体系结构。集合框架包含三大块内容：对外的接口、接口的实现和对集合运算的算法。
接口：是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的语言，接口通常形成一个层次。
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
集合框架的主要理念用一句话概括就是：提供一套“小而美”的API。API需要对程序员友好，增加新功能时能让程序员们快速上手。此外，所有的集合类都必须能提供友好的交互操作，这包括没有继承Collection类的数组对象。因此，框架提供一套方法，让集合类与数组可以相互转化，并且可以把Map看作成集合。Java 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中， 所以当使用集合框架的时候需要进行导包，import java.util.*。
上图完整地给出了集合框架体系中所包含的接口，实现类。学习接口和类的最好方法就是查看它们的源码，并配合使用API文档。下面我们抽取出比较核心的部分，得到简化版框架图，如下：
Collection：中可以存储的元素间无序，可以重复组各自独立的元素， 即其内的每个位置仅持有一个元素，同时允许有多个null元素对象。
|--List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引，允许重复元素。
|--Set：无序(存入和取出顺序有可能不一致)，不允许重复元素，必须保证元素的唯一性。
java.util.Collection接口中的方法：
可以看出，Collection接口中的主要方法还是相关的增删改查，注意：成功之下添加方法和删除方法，集合的长度会改变。
boolean retainAll(Collection c)：对当前集合中保留和指定集合中的相同的元素。如果两个集合元素相同，返回false；如果retainAll修改了当前集合，返回true。
toArray() 和toArray([])将集合转成数组。
Iterator iterator()：获取集合中元素上迭代功能的迭代器对象。取出集合元素。Iterator中只有hasNext(),next(),remove()方法
equals(Object):有时候需要重写
hashCode():
List本身是Collection接口的子接口，具备了Collection的所有方法。List 体系特有的共性方法都有索引(角标)，这是该集合最大的特点。也就是说，List的特有方法都是围绕索引(角标)定义的。List集合的又分了具体的子类，子类之所以要区分开是因为List的不同子类内部的数据结构(存储数据的方式)不同。
List：有序(元素存入集合顺序和取出一致)，元素都有索引，允许重复元素-->自定义元素类型都要复写equals方法。
|--ArrayList：底层的也是数组结构，也是长度可变的，可以理解为长度可变的数组。线程不同步的，替代了Vector。增删速度不快。查询速度很快。(因为在内存中是连续空间)
|--LinkedList：底层的数据结构是链表，线程不同步的。与ArrayList相反，增删速度很快，查询速度较慢。(因为在内存中需要一个个查询、判断地址来寻找下一元素)
|--Vector：底层的数据结构是数组。数组是可变长度的。线程同步的。增删和查询都巨慢！，Vector几乎被ArrayList所替代了，其实可以理解为Vector是一个支持多线程的ArrayList，只是Vector的增删和查询速度过慢，性能差，几乎不被使用。
可变长度数组的原理：不断地new 新数组并将原数组元素复制到新数组。即当元素超出数组长度，会产生一个新数组，将原数组的数据复制到新数组中，再将新的元素添加到新数组中。其中， 而Vector是允许设置默认的增长长度，Vector的默认扩容方式为原来的2倍。而ArrayList扩容问题相对复杂一些，关注源码中的 int newCapacity = oldCapacity + (oldCapacity >> 1)，从这里就可以得到一个结论，每次扩容的容量是之前容量的1.5倍（除了空数组下的扩容）。
空数组的情况下满足newCapacity - minCapacity < 0的条件，所以newCapacity=10
当第二次扩容时，又是如何变化的呢？当add第11个元素时，minCapacity=11，在grow方法中，newCapacity=10 + 10>>1 = 15，故而第二次扩容的容量为15。注意下，那么第三次扩容呢？按照1.5倍的说法计算：15 * 1.5 = 22.5，那应该是22还是23？所以一定要注意底层实现是根据位移运算：15 + 15 >> 1 = 22
总结：
1.第一次进行add操作时，默认扩容容量为10
2.扩容的条件：既存元素数 + 1 > 容量
2.扩容规则为：oldCapacity + oldCapacity >> 1，可理解为旧容量的1.5倍。原容量+原容量除以2并向下取整
List集合支持对元素的增、删、改、查。
1.添加(增)：
add(index, element)：在指定的索引位插入元素。
addAll(index, collection)：在指定的索引位插入一堆元素。
2.删除(删)：
remove(index)：删除指定索引位的元素。 返回被删的元素。
3.修改(改)：
element set(index, newElement)：对指定索引位进行元素的修改。
4.获取(查)：
element get(index)：通过索引获取指定元素。
int indexOf(element)：获取指定元素第一次出现的索引位，如果该元素不存在返回—1；所以，通过—1，可以判断一个元素是否存在。
int lastIndexOf(element) ：反向索引指定元素的位置。
List subList(start,end) ：获取子列表。
5.获取所有元素(查全部)：
ListIterator listIterator()：list集合特有的迭代器。 在进行list列表元素迭代的时候，如果想要在迭代过程中，想要对元素进行操作的时候。比如，迭代过程中执行添加，会发生ConcurrentModificationException并发修改异常。那是因为集合引用和迭代器引用在同时操作元素，通过集合获取到对应的迭代器后，在迭代中，进行集合引用的元素添加，迭代器并不知道，所以会出现异常情况。如何解决呢？Iterator中只有hasNext(),next(),remove()方法。而ListIterator这个列表迭代器接口具备了对元素的增、删、改、查的动作。
ArrayList<E>类：
接下来先讨论List接口的第一个重要子类：java.util.ArrayList<E>类，我这里先抛开泛型不说，本篇后面有专门阐述。但要注意，由于还没有使用泛型，利用Iterator的next()方法取出的元素必须向下转型，才可使用子类特有方法。针对ArrayList类，我们最需要注意的是，ArrayList的contains()方法底层使用的equals()方法判别的，所以自定义元素类型中必须复写Object的equals()方法。
案例一，往ArrayList中存储自定义对象Person(name, age)，代码如下：
package ustc.lichunchun.list.test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import ustc.lichunchun.domian.Person;
public class ArrayListTest {
public static void main(String[] args) {
//1.创建ArrayList集合对象。注意：由超类声明，子类来new。调用的最终是子类中定义的方法，如果子类没有，则调用子类的父类方法。这存在一种向上追溯的过程。
//在list当中将可以调用object当中所有声明public的方法，而调用的方法实体是来自ArrayList的。
//而之所以list不可以调用，clone（）与finalize（）方法，只是因为它们是protected的。
List list = new ArrayList();
//2.添加Person类型的对象。 注意：在这个自定义对象Person类中，必须重写toString()方法，最后直接打印p
Person p1 = new Person("lisi1", 21);
Person p2 = new Person("lisi2", 22);
//3.往list这个ArrayList中添加Person类的对象。
list.add(p1);//add(Object obj)
list.add(p2);
list.add(new Person("lisi3", 23));
//4.取出元素。
for (Iterator it = list.iterator(); it.hasNext();) {
//it.next():取出的元素都是Object类型的。需要用到具体对象内容时，需要向下转型。
Person p = (Person)it.next();
System.out.println(p.getName()+":"+p.getAge());//如果不向下转型，Object类对象没有getName、getAge方法。
}
}
} 案例二，从ArrayList中取出重复的自定义元素。
第1步，先重写Person类中的equals()、toString()。记住：往集合里面存储自定义元素，该元素所属类一定要重写equals()、toString()方法！，代码如下：
package ustc.lichunchun.domian;
public class Person{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() { //重写了toString()方法，为了满足最后的打印pintln()
return "Person [name=" + name + ", age=" + age + "]";
}
/*
* 建立Person类自己的判断对象是否相同的依据，必须要覆盖Object类中的equals方法。
*/
public boolean equals(Object obj) { //重写了equals()方法，为了满足contain()的调用
//为了提高效率，如果比较的对象是同一个，直接返回true即可。
if(this == obj)
return true;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
Person p = (Person)obj;
return this.name.equals(p.name) && this.age==p.age;
}
/*@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}*/
} 第2步，在完成上面操作之后，再来操作这个Person类所创建的实体类对象，代码如下：
package ustc.lichunchun.list.test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import ustc.lichunchun.domian.Person;
public class ArrayListTest3 {
public static void main(String[] args) {
List list = new ArrayList();
//上文代码中已经对Person类中的equals()和toString()方法进行了重写,equals()的重写是为了满足contain()的调用，toString()的重写是为了满足pintln()的调用
Person p = new Person("li",19);
//往list这个ArrayList中添加Person类的实体类对象
list.add(p);
list.add(p);//存储了一个地址相同的对象。在equals方法中直接先this==obj即可。
list.add(new Person("li",20));
list.add(new Person("li",23));
list.add(new Person("li",26));
list.add(new Person("li",23));
list.add(new Person("li",26));
list.add(new Person("li",20));
System.out.println(list);
singleElement(list); //调用具体方法，取出重复的元素
System.out.println(list);
}
public static void singleElement(List list){
List temp = new ArrayList();
for (Iterator it = list.iterator(); it.hasNext();) {
Object obj = (Object) it.next();
if(!temp.contains(obj))// --> contains()方法底层调用的是容器中元素对象的equals()方法！
//这里如果Person类自身不定义equals方法，就使用Object的equals()方法，比较的就仅仅是地址了。
temp.add(obj);
}
list.clear();
list.addAll(temp);
}
} 案例三，ArrayList实现遍历的几种方法，代码如下：
import java.util.Iterator;
import java.util.List;
/**
* 测试类
* @author 小浩
* @创建日期 2015-3-2
*/
public class Test{
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");
//第一种遍历方法使用foreach遍历List
for (String str : list) { //也可以改写for(int i=0;i<list.size();i++)这种形式
System.out.println(str);
}
//第二种遍历，把链表变为数组相关的内容进行遍历
String[] strArray=new String[list.size()]; //先定义一个数据类型一致的数组
list.toArray(strArray); //将List转换成刚才定义的数组
for(int i=0;i<strArray.length;i++) //这里也可以改写为foreach(String str:strArray)这种形式
{
System.out.println(strArray[i]);
}
//第三种遍历 使用迭代器进行相关遍历
Iterator<String> ite=list.iterator();
while(ite.hasNext())
{
System.out.println(ite.next());
}
}
}LinkedList<E>类：
java.util.LinkedList<E>类是List接口的链表实现，底层是一个双向循环链表，可以利用LinkedList实现堆栈、队列这两个数据结构。它的特有方法有如下这些：
addFirst();
addLast();
在jdk1.6以后：
offerFirst();
offerLast();
removeFirst()：获取链表中的第一个元素，并删除链表中的第一个元素。如果链表为空，抛出NoSuchElementException
removeLast();
在jdk1.6以后：
pollFirst();获取链表中的第一个元素，并删除链表中的第一个元素。如果链表为空，返回null。
pollLast();
getFirst()：获取链表中的第一个元素。如果链表为空，抛出NoSuchElementException;
getLast();
在jdk1.6以后：
peekFirst();获取链表中的第一个元素。如果链表为空，返回null。
peekLast();
案例，通过LinkedList实现一个堆栈、队列数据结构（堆栈：先进后出。First In Last Out FILO。队列：先进先出。First In First Out FIFO）。代码如下：
package ustc.lichunchun.list.linkedlist;
import java.util.LinkedList;
/*
* 描述一个队列数据结构。内部使用的是LinkedList。
*/
public class MyQueue {
private LinkedList link; //以LinkedList这个类对象作为私有化属性
MyQueue() {
link = new LinkedList();
}
/**
* 添加元素的方法。
*/
public void myAdd(Object obj) {
// 内部使用的是LinkedList的方法。
link.addFirst(obj);
}
/**
* 获取队列元素的方法。
*/
public Object myGet() {
return link.removeFirst();
}
/**
* 集合中是否有元素的方法。
*/
public boolean isNull() {
return link.isEmpty();
}
} package ustc.lichunchun.list.linkedlist;
import java.util.LinkedList;
/*
* 实现一个堆栈结构。内部使用的是LinkedList。
*/
public class MyStack {
private LinkedList link;
MyStack() {
link = new LinkedList();
}
public void myAdd(Object obj) {
link.addFirst(obj);
}
public Object myGet() {
return link.removeLast();
}
public boolean isNull() {
return link.isEmpty();
}
} package ustc.lichunchun.list.linkedlist;
import java.util.LinkedList;
//此为测试类
public class LinkedListTest {
public static void main(String[] args) {
/*
* 练习：请通过LInkedList实现一个堆栈，或者队列数据结构。
* 堆栈：先进后出。First In Last Out FILO.
* 队列：先进先出。First In First Out FIFO.
*/
//1.创建自定义的队列对象。
MyQueue queue = new MyQueue();
//2.添加元素。
queue.myAdd("abc1");
queue.myAdd("abc2");
queue.myAdd("abc3");
queue.myAdd("abc4");
//3.获取所有元素。先进先出。
while(!queue.isNull())
System.out.println(queue.myGet());
System.out.println("--------------------------");
//1.创建自定义的堆栈对象。
MyStack stack = new MyStack();
//2.添加元素。
stack.myAdd("def5");
stack.myAdd("def6");
stack.myAdd("def7");
stack.myAdd("def8");
//3.获取所有元素。先进后出。
while(!stack.isNull())
System.out.println(stack.myGet());
}
} java.util.Set<E>接口，一个不包含重复元素的 collection。更确切地讲，set 不包含满足e1.equals(e2) 的元素对e1 和e2，并且最多包含一个 null 元素。
Set：不允许重复元素。和Collection的方法相同。Set集合取出方法只有一个：迭代器。
|--HashSet：底层数据结构是哈希表(散列表)。无序，比数组查询的效率高。线程不同步的。
-->根据哈希冲突的特点，为了保证哈希表中元素的唯一性，
该容器中存储元素所属类应该复写Object类的hashCode()、equals()方法。
|--LinkedhashSet：有序，HashSet的子类。
|--TreeSet：底层数据结构是二叉树。可以对Set集合的元素按照指定规则进行排序。线程不同步的。
-->add方法新添加元素必须可以同容器已有元素进行比较，
所以元素所属类应该实现Comparable接口的compareTo() 方法，以完成排序。
或者添加Comparator比较器，实现compare() 方法。
代码示例，如下：
package ustc.lichunchun.set.demo;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo {
public static void main(String[] args) {
//1.创建一个Set容器对象。
Set set = new HashSet();
//Set set = new LinkedHashSet();如果改成LinkedHashSet，可以实现有序。
//2.添加元素。
set.add("haha");
set.add("nba");
set.add("abc");
set.add("nba");
set.add("heihei");
//3.只能用迭代器取出。
for (Iterator it = set.iterator(); it.hasNext();) {
System.out.println(it.next());
}
}
} HashSet<E>类：
java.util.HashSet<E>类实现Set 接口，由哈希表（实际上是一个HashMap 实例）支持，哈希表就是存储哈希值的结构。HashSet接口不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用null 元素。堆内存的底层实现就是一种哈希表结构，需要通过哈希算法来计算对象在该结构中存储的地址。这个方法每个对象都具备，叫做hashCode()方法，隶属于java.lang.Objecct类。hashCode()方法本身调用的是windows系统本地的算法，也可以自己定义。
哈希表的原理：
1.对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值称为哈希值。
2.哈希值就是这个元素的位置。
3.如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。
如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础 +1顺延。
4.存储哈希值的结构，我们称为哈希表。
5.既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。
这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。
哈希表的特点：
1.不允许存储重复元素，因为会发生查找的不确定性。
2.不保证存入和取出的顺序一致，即不保证有序。
3.比数组查询的效率高。
哈希冲突：
当哈希算法算出的两个元素的值相同时，称为哈希冲突。冲突后，需要对元素进行进一步的判断。判断的是元素的内容，equals。如果不同，还要继续计算新的位置，比如地址链接法，相当于挂一个链表扩展下来。
如何保证哈希表中元素的唯一性？
元素必须重写hashCode() 方法 和 equals() 方法。
重写hashCode() 方法是为了根据元素自身的特点确定哈希值。
重写equals() 方法，是为了解决哈希值的冲突。
如何实现有序？
LinkedHashSet类，可以实现有序。
案例，往HashSet中存储学生对象(姓名，年龄)，出现同姓名、同年龄的学生则视为同一个学生，不存。第1步，在学生类中，要重写里面的hashcode() 方法 和 equals() 方法。代码如下：
package ustc.lichunchun.domian;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
/*
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
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 (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
*/
//重写hashCode() 方法，根据对象自身的特点定义哈希值。
public int hashCode(){
final int NUMBER = 31;
return name.hashCode()+ age*NUMBER;
}
//需要定义对象自身判断内容相同的依据。重写equals() 方法，解决哈希值的冲突。
public boolean equals(Object obj){
if (this == obj)
return true;
if(!(obj instanceof Student))
throw new ClassCastException(obj.getClass().getName()+"类型错误");
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age == stu.age;
}
} 第2步，往HashSet中存储学生对象。代码如下：
package ustc.lichunchun.set.demo;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import ustc.lichunchun.domian.Student;
public class HashSetTest {
public static void main(String[] args) {
/*
* 练习：往HashSet中存储学生对象(姓名，年龄)。同姓名、同年龄视为同一个人，不存。
* 1.描述学生。
* 2.定义容器。
* 3.将学生对象存储到容器中。
*
* 发现存储了同姓名、同年龄的学生是可以的。
* 原因是每一次存储学生对象，都先调用hashCode()方法获取哈希值。
* 但此时调用的是Object类中的hashCode。所以同姓名同年龄了，但因为是不同的对象，哈希值也不同。
* 这就是同姓名同年龄存入的原因。
*
* 解决：
* 需要根据学生对象自身的特点来定义哈希值。
* 所以就需要覆盖hashCode方法。
*
* 发现，当hashCode返回值相同时，会调用equals方法比较两个对象是否相等。
* 还是会出现同姓名同年龄的对象，因为子类没有复写equals方法，
* 直接用Object类的equals方法仅仅比较了两个对象的地址值。
* 这就是同姓名同年龄还会存入的原因。
*
* 解决：
* 需要定义对象自身判断内容相同的依据。
* 所以就需要覆盖equals方法。
*
* 效率问题：
* 尽量减少哈希算法求得的哈希值的冲突。减少equals方法的调用。
*/
//1.创建容器对象。
Set set = new HashSet();
//2.存储学生对象。
set.add(new Student("xiaoqiang",20));
set.add(new Student("wangcai",27));
set.add(new Student("xiaoming",22));
set.add(new Student("xiaoqiang",20));
set.add(new Student("daniu",24));
set.add(new Student("xiaoming",22));
//3.获取所有学生。
for (Iterator it = set.iterator(); it.hasNext();) {
Student stu = (Student) it.next();
System.out.println(stu.getName()+":"+stu.getAge());
}
} ArrayList存储元素依赖的是equals()方法。比如remove()、contains()底层判断用的都是equals()方法。
HashSet判断元素是否相同依据的是hashCode()和equals()方法。如果哈希冲突(哈希值相同)，再判断元素的equals()方法。如果equals()方法返回true，不存；返回false，存储！
TreeSet<E>类：
java.util.Set<E>TreeSet类基于TreeMap的NavigableSet实现。使用元素的自然顺序(Comparable接口的compareTo()方法)对元素进行排序，或者根据创建 set 时提供的自定义比较器(Comparator的compare()方法)进行排序，具体取决于使用的构造方法。此实现为基本操作（add、remove和contains）提供受保证的 log(n) 时间开销。TreeSet底层是自平衡的二叉树结构，二叉树结构特点是可以排序。并且对二叉树的建立过程内部优化，基于折半的排序思想，以减少比较次数。
TreeSet：可以对元素排序。注意：排序和有序是两个不同的概念。
有序：存入和取出的顺序一致。--> List
排序：升序or降序。--> TreeSet
通过案例，了解TreeSet对元素进行排序的功能，代码如下：
package ustc.lichunchun.set.demo;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import ustc.lichunchun.domian.Student;
public class TreeSetDemo {
public static void main(String[] args) {
Set set = new TreeSet();
set.add("abc");
set.add("heihei");
set.add("nba");
set.add("haha");
set.add("heihei");
for (Iterator it = set.iterator(); it.hasNext();) {
System.out.println(it.next());
}
}
} 那如果往TreeSet集合中存入的是自定义元素呢？这就需要元素自身具备比较功能。所以元素需要实现Comparable接口，并重写compareTo()方法。如果元素不具备比较性，在运行时会发生ClassCastException异常。TreeSet能够进行排序，但是自定义的Person类需要给出排序的规则。即普通的自定义类不具备排序的功能，所以元素要实现Comparable接口，并重写compareTo()方法，强制让元素具备比较性，重写compareTo()方法。
如何保证元素唯一性？
参考的就是比较方法(比如compareTo() )的返回值是否为0。是0，就是重复元素，不存。
注意：在进行比较时，判断元素是否唯一，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。比如，同姓名同年龄，才视为同一个人。
案例， 往TreeSet集合存入上文中所描述的学生类对象，并要求按照年龄进行排序。代码如下：
package ustc.lichunchun.domian;
/*
* 学生类本身继承自Object类，具备一些方法。
* 我们想要学生类具备比较的方法，就应该在学生类的基础上进行功能的扩展。
* 比较的功能已经在Comparable接口中定义下来了，学生类只需要实现Comparable接口即可。
* 记住：需要对象具备比较性，只要让对象实现comparable接口即可。
*/
public class Student implements Comparable{ //自定义元素要实现Comparable接口，并重写其中的compareTo()方法
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
/*
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
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 (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
*/
//重写hashCode方法。根据对象自身的特点定义哈希值。
public int hashCode(){
final int NUMBER = 31;
return name.hashCode()+ age*NUMBER;
}
//需要定义对象自身判断内容相同的依据。重写equals方法。
public boolean equals(Object obj){
if (this == obj)
return true;
if(!(obj instanceof Student))
throw new ClassCastException(obj.getClass().getName()+"类型错误");
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age == stu.age;
}
//实现了Comparable接口，学生就具备了比较功能。该功能是自然排序使用的方法。
//自然排序就以年龄的升序排序为主。 升序
//既然是同姓名同年龄是同一个人，视为重复元素，要判断的要素就有两个。
//既然是按照年龄进行排序。所以先判断年龄，再判断姓名。
@Override
public int compareTo(Object o) {
Student stu = (Student)o;
System.out.println(this.name+":"+this.age+"......"+stu.name+":"+stu.age);
if(this.age > stu.age)
return 1;
if(this.age < stu.age)
return -1;
//return 0;//0表示重复元素，不存。
return this.name.compareTo(stu.name);//完成了主要条件的比较之后还要完成次要条件的比较。在两个age 值一样的情况下，再进一步细化条件，只有姓名、年龄都一样，才是重复元素。
/*
主要条件：
return this.age - stu.age;
*/
/*
主要条件+次要条件：
int temp = this.age - stu.age;
return temp==0?this.name.compareTo(stu.age):temp;
*/
}
} package ustc.lichunchun.set.demo;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import ustc.lichunchun.domian.Student;
public class TreeSetDemo {
public static void main(String[] args) {
Set set = new TreeSet();
set.add(new Student("xiaoqiang",20));//java.lang.ClassCastException 类型转换异常
//问题：因为学生要排序，就需要比较，而没有定义比较方法，无法完成排序。
//解决：add方法中实现比较功能,使用的是Comparable接口的比较方法。
//Comparable接口抽取并定义规则，强行对实现它的每个类的对象进行整体排序，实现我的类就得实现我的compareTo() 方法，否则不能创建对象。
set.add(new Student("daniu",24));
set.add(new Student("xiaoming",22));
set.add(new Student("huanhuan",22)); //根据复写的compareTo方法，huanhuan和xiaoming两个对象属于重复元素(进一步细化条件之前,compareTo返回值为0即视为重复)，又TreeSet容器不存重复元素，所以huanhuan没有存进去。
set.add(new Student("tudou",18));
set.add(new Student("dahuang",19));
/*set.add(new Student("lisi02", 22));
set.add(new Student("lisi007", 20));
set.add(new Student("lisi09", 19));
set.add(new Student("lisi08", 19));
set.add(new Student("lisi11", 40));
set.add(new Student("lisi16", 30));
set.add(new Student("lisi12", 36));
set.add(new Student("lisi10", 29));
set.add(new Student("lisi22", 90));
*/
for (Iterator it = set.iterator(); it.hasNext();) {
Student stu = (Student)it.next();
System.out.println(stu.getName()+":"+stu.getAge());
}
}
} 如何实现有序？保证二叉树只return一边即可，比如：
public int compareTo(Object o){
if (this.age == o.age)
return 0;//保证TreeSet不存入自定义的重复元素。
return 1;//保证添加的元素都存入二叉树的右子树。
} TreeSet第一种排序方式：需要元素具备比较功能。所以元素需要实现Comparable接口。重写compareTo()方法。需求中也有这样一种情况，元素具备的比较功能不是所需要的，也就是说不想按照自然排序的方式，而是按照自定义的排序方式，对元素进行排序。而且，存储到TreeSet中的元素万一没有比较功能，该如何排序呢？这时，就只能使用第二种排序方式----让集合具备比较功能，定义一个比较器。联想到集合的构造函数，去查API。
TreeSet第二种排序方式：需要集合具备比较功能，定义一个比较器。所以要实现java.util.Comparator<T>接口，重写compare()方法，将Comparator接口的对象，作为参数传递给TreeSet集合的构造函数。这个compare()方法是用来判断多个比较器是否相同。
案例，自定义一个比较器，用来对学生对象按照姓名进行排序。
第1步， 实现Comparator自定义比较器，代码如下：
package ustc.lichunchun.comparator;
import java.util.Comparator;
import ustc.lichunchun.domian.Student;
/**
* 自定义一个比较器，用来对学生对象按照姓名进行排序。
*
* @author lichunchun
*/
public class ComparatorByName extends Object implements Comparator { //实现Comparator接口，并在后面代码中要重写compare() 方法
@Override
public int compare(Object o1, Object o2) { //重写compare() 方法
Student s1 = (Student) o1;
Student s2 = (Student) o2;
int temp = s1.getName().compareTo(s2.getName()); //注意区分这个compareTo()方法和上面代码中的compare()方法
return temp == 0 ? s1.getAge() - s2.getAge() : temp;
}
//ComparatorByName类通过继承Object类，已经重写了Comparator接口的equals()方法。
//这里的equals()方法是用来判断多个比较器是否相同。
//如果程序中有多个比较器，这时实现Comparator的类就应该自己重写的equals()方法，来判断几个比较器之间是否相同。
} 第2步，往TreeSet集合中存入学生类对象，主要是在TreeSet的构造函数中加入比较器参数，即可完成自定义排序。代码如下：
package ustc.lichunchun.set.demo;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import ustc.lichunchun.comparator.ComparatorByName;
import ustc.lichunchun.domian.Student;
public class TreeSetDemo2 {
public static void main(String[] args) {
//初始化TreeSet集合明确一个比较器。
Set set = new TreeSet(new ComparatorByName()); //new ComparatorByName()就是创建了一个上文中自己定义的比较器类的一个实例对象，即一个具体的比较器
//并把new ComparatorByName()作为实际参数传递给TreeSet 的构造方法
set.add(new Student("xiaoqiang",20));
set.add(new Student("daniu",24));
set.add(new Student("xiaoming",22));
set.add(new Student("tudou",18));
set.add(new Student("daming",19));
set.add(new Student("dahuang",19));
for (Iterator it = set.iterator(); it.hasNext();) {
Student stu = (Student)it.next(); //不要忘记类型转换
System.out.println(stu.getName()+":"+stu.getAge()); //如果不进行上句中的类型转换是无法获取到学生对象的属性的
}
}
} TreeSet集合排序的两种方式中，Comparable接口和Comparator比较器接口的区别：
1.让元素自身具备比较性，需要元素对象实现Comparable接口，重写compareTo()方法。
2.如果元素不具备比较性，让集合自身来进行比较性，需要定义一个实现了Comparator接口的比较器，并重写compare()方法，并将该类对象作为实际参数传递给TreeSet集合的构造方法。比如，上面案例中的Set set = new TreeSet(new ComparatorByName()); 语句。
3.容器使用Comparator比较器接口对元素进行排序，只要实现比较器对象就可以。
-->降低了比较方式和集合之间的耦合性-->自定义比较器的方式更为灵活。
元素自身可以具备比较功能
-->自然排序通常都作为元素的默认排序。
4.Comparable接口的compareTo()方法，一个参数；Comparator接口的compare()方法，两个参数。
Collection集合各个具体实现类的名字特征：前缀名是数据结构名，后缀名是所属体系名。
ArrayList：数组结构。看到数组，就知道查询快，看到List，就知道可以重复。可以增删改查。
LinkedList：链表结构，增删快。xxxFirst、xxxLast方法，xxx：add、get、remove
HashSet：哈希表，查询速度更快，就要想到唯一性、元素必须覆盖hashCode()、equals()。看到Set，就知道不可以重复，不保证有序。
LinkedHashSet：链表+哈希表。可以实现有序（有点特殊），因为有链表。但保证元素唯一性。
TreeSet：二叉树，可以排序。就要想到两种比较方式(两个接口)：一种是自然排序Comparable，一种是比较器Comparator。
java.util.Map<K,V>接口，将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。要保证键的唯一性-->Set。值可以重复-->Collection。
Map：双列集合，一次存一对，键值对。
|--HashMap：底层是哈希表数据结构，是线程不同步的，允许存储null键，null值。HashMap替代了Hashtable。
|--TreeMap：底层是二叉树结构，线程不同步的。可以对map集合中的键进行指定顺序的排序。
|--Hashtable：底层是哈希表数据结构，是线程同步的，不允许存储null键，null值。在Java集合框架中，线程同步的只用Hashtable和Vector两个。特别小心Hashtable中的t 是小写的，书写的时候要小心。
|--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。 （留心下实际项目中的Properties文件、文档）
揭秘：HashSet、TreeSet的底层是用HashMap、TreeMap实现的，只操作键，就是Set集合。
Map集合存储和Collection有着很大不同：
Collection一次存一个元素，而Map一次存一对元素。
Collection是单列集合，而Map是双列集合。
Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
特点：要保证map集合中键的唯一性。
Map接口中的共性方法：
1.添加： 会改变集合长度
v put(key, value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。
putAll(Map<k,v> map);
2.删除： 会改变集合长度
v remove(key)：删除指定键
void clear()：清空
3.判断：
boolean containsKey(Object key)：是否包含key键
boolean containsValue(Object value)：是否包含value值
boolean isEmpty();是否为空
4.取出：
v get(key)：通过指定键获取对应的值。如果返回null，可以判断该键不存在。
当然有特殊情况，就是在Hashmap集合中，是可以存储null键null值的。
int size()：返回长度。
package ustc.lichunchun.map;
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
/*
* 需求：Map集合中存储学号、姓名。
*/
Map<Integer, String> map = new HashMap<Integer, String>();
methodDemo(map);
}
public static void methodDemo(Map<Integer, String> map){
//1.存储键值对。如果键相同，会出现值覆盖。
System.out.println(map.put(3, "xiaoqiang"));
System.out.println(map.put(3, "erhu"));
map.put(7, "wangcai");
map.put(2, "daniu");
//2.移除。-->会改变长度。
//System.out.println(map.remove(7));
//3.获取。
System.out.println(map.get(7));
System.out.println(map);
}
} 5. 想要获取Map中的所有元素：
原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。
把Map集合转成Set的方法：
方式1： Set keySet();
可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get()方法对获取到的键进行值的获取。
Set keySet = map.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()) {
Object key = it.next();
Object value = map.get(key);
System.out.println(key+":"+value);
} 方式2： Set entrySet();
取的是键和值的映射关系。Map.Entry：其实就是一个Map接口中的内部接口。为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。
Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();
while(it.hasNext()) {
Map.Entry me = (Map.Entry)it.next();
System.out.println(me.getKey()+"::::"+me.getValue());
} 案例，取出map 中的所有元素，代码如下：
package ustc.lichunchun.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo2 {
public static void main(String[] args) {
/*
* 取出Map中所有的元素。 map存储姓名---归属地。
*/
Map<String, String> map = new HashMap<String, String>();
map.put("xiaoqiang", "beijing");
map.put("wangcai", "funiushan");
map.put("daniu", "heifengzhai");
map.put("erhu", "wohudong");
map.put("zhizunbao", "funiushan");
//System.out.println(map.get("wangcai"));
/*
//演示keySet(); 取出所有的键，并存储到Set集合中。
Set<String> keySet = map.keySet();
//Map集合没有迭代器。但是可以将Map集合转成Set集合，再使用迭代器就ok了。
for (Iterator<String> it = keySet.iterator(); it.hasNext();) {
String key = it.next();
String value = map.get(key);
System.out.println(key+":"+value);
}
//演示entrySet(); Map.Entry：其实就是一个Map接口中的内部接口。
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Iterator<Map.Entry<String, String>> it = entrySet.iterator(); it.hasNext();) {
Map.Entry<String, String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"::"+value);
}
*/
//演示values(); 获取所有的值。
Collection<String> values = map.values();
for (Iterator<String> it = values.iterator(); it.hasNext();) {
String value = it.next();
System.out.println(value);
}
}
}
//原理
interface MyMap{//-->键值对
//entry就是map接口中的内部接口。
public static interface MyEntry{//-->键值对的映射关系
}
}
class MyDemo implements MyMap.MyEntry{
} 什么时候使用Map集合呢？当需求中出现映射关系时，应该最先想到map集合。比如，获取星期几，代码如下：
import java.util.Map;
import ustc.lichunchun.exception.NoWeekException;
public class MapTest {
public static void main(String[] args) {
/*
* 什么时候使用map集合呢？
* 当需求中出现映射关系时，应该最先想到map集合。
*/
String cnWeek = getCnWeek(3); //以数组，查看日期对应的星期几
System.out.println(cnWeek);
String enWeek = getEnWeek(cnWeek); //以map ，查看各个星期几对应的英文星期几
System.out.println(enWeek);
}
/*
* 根据用户指定的数据获取对应的星期。
*/
public static String getCnWeek(int num){
if (num>7 || num<=0)
throw new NotWeekException(num+", 没有对应的星期");
String[] cnWeeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
return cnWeeks[num];
}
/*
* 根据中文的星期，获取对应的英文星期。
* 中文与英文相对应，可以建立表，没有有序的编号，只能通过map集合。
*/
public static String getEnWeek(String cnWeek){
//创建一个表。
Map<String,String> map = new HashMap<String, String>();
map.put("星期一","Monday");
map.put("星期二","Tuesday");
map.put("星期三","Wednesday");
map.put("星期四","Thursday");
map.put("星期五","Friday");
map.put("星期六","Saturday");
map.put("星期日","Sunday");
return map.get(cnWeek);
}
} 上段程序中用到的NotWeekException异常，代码如下：
package ustc.lichunchun.exception;
public class NotWeekException extends RuntimeException {
/**
*
*/
private static final long serialVersionUID = 1L;
public NotWeekException() {
super();
}
public NotWeekException(String message, Throwable cause,
boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
public NotWeekException(String message, Throwable cause) {
super(message, cause);
}
public NotWeekException(String message) {
super(message);
}
public NotWeekException(Throwable cause) {
super(cause);
}
} HashMap<K, V>类：
以案例的形式来理解。案例一， 员工对象(姓名，年龄)都有对应的归属地， 将员工和归属存储到HashMap集合中并取出，其中同姓名同年龄视为同一个员工。代码如下：
package ustc.lichunchun.domain;
public class Employee implements Comparable<Employee>{ //员工类实现Comparable接口，并重写其中的compareTo()方法
private String name; //员工类的私有化属性
private int age;
public Employee() { //员工类的无参构造方法
super();
}
public Employee(String name, int age) { //员工类的有参构造方法
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() { //重写toString()方法
return "Employee [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() { //重写hashCode()方法
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) { //重写equals()方法
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public int compareTo(Employee o) {
int temp = this.age-o.age; //年龄
return temp==0?this.name.compareTo(o.name):temp;
}
} package ustc.lichunchun.map;
import java.util.HashMap;
import java.util.Map;
import ustc.lichunchun.domain.Employee;
public class HashMapTest {
public static void main(String[] args) {
/*
* 练习：
* 员工对象(姓名，年龄)都有对应的归属地。
* key=Employee value=String
*
* 1.
* 将员工和归属存储到HashMap集合中并取出。
* 同姓名同年龄视为同一个员工。
*
*/
Map<Employee,String> map = new HashMap<Employee,String>();//如果改成LinkedHashMap可以实现有序。
map.put(new Employee("xiaozhang",24),"北京"); //员工、员工的所属地
map.put(new Employee("laoli",34),"上海");
map.put(new Employee("mingming",26),"南京");
map.put(new Employee("xili",30),"广州");
map.put(new Employee("laoli",34),"铁岭");//键相同是，值会被覆盖。new Employee("laoli",34)相同,则上海被覆盖掉了
for (Employee employee : map.keySet()) { //map自己没有迭代器，转换成set集合再使用迭代器。这里使用了.keySet()方法类转换
System.out.println(employee.getName()+":"+employee.getAge()+"..."+map.get(employee));
}
}
} TreeMap<K, V>类：
接着上例，按照员工的年龄进行升序排序并取出。-->Comparable。再按照员工的姓名进行升序排序并取出。-->Comparator。
package ustc.lichunchun.map;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
import ustc.lichunchun.domain.Employee;
public class TreeMapTest {
public static void main(String[] args) {
/*
* 练习：
* 2.
* 按照员工的年龄进行升序排序并取出。-->Comparable
* 按照员工的姓名进行升序排序并取出。-->Comparator
*/
Comparator<Employee> comparator = new Comparator<Employee>(){
@Override
public int compare(Employee o1, Employee o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0?o1.getAge()-o2.getAge():temp;
}
};
//Map<Employee,String> map = new TreeMap<Employee,String>();// 按照年龄
Map<Employee,String> map = new TreeMap<Employee,String>(comparator);//按照姓名
map.put(new Employee("xiaozhang",24),"北京");
map.put(new Employee("laoli",34),"上海");
map.put(new Employee("mingming",26),"南京");
map.put(new Employee("xili",30),"广州");
map.put(new Employee("laoli",34),"铁岭");
for(Map.Entry<Employee, String> me : map.entrySet()){
System.out.println(me.getKey().getName()+"::"+me.getKey().getAge()+"..."+me.getValue());
}
}
} java.util.Iterator接口是一个对 collection 进行迭代的迭代器，作用是取出集合中的元素。
Iterator：只有hasNext()、next()、remove()三个方法
|--ListIterator：List集合所特有的迭代器，可以在遍历的时候对元素进行增删改查操作。ListIterator listIterator()：list集合特有的迭代器。 在进行list列表元素迭代的时候，如果想要在迭代过程中，想要对元素进行操作的时候。比如，迭代过程中执行添加，会发生ConcurrentModificationException并发修改异常。那是因为集合引用和迭代器引用在同时操作元素，通过集合获取到对应的迭代器后，在迭代中，进行集合引用的元素添加，迭代器并不知道，所以会出现异常情况。如何解决呢？Iterator中只有hasNext(),next(),remove()方法。而ListIterator这个列表迭代器接口具备了对元素的增、删、改、查的动作。
Iterator iterator()：获取集合中元素上迭代功能的迭代器对象。
迭代：取出元素的一种方式。有没有啊？有！取一个。还有没有啊？有！取一个。还有没有啊？没有。算了。
迭代器：具备着迭代功能的对象。迭代器对象不需要new。直接通过 iterator()方法获取即可。
迭代器是取出Collection集合中元素的公共方法。
每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素，将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口。也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。Iterator it = coll.iterator(); //获取容器中的迭代器对象，至于这个对象是是什么不重要。这对象肯定符合一个规则Iterator接口。
package ustc.lichunchun.collection.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
//1.创建集合。
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
//方式一：获取该容器的迭代器。
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//方式二：直接for+alt+/，选择第三个。
for (Iterator it = coll.iterator(); it.hasNext();) {
System.out.println(it.next());
}
System.out.println(it.next());//abc1
System.out.println(it.next());//abc2
System.out.println(it.next());//abc3
System.out.println(it.next());//java.util.NoSuchElementException
}
} java.util.Enumeration：枚举。具备枚举取出方式的容器只有Vector，已被淘汰。Vector就是一个支持多线程的ArrayList，只是Vector的查询和增删效率都特别低。举例如下：
package ustc.lichunchun.enumeration;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class EnumerationDemo {
public static void main(String[] args) {
/*
* Enumeration：枚举。
* 具备枚举取出方式的容器只有Vector。
*/
Vector v = new Vector();
v.add("abc1");
v.add("abc2");
v.add("abc3");
/*Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}*/
//获取枚举。-->淘汰了
for(Enumeration en = v.elements(); en.hasMoreElements();){
System.out.println("enumeration: "+en.nextElement());
}
//获取迭代。-->好用。
for (Iterator it = v.iterator(); it.hasNext();) {
System.out.println("iterator: "+it.next());
}
//获取高级for。-->无角标，仅为遍历。
for (Object obj : v) {
System.out.println("foreach: "+obj);
}
}
} java.util.Collections类的出现给集合操作提供了更多的功能。这个类不需要创建对象，完全由在 collection 上进行操作或返回 collection 的静态方法组成。静态方法与类相关。
1.对List排序：
sort(list); //具备泛型限定，保证安全。
2.逆序：
reverseOrder()
3.最值：
max()
min()
4.二分查找：
binarySearch()
5.将非同步集合转成同步集合： //非同步的集合可以通过工具类Collections类转换成为同步的集合
synchronizedCollection
synchronizedList
SynchronizedSet
synchronizedMap
Collections工具类代码示例，如下：
package ustc.lichunchun.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import ustc.lichunchun.comparator.ComparatorByLength;
public class CollectionsDemo {
public static void main(String[] args) {
/*
* Collections排序、逆序、最值、同步方法演示
*/
methodDemo1();
Collection<String> coll = new ArrayList<String>();
coll.add("abcd");
coll.add("ab");
coll.add("haha");
coll.add("zzz");
String max = getMax(coll);
String max1 = Collections.max(coll,new ComparatorByLength());
System.out.println("max = "+max);
System.out.println("max1 = "+max1);
/*
* Collections中有一个可以将非同步集合转成同步集合的方法。
* 同步集合 synchronized集合(非同步集合);
*/
Collection<String> synColl = Collections.synchronizedCollection(coll);
}
public static void methodDemo1() {
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("xy");
list.add("haha");
list.add("nba");
System.out.println(list);
//对list排序。自然排序。使用的是元素的compareTo方法。
Collections.sort(list);
System.out.println(list);
//按照长度排序。
Collections.sort(list,new ComparatorByLength());
System.out.println(list);
//按照长度逆序。
Collections.sort(list,Collections.reverseOrder(new ComparatorByLength()));//reverseOrder强行逆转比较器顺序。
System.out.println(list);
}
} 上述代码中用到的比较器实现如下：
package ustc.lichunchun.comparator;
import java.util.Comparator;
public class ComparatorByLength implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
int temp = o1.length()-o2.length();
return temp==0?o1.compareTo(o2):temp;
}
} Collections工具类中将非同步集合转成同步集合的原理解释：定义一个类，将非同步集合所有的方法加同一把锁后返回。
List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一个同步的list。
class MyCollections{
public static List synList(List list){
return new MyList(list);
}
private class MyList{
private List list;
private static final Object lock = new Object();
MyList(List list){
this.list = list;
}
public boolean add(Object obj){
synchronized(lock){ //加锁
return list.add(obj);
}
}
public boolean remove(Object obj){
synchronized(lock){
return list.remove(obj);
}
}
}
} Collections 和 Collection 的区别：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
java.util.Arrays类是用来操作数组的工具类，里面的方法都是静态的。代码示例：
package ustc.lichunchun.arrays;
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
//int[] arr = new int[3];
Integer[] arr = new Integer[3]; //int--->Integer,自动装箱拆箱。
String[] arr1 = new String[3];
swap(arr,1,2);
swap(arr1,1,2);
int[] arr2 = {45,1,23,56,67};
System.out.println(arr2); //[I@1db9742
System.out.println(Arrays.toString(arr2)); //[45, 1, 23, 56, 67]，底层用的是StringBuilder。StringBuilder效率高，但是不支持线程同步
}
public static <T> void swap(T[] arr, int x, int y){ //T必须是引用类型。int--->Integer,自动装箱拆箱。
T temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
//toString的源码实现。
public static String toString(int[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) { //中间省略条件判断，提高了效率。
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
} Arrays类中有一个很重要的方法就是asList()方法，它返回一个受指定数组支持的固定大小的List列表。所以这里我就重点说一下，如何实现数组和集合之间的转换。
1.数组转成集合
Arrays.asList()方法：将数组转换成list集合。
<span style="font-size:14px;">String[] arr = {"abc","kk","qq"};
List<String> list = Arrays.asList(arr);//将arr数组转成list集合。</span> 将数组转换成集合，有什么好处呢？用asList()方法，将数组变成集合；可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set等方法。注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add()、remove()、clear()不能使用。（会报不支持操作异常UnsupportedOperationException）。如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。
package ustc.lichunchun.arrays;
import java.util.Arrays;
import java.util.List;
public class ArraysDemo2 {
public static void main(String[] args) { //程序入口主方法
/*
* 数组转成集合。
*
* Arrays:用来操作数组的工具类，里面的方法都是静态的。
*/
demo_1();
demo_2();
}
public static void demo_1() {
/*
* 重点：Arrays asList(数组) 将数组转成集合。
*
* 为什么要把数组转成集合？
* 因为数组能用的方法是有限的：折半、排序、toString()、equals()、fill()，没了。
* 我想知道数组的位置、是否包含某个元素，这些都没有，但是集合中有这些方法。
*
* 好处：数组转成List集合，就是为了使用集合的方法操作数组中的元素。
*
* 注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的，
* 否则会发生UnsupportedOperationException
*/
String[] strs = {"abc","haha","nba","zz"};
//以前的做法：自己定义一个方法实现功能
boolean b = myContains(strs, "nba");
System.out.println("contains:"+b);
//现在的做法：数组转成集合，从而利用集合的方法
List<String> list = Arrays.asList(strs);
System.out.println("list contains:"+list.contains("nba"));
System.out.println(list);
//list.add("qq");//报错--> java.lang.UnsupportedOperationException
//因为数组是固定长度的。
}
/*
* 自定义 对数组中某元素进行查找。
*/
public static boolean myContains(String[] arr, String key){
for (int i = 0; i < arr.length; i++) {
String str = arr[i];
if(str.equals(key))
return true;
}
return false;
}
public static void demo_2() {
/*
* 如果数组中都是引用数据类型，转成集合时，数组元素直接作为集合元素。
* 如果数组中都是基本数据类型，会将数组对象作为集合中的元素。(因为集合中只能存对象)
*/
int[] arr = {45,23,78,11,99};
List<int[]> list = Arrays.asList(arr);
System.out.println(list);//[[I@1db9742]
System.out.println(list.size());//1
System.out.println(list.get(0));//[I@1db9742
//原因：把数组作为元素，存进了集合中。
//那上面代码的泛型该咋写？
//泛型应该是集合中元素的类型。arr是int[]类型，所以是List<int[]> list
//实际中，我们应该声明为Integer数组，而不是int数组，如下：
Integer[] arr1 = {45,23,78,11,99};
List<Integer> list1 = Arrays.asList(arr1);
System.out.println(list1);//[45, 23, 78, 11, 99]
System.out.println(list1.get(0));//45
}
} 2.集合转成数组
用的是Collection接口中的方法：toArray()。没有使用到工具类Arrays类
注意：如果给toArray()传递的指定类型的数组长度小于了集合的size，那么toArray()方法，会自定再创建一个该类型的数组，长度为集合的size。如果传递的指定的类型的数组的长度大于了集合的size，那么toArray()方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。所以，在传递指定类型数组时，最好的方式就是指定的长度和集合size相等的数组。将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。
package ustc.lichunchun.arrays;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArraysDemo3 {
public static void main(String[] args) {
/*
* 集合转成数组。
*
* 使用的就是Collection接口中的toArray()方法。没有使用到工具类Arrays类
*
* 为什么要把集合转成数组？
* 可以对集合中的元素操作的方法进行限定，不允许对其进行增删。 当然查看操作是允许的
*/
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("haha");
/*
* toArray方法需要传入一个指定类型的数组。
* 长度该如何定义呢？
* 传入的数组长度，如果小于集合长度，那么该方法会创建一个同类型的数组，并且这个数组的length属性值集合集合的size()值相等。
* 传入的数组长度，如果大于集合长度，那么该方法会使用指定的数组，存储集合中的元素，其他位置默认为null。
*
* 所以建议，长度就指定为集合的size();
*/
String[] arr =list.toArray(new String[0]);
System.out.println(Arrays.toString(arr));//[abc, haha]
String[] arr1 =list.toArray(new String[3]);
System.out.println(Arrays.toString(arr1));//以字符串的形式输出[abc, haha, null]
String[] arr2 =list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr2));//以字符串的形式输出[abc, haha]
}
} 数组和集合之间的转换目的，就是为了特定的需要使用对方的优点来弥补自己的不足，转换过程中元素保持不变。 数组和List、Set都可以存放多个元素，数组的特点是长度固定，访问速度非常快，元素类型单一；List的特点是长度可以动态增加，能够维护元素的次序，存入的所有元素都当做Object，允许元素重复；Set的特点是长度可以动态增加，能够保证元素不重复，存入的所有元素都当做Object。
List转换成数组可以使用List的toArray()方法，返回一个Object数组。
Set转换成数组可以使用Set的toArray()方法，返回一个Object数组。
如果List或Set中元素的类型单一都为A，那么可以使用带参数的toArray()方法，得到类型为A的数组，具体语句是“（A[]）set.toArray(new A[0])”，要记得强制类型转换。
数组转换成List可以使用Arrays的asList静态方法，得到一个List。
数组转化成Set时，需要先将数组转化成List再用List构造Set。包含两个步骤。
package com.example.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class ConvertorTest {
/**
* @param args
*/
public static void main(String[] args) {
testArray11List();
testList12Array();
testArray21Set();
testArray22Set();
testSet31List();
testSet32List();
testMap411List();
testMap422List();
}
private static void testArray11List() {
//数组-->List ，为了使用List中除了增删之外的方法，对数组元素进行操作
String[] ss = {"JJ","KK"};
List<String> list1 = Arrays.asList(ss); //使用工具类Arrays类中的.asList()方法
List<String> list2 = Arrays.asList("AAA","BBB");
System.out.println(list1);
System.out.println(list2);
}
private static void testList12Array() {
//List-->数组 ，限制List中增删方法的使用
List<String> list = new ArrayList<String>();
list.add("AA");
list.add("BB");
list.add("CC");
Object[] objects = list.toArray();//返回Object数组 ，调用List自己的 .toArray()方法
System.out.println("objects:"+Arrays.toString(objects));
String[] arr = new String[list.size()];
list.toArray(arr);//将转化后的数组放入已经创建好的对象中
System.out.println("strings1:"+Arrays.toString(arr));
}
private static void testArray21Set() {
String[] arr = {"AA","BB","DD","CC","BB"};
//数组(-->List)-->Set ，为了使用Set中除了增删之外的方法，对数组元素进行操作
Set<String> set = new HashSet<String>(Arrays.asList(arr)); //使用工具类Arrays类中的.asList()得到一个List，再将list作为Set构造方法的参数
System.out.println(set);
}
private static void testSet22Array() {
Set<String> set = new HashSet<String>();
set.add("AA");
set.add("BB");
set.add("CC");
String[] arr = new String[set.size()];
//Set-->数组 ,为了限制Set中增删方法的使用
set.toArray(arr); //使用Set自己的 .toArray()方法
System.out.println(Arrays.toString(arr));
}
private static void testList31Set() {
List<String> list = new ArrayList<String>();
list.add("ABC");
list.add("EFG");
list.add("LMN");
list.add("LMN");
//List-->Set ，为了排除List中的重复元素
Set<String> listSet = new HashSet<String>(list); //将list作为Set的构造方法的参数
System.out.println(listSet);
}
private static void testSet32List() {
Set<String> set = new HashSet<String>();
set.add("AA");
set.add("BB");
set.add("CC");
//Set --> List ，为了给Set中的元素添加顺序，即让它们有下标
List<String> setList = new ArrayList<String>(set); //将set作为List的构造函数的参数
System.out.println(setList);
}
private static void testMap411List() {
Map<String, String> map = new HashMap<String, String>();
map.put("A", "ABC");
map.put("K", "KK");
map.put("L", "LV");
// 将Map Key 转化为List。我自己觉得这种情况不大使用，因为Map中的键是唯一不可重复的，不符合List。
List<String> mapKeyList = new ArrayList<String>(map.keySet());
System.out.println("mapKeyList:"+mapKeyList);
// 将Map Value 转化为List。
List<String> mapValuesList = new ArrayList<String>(map.values()); //Map自己的 .values()方法获得值的信息，将其存储到Set中
System.out.println("mapValuesList:"+mapValuesList);
}
private static void testMap422Set() {
Map<String, String> map = new HashMap<String, String>();
map.put("A", "ABC");
map.put("K", "KK");
map.put("L", "LV");
// 将Map 的键转化为Set
Set<String> mapKeySet = map.keySet(); //Map自己的 .keySet()方法获得键的值，将其存储在Set中。还可以使用entry.set()实现
System.out.println("mapKeySet:"+mapKeySet);
// 将Map 的值转化为Set。我自己觉得这种情况不大实用，以为Map中的值是可以重复的，不符合Set。
Set<String> mapValuesSet = new HashSet<String>(map.values());
System.out.println("mapValuesSet:"+mapValuesSet);
}
} 泛型是JDK1.5以后出现的新技术。在JDK1.4版本之前，容器什么类型的对象都可以存储。但是在取出时，需要用到对象的特有内容时，需要做向下转型。但是对象的类型不一致，导致了向下转型发生了ClassCastException异常。为了避免这个问题，只能主观上控制，往集合中存储的对象类型保持一致。为了解决该问题，JDK1.5以后，在定义集合时，就直接明确集合中存储元素的具体类型。这样，编译器在编译时，就可以对集合中存储的对象类型进行检查。一旦发现类型不匹配，就编译失败。这个技术就是泛型技术。
package ustc.lichunchun.generic.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericDemo {
public static void main(String[] args) {
List list = new ArrayList();
list.add("abc");
list.add(4);//list.add(Integer.valueOf(4));自动装箱.
for (Iterator it = list.iterator(); it.hasNext();) {
System.out.println(it.next());
//等价于：
Object obj = it.next();
System.out.println(obj.toString());
//因为String和Integer类都重写了Object类的toString方法，所以可以这么做。
String str = (String)it.next();
System.out.println(str.length());
//->java.lang.ClassCastException:java.lang.Integer cannot be cast to java.lang.String
}
//为了在运行时期不出现类型异常，可以在定义容器时，就明确容器中的元素的类型。-->泛型
List<String> list = new ArrayList<String>();
list.add("abc");
for (Iterator<String> it = list.iterator(); it.hasNext();) {
String str = it.next();
//class文件中怎么保证it.next()返回的Object类型一定能够变成String类型？
//虽然class文件中，没有泛型标识。但是在编译时期就已经保证了元素类型的统一，一定都是某一类元素。
//那么在底层，就会有自动的相应类型转换。这叫做泛型的补偿。
System.out.println(str.length());
}
}
} 泛型的擦除：编译器通过泛型对元素类型进行检查，只要检查通过，就会生成class文件，但在class文件中，就将泛型标识去掉了。泛型只在源代码中体现。但是通过编译后的程序，保证了容器中元素类型的一致。
泛型的补偿：在运行时，通过获取元素的类型进行转换操作。在底层会有自动的相应类型转换，而不用程序员再进行强制类型转换了。
泛型的好处：1.)将运行时期的问题，转移到了编译时期，可以更好的让程序员发现问题并解决问题。2.)避免了强制转换、向下转型的麻烦。
package ustc.lichunchun.generic.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericDemo2 {
public static void main(String[] args) {
//创建一个List集合，存储整数。List ArraytList
List<Integer> list = new ArrayList<Integer>();
list.add(5);//自动装箱 list.add(Integer.valueOf(5));
list.add(6);
for (Iterator<Integer> it = list.iterator(); it.hasNext();) {
Integer integer = it.next();//使用了泛型后，it.next()返回的就是指定的元素类型。
System.out.println(integer);
}
}
} 总之，泛型就是应用在编译时期的一项安全机制。泛型技术是给编译器使用的技术，用于编译时期，确保了类型的安全。
先给出一个小案例，代码如下：
package ustc.lichunchun.domain;
public class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Person o) {
int temp = this.getAge() - o.getAge();
return temp == 0 ? this.getName().compareTo(o.getName()) : temp;
}
@Override
public int hashCode() {
final int NUMBER = 31;
return this.name.hashCode()+this.age*NUMBER;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if(!(obj instanceof Person))
throw new ClassCastException("类型不匹配");
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
} package ustc.lichunchun.generic.demo;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import ustc.lichunchun.comparator.ComparatorByName;
import ustc.lichunchun.domain.Person;
public class GenericDemo3 {
public static void main(String[] args) {
Set<String> set = new TreeSet<String>();
set.add("abcd");
set.add("aa");
set.add("nba");
set.add("cba");
for (String s : set) {
System.out.println(s);
}
//按照年龄排序
Set<Person> set = new TreeSet<Person>(); //set的名字可以一样
set.add(new Person("abcd",20));
set.add(new Person("aa",26));
set.add(new Person("nba",22));
set.add(new Person("cba",24));
for(Person p: set){
System.out.println(p);
}
//按照姓名排序
Set<Person> set = new TreeSet<Person>(new ComparatorByName()); //set的名字可以一样
set.add(new Person("abcd",20));
set.add(new Person("aa",26));
set.add(new Person("nba",22));
set.add(new Person("cba",24));
for(Person p: set){
System.out.println(p);
}
//HashSet不重复的实现
Set<Person> set = new HashSet<Person>(); //set的名字可以一样
set.add(new Person("aa",26));
set.add(new Person("abcd",20));
set.add(new Person("abcd",20));
set.add(new Person("nba",22));
set.add(new Person("nba",22));
set.add(new Person("cba",24));
for(Person p: set){
System.out.println(p);
}
}
} 泛型技术在集合框架中应用的范围很大。什么时候需要写泛型呢？当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。只要看到类或者接口在描述时右边定义<>，就需要泛型。其实是，容器在不明确操作元素的类型的情况下，对外提供了一个参数，用<>封装。使用容器时，只要将具体的类型实参传递给该参数即可。说白了，泛型就是，传递"类型参数"。下面依次介绍泛型类、泛型方法、泛型接口。
1.) 泛型类 --> 泛型定义在类上
首先，我们实现两个继承自Person类的子类，分别是Student类、Worker类，代码如下：
package ustc.lichunchun.domain;
public class Student extends Person {
public Student() {
super();
}
public Student(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return "Student [name="+getName()+", age="+getAge()+"]";
}
} package ustc.lichunchun.domain;
public class Worker extends Person {
public Worker() {
super();
}
public Worker(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return "Worker [name=" + getName() + ", age=" + getAge() + "]";
}
} 需求：创建一个用于操作Student对象的工具类。对 对象进行设置和获取。JDK1.5以后，就可以使用泛型。类型不确定时，可以对外提供参数。由使用者通过传递参数的形式完成类型的确定。
//JDK 1.5 在类定义时就明确参数。由使用该类的调用者，来传递具体的类型。
class Util<W>{//-->泛型类。
private W obj;
public W getObj() {
return obj;
}
public void setObj(W obj) {
this.obj = obj;
}
} 利用泛型类，我们就可以直接在编译时期及时发现程序错误，同时避免了向下转型的麻烦。利用上述泛型类工具，代码如下：
package ustc.lichunchun.generic.demo;
import ustc.lichunchun.domain.Student;
import ustc.lichunchun.domain.Worker;
public class GenericDemo4 {
public static void main(String[] args) {
/*
* 泛型1：泛型类-->泛型定义在类上。
*/
/* //JDK 1.4
Tool2 tool = new Tool2();
tool.setObj(new Worker());
Student stu = (Student)tool.getObj();//异常-->java.lang.ClassCastException: Worker cannot be cast to Student
System.out.println(stu);
*/
//JDK 1.5
Util<Student> util = new Util<Student>();
//util.setObj(new Worker());//编译报错-->如果类型不匹配，直接编译失败。
//Student stu = util.getObj();//避免了向下转型。不用强制类型转换。
System.out.println(stu);
//总结：什么时候定义泛型？
//当类型不明确时，就应该使用泛型来表示，在类上定义参数，由调用者来传递实际类型参数。
}
} 2. )泛型方法 --> 泛型定义在方法上。这里只需要注意一点，如果静态方法需要定义泛型，泛型只能定义在方法上。代码如下：
package ustc.lichunchun.generic.demo;
public class GenericDemo5 {
public static void main(String[] args) {
/*
* 泛型2：泛型方法-->泛型定义在方法上。
*/
Demo1<String> d = new Demo1<String>();
d.show("abc");
//d.print(6);在类上明确类型后，错误参数类型在编译时期就报错。
Demo1<Integer> d1 = new Demo1<Integer>();
d1.print(6);
//d1.show("abc");
System.out.println("----------------");
Demo2<String> d2 = new Demo2<String>();
d2.show("abc");
d2.print("bcd");
d2.print(6);
}
}
class Demo1<W>{ //泛型定义在类上
public void show(W w){
System.out.println("show: "+w);
}
public void print(W w){
System.out.println("print: "+w);
}
}
class Demo2<W>{
public void show(W w){
System.out.println("show: "+w);
}
public <Q> void print(Q w){//-->泛型方法。某种意义上可以将Q理解为Object。
System.out.println("print: "+w);
}
/*
public static void show(W w){//报错-->静态方法是无法访问类上定义的泛型的。
//因为静态方法隶属于类，优先于对象存在，而泛型的类型参数确定，需要对象明确。
System.out.println("show: "+w);
}
*/
public static <A> void staticShow(A a){//如果静态方法需要定义泛型，泛型只能定义在方法上。含静态方法的类中不能定义泛型类
System.out.println("static show: "+a);
}
} 3.)泛型接口--> 泛型定义在接口上。
package ustc.lichunchun.generic.demo;
public class GenericDemo6 {
public static void main(String[] args) {
/*
* 泛型3：泛型接口-->泛型定义在接口上。
*/
SubDemo d = new SubDemo();
d.show("abc");
}
}
interface Inter<T>{//泛型接口。
public void show(T t);
}
class InterImpl<W> implements Inter<W>{//依然不明确要操作什么类型。
@Override
public void show(W t) {
System.out.println("show: "+t);
}
}
class SubDemo extends InterImpl<String>{
}
/*
interface Inter<T>{//泛型接口。
public void show(T t);
}
class InterImpl implements Inter<String>{
@Override
public void show(String t) {
}
}
*/ 泛型通配符<?>，当具体类型不确定的时候，可以使用<?>通配符就是。当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。
package ustc.lichunchun.generic.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import ustc.lichunchun.domain.Student;
public class GenericDemo7 {
public static void main(String[] args) {
/*
* 通配符<?> --> 相当于<? extends Object>
*/
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
printCollection(list);
Set<String> set = new HashSet<String>();
set.add("haha");
set.add("xixi");
set.add("hoho");
printCollection(set);
List<Student> list2 = new ArrayList<Student>();
list2.add(new Student("abc1",21));
list2.add(new Student("abc2",22));
list2.add(new Student("abc3",23));
list2.add(new Student("abc4",24));
//Collection<Object> coll = new ArrayList<Student>();-->wrong-->左右不一样，可能会出现类型不匹配
//Collection<Student> coll = new ArrayList<Object>();-->wrong-->左右不一样，可能会出现类型不匹配
//Collection<?> coll = new ArrayList<Student>();-->right-->通配符
printCollection(list2);
}
/*private static void printCollection(List<String> list) {
for (Iterator<String> it = list.iterator(); it.hasNext();) {
String str = it.next();
System.out.println(str);
}
}*/
/*private static void printCollection(Collection<String> coll) {
for (Iterator<String> it = coll.iterator(); it.hasNext();) {
String str = it.next();
System.out.println(str);
}
}*/
private static void printCollection(Collection<?> coll) {//在不明确具体类型的情况下，可以使用通配符来表示。
for (Iterator<?> it = coll.iterator(); it.hasNext();) {//技巧：迭代器泛型始终保持和具体集合对象一致的泛型。
Object obj = it.next();
System.out.println(obj);
}
}
} 泛型的限定
<? extends E>：接收E类型或者E的子类型对象。上限。一般存储对象的时候用。比如添加元素 addAll。
<? super E>：接收E类型或者E的父类型对象。下限。一般取出对象的时候用。比如比较器。
package ustc.lichunchun.generic.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import ustc.lichunchun.domain.Person;
import ustc.lichunchun.domain.Student;
import ustc.lichunchun.domain.Worker;
public class GenericDemo8 {
public static void main(String[] args) {
/*
* 泛型的限定
*/
List<Student> list = new ArrayList<Student>();
list.add(new Student("abc1",21));
list.add(new Student("abc2",22));
list.add(new Student("abc3",23));
list.add(new Student("abc4",24));
printCollection(list);
Set<Worker> set = new HashSet<Worker>();
set.add(new Worker("haha",23));
set.add(new Worker("xixi",24));
set.add(new Worker("hoho",21));
set.add(new Worker("haha",29));
printCollection(set);
}
/*
* 泛型的限定：
* ? extends E ：接收E类型或者E的子类型。-->泛型上限。
* ? super E ：接收E类型或者E的父类型。-->泛型下限。
*/
private static void printCollection(Collection<? extends Person> coll) {//泛型的限定，支持一部分类型。
for (Iterator<? extends Person> it = coll.iterator(); it.hasNext();) {
Person obj = it.next();//就可以使用Person的特有方法了。
System.out.println(obj.getName()+":"+obj.getAge());
}
}
} 案例一，演示泛型上限（存入操作）在API中的体现。我们这里使用的是TreeSet的构造函数：TreeSet<E>(Collection<? extends E> coll)
package ustc.lichunchun.generic.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;
import ustc.lichunchun.domain.Person;
import ustc.lichunchun.domain.Student;
import ustc.lichunchun.domain.Worker;
public class GenericDemo9 {
public static void main(String[] args) {
/*
* 演示泛型限定在API中的体现。
* TreeSet的构造函数。
* TreeSet<E>(Collection<? extends E> coll);
*
* 什么时候会用到上限呢？
* 一般往集合存储元素时。如果集合定义了E类型，通常情况下应该存储E类型的对象。
* 对于E的子类型的对象，E类型也可以接受(多态)。所以这时可以将泛型从E改为 ? extends E.
*/
Collection<Student> coll = new ArrayList<Student>();
coll.add(new Student("abc1",21));
coll.add(new Student("abc2",22));
coll.add(new Student("abc3",23));
coll.add(new Student("abc4",24));
Collection<Worker> coll2 = new ArrayList<Worker>();
coll2.add(new Worker("abc11",21));
coll2.add(new Worker("abc22",27));
coll2.add(new Worker("abc33",35));
coll2.add(new Worker("abc44",29));
TreeSet<Person> ts = new TreeSet<Person>(coll);//coll2 也可以传进来。泛型中的Person类型是Student和Worker的父类
ts.add(new Person("abc8",21));
ts.addAll(coll2);//addAll(Collection<? extends E> c);
for (Iterator<Person> it = ts.iterator(); it.hasNext();) {
Person person = it.next();
System.out.println(person.getName());
}
}
}
//原理
class MyTreeSet<E>{
MyTreeSet(){
}
MyTreeSet(Collection<? extends E> c){
}
} 案例二，演示泛型下限（取出操作）在API中的体现。同样，我们这里使用的是另一个TreeSet的构造函数：TreeSet<E>(Comparator<? super E> comparator)
package ustc.lichunchun.generic.demo;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
import ustc.lichunchun.domain.Person;
import ustc.lichunchun.domain.Student;
import ustc.lichunchun.domain.Worker;
public class GenericDemo10 {
public static void main(String[] args) {
/*
* 演示泛型限定在API中的体现。
* TreeSet的构造函数。
* TreeSet<E>(Comparator<? super E> comparator)
*
* 什么时候用到下限呢？
* 当从容器中取出元素操作时，可以用E类型接收，也可以用E的父类型接收。
*
*/
//创建一个Student、Worker都能接收的比较器。
Comparator<Person> comp = new Comparator<Person>() {//匿名内部类
@Override
public int compare(Person o1, Person o2) {//每次都是容器中的两个元素过来进行比较
int temp = o1.getAge()-o2.getAge();
return temp==0?o1.getName().compareTo(o2.getName()):temp;
}
};
TreeSet<Student> ts = new TreeSet<Student>(comp);
ts.add(new Student("abc1",21));
ts.add(new Student("abc2",28));
ts.add(new Student("abc3",23));
ts.add(new Student("abc4",25));
TreeSet<Worker> ts1 = new TreeSet<Worker>(comp);
ts1.add(new Worker("abc11",21));
ts1.add(new Worker("abc22",27));
ts1.add(new Worker("abc33",22));
ts1.add(new Worker("abc44",29));
for (Iterator<? extends Person> it = ts1.iterator(); it.hasNext();) {
Person p = it.next();//多态
System.out.println(p);
}
}
}
//原理
class YouTreeSet<E>{
YouTreeSet(Comparator<? super E> comparator){
}
} 泛型的细节：
1.泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；
2.使用带泛型的类创建对象时，等式两边指定的泛型必须一致；原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；
3.等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；
ArrayList<String> al = new ArrayList<Object>(); //错
//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。
ArrayList<? extends Object> al = new ArrayList<String>();
al.add("aa"); //错
//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。
// ？extends Object 代表Object的子类型不确定，怎么能添加具体类型的对象呢？
public static void method(ArrayList<? extends Object> al) {
al.add("abc"); //错
//只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。
} 注意：Map没有迭代器，只有将Map中的转换成Set之后才可以进行遍历。
在Java集合框架中，线程同步的只用Hashtable和Vector两个。
Java中== 和 equals() 的区别
//基本数据类型的比较
int num1 = 10;
int num2 = 10;
System.out.println(num1 == num2); //true
//引用数据类型的比较
String s1 = "chance";
String s2 = "chance";
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
//String类中==与equals的比较
String s3 = new String("chance");
String s4 = new String("chance");
System.out.println(s3 == s4); //false
System.out.println(s3.equals(s4)); //true
//非String类中==与equals类型的比较
Scanner scanner = new Scanner(System.in);
Scanner scanner2 = new Scanner(System.in);
System.out.println(scanner.equals(scanner2)); //false
Scanner sc = scanner;
System.out.println(scanner.equals(sc)); //true输出结果如下：
true
true
true
false
true
false
true
------------------------------------------------------------------ 我是低调的分隔线 ----------------------------------------------------------------------
吾欲之南海，一瓶一钵足矣...