集合：可以存储不同类型的多个对象，随着存储对象的个数的增加而自动扩大容量
体系结构:
Collection<E>
|----List:存入的对象是有序的，且可以重复
ArrayList:底层使用的数据结构是数组，线程不安全的，查找速度快，增删速度慢
Vector:底层使用的数据结构是数组，线程安全的，查找速度快，增删速度慢
LinkedList:底层使用的数据结构是链表，线程不安全的，查找速度慢，增删速度快
|----Set:存入的对象是无序的，且不可以重复
HashSet:底层使用的数据结构是哈希表，线程不安全的
保证对象唯一的原理：
先判断hashCode()值，如果都不同就直接加入集合，如果哈希值相同了
在调用equals()方法，如果equals()方法返回值为true,则认为集合中存在该对象，不加入集合
TreeSet:底层使用的数据结构是二叉树，线程不安全的
会对存入集合的对象进行排序
保证集合中对象唯一的方式：依据compareTo()或compare()的返回值是否为0
排序方式一：让存入集合中的对象具备可比较性
让存入集合中的对象所属的类实现Comparable<T>接口中的intcompareTo(T t) 方法
排序方式二:让集合具备排序功能
定义一个比较器，实现Comparator<T>接口中的int compare(T t1,T t2)方法
把比较器对象作为参数传递给TreeSet<E>集合的构造方法
当集合中的对象具备可比较性，且存在比较器时，比较器优先被使用
泛型：<引用数据类型>
把运行时期的问题转移到了编译时期
不用再强制类型转换
classDemo<T>
{
publicvoid show(T t)
{ }
//自己使用泛型的方法
public<E> void fun(E e)
{
}
//静态方法只能自己使用泛型
publicstatic <W> void func(W w)
{}
}
//泛型定义在接口上
interfaceinter<T>
{ }
通配符：?
泛型限定：?extends E 和? super E
Map<K,V>:一个单独的接口，存储的是键值对，键不可以重复,无序的
HashMap:保证键唯一的原理和HashSet一样，hashCode(),equals()
TreeMap:TreeMap是根据键来排序的,保证键唯一的原理和TreeSet相同,依据
compareTo()或compare()的返回值是否为0，为0就认为是重复键
Map的迭代方式有两种：
第一种:
Set<K> keys =map.keySet();
Iterator<K> ite = keys.iterator();
while(ite.hasNext())
{
K key = ite.next();
V value = map.get(key);
System.out.println(key+","+value);
}
第二种:
Set<Map.Entry<K,V>> entry = map.entrySet();
Iterator<Map.Entry<K,V>> ite = entry.iterator();
while(ite.hasNext())
{
Map.Entry<K,V> en = ite.next();
K key = en.getKey();
V value = en.getValue();
System.out.println(key+","+value);
}
工具类：Arrays
Collections
举例说明：
/*
Collection
List:存储的对象是有序的(取出的顺序和存储的顺序是一致的)，对象是可以重复的
--ArrayList:底层使用的数据结构是数组,查找速度快，增删速度慢 线程不同步的
--LinkedList：底层使用的数据结构是链表，查找速度慢，增删速度快 线程不同步的
--Vector:底层使用的数据结构是数组，线程同步的
Set:存储的对象是无序的(取出的顺序和存储的顺序是不一致的)，对象不可以重复
*/
import java.util.*;
class Demo1
{
public static void main(String[] args)
{
ArrayList list = new ArrayList();
list.add("java01");
list.add("java02");
list.add("java03");
list.add("java03");
list.add("java02");
Iterator ite = list.iterator();
while(ite.hasNext())
{
sop(ite.next());
}
ArrayList list2 = quChu(list);
sop(list2);
}
//去除集合中的重复元素
public static ArrayList quChu(ArrayList list)
{
ArrayList list2 = new ArrayList();
for(int i=0;i<list.size();i++)
{
Object obj = list.get(i);
if(!list2.contains(obj))//依据什么来判断是否包含这个对象？boolean equals(Object obj)
{
list2.add(obj);
}
}
return list2;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*TreeSet:保证集合中对象唯一的方式：依据compareTo()或compare()的返回值是否为0
排序方式一：让存入集合中的对象具备可比较性
让存入集合中的对象所属的类实现Comparable<T>接口中的intcompareTo(T t) 方法
排序方式二:让集合具备排序功能
定义一个比较器，实现Comparator<T>接口中的int compare(T t1,T t2)方法
把比较器对象作为参数传递给TreeSet<E>集合的构造方法
当集合中的对象具备可比较性，且存在比较器时，比较器优先被使用*/
举例说明：
package com.demo.day07;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class Demo8 {
public static void main(String[] arg)
{
ComparaByName comparaByName=new ComparaByName();
TreeSet ts=new TreeSet(comparaByName);
// ts.add("sa");
// ts.add("assa");
// ts.add("esa");
// ts.add("fsa");
ts.add(new People("zs",22));
ts.add(new People("ls",28));
ts.add(new People("wm",22));
ts.add(new People("tt",23));
Iterator ite=ts.iterator();
while(ite.hasNext())
{
sop(ite.next());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
@SuppressWarnings("rawtypes")
class ComparaByName implements Comparator//<span style="font-weight: bold;">排序方式二</span>
{
@Override
public int compare(Object arg0, Object arg1) {
if(!(arg0 instanceof People))
throw new ClassCastException("类型不对");
if(!(arg1 instanceof People))
throw new ClassCastException("类型不对");
People per1=(People)arg0;
People per2=(People)arg1;
int num=per1.getName().compareTo(per2.getName());
return num==0?per1.getAge()-per2.getAge():num;
}
}
class People implements Comparable//<span style="font-weight: bold;">排序方式一</span>
{
private String name;
private int age;
@Override
public int compareTo(Object obj) {
if(!(obj instanceof People))
throw new ClassCastException("类型不对");
People per=(People)obj;
int num=this.age-per.age;
return num==0?this.name.compareTo(per.name):num;
}
public People() {
super();
// TODO Auto-generated constructor stub
}
public People(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "People [name=" + name + ", 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;
}
}
原文：http://blog.csdn.net/u011007829/article/details/43239703