本文主要介绍：
1.集合框架
2.泛型
3.内部类
1.集合框架
集合是一个对象容器，用来存储其它的多个对象。
他们的关系如下图：
List和Set是Collection的子类
Collection：存储的元素好似Object对象
方法：
add(Object o):把对象加入集合。
addAll(Collection c):把c中所有对象放入集合。
clear()：清空集合。
Contains(Object s):判断对象是否存在。
List:
接口
特点：元素有顺序，可以重复。
实现类：
1.ArrayList 用数组实现 查询快 增删慢
2.vector 用数组实现 重量级 线程安全
3.LinkedList 用链表实现 查询慢 增删快
利用LinKedList可以定义栈
eg:
class stack
{
private LinkedList遍历方式：
1.for循环
eg:
Studen one1 = new Studen(20, "小明");
Studen one2 = new Studen(50, "小白");
Studen one3 = new Studen(40, "小红");
java.util.List list = new ArrayList<>();
list.add(one1);
list.add(one2);
list.add(one3);
for (int i = 0; i 2.迭代器遍历
eg:
Studen one1 = new Studen(20, "小明");
Studen one2 = new Studen(50, "小白");
Studen one3 = new Studen(40, "小红");
java.util.List list = new ArrayList<>();
list.add(one1);
list.add(one2);
list.add(one3);
Iterator iterator = list.iterator();
while(iterator.hasNext())
{
Studen s = iterator.next();
System.out.println("age"+s.age+"name"+s.name);
}
3.for-each
eg:
Studen one1 = new Studen(20, "小明");
Studen one2 = new Studen(50, "小白");
Studen one3 = new Studen(40, "小红");
java.util.List list = new ArrayList<>();
list.add(one1);
list.add(one2);
list.add(one3);
for (Studen studen : list)
{
System.out.println("age"+studen.age+"name"+studen.name);
}
Set
是接口
特点：元素无顺序，内容不重复。
方法：全部继承自Collection接口
实现类：
1.HashSet
HashSet把自定义对象放入HashSet，元素加入HashSet中，会先比较哈希码，如果哈希码相同，再调用equals()看是否为同一元素，为保证元素不重复。需要进行以下两步：
1.覆盖hashCode(),保证相同对象返回相同的int，尽量保证不同对象返回不同的哈希码。
2.覆盖equals()，保证相同对象返回true。
eg:
class Studen implements Comparable
{
int age;
String name;
Studen()
{
}
Studen(int age,String name)
{
this.age = age;
this.name = name;
}
@Override
public int compareTo(Studen arg0)
{
// TODO Auto-generated method stub
if (this.age>arg0.age)
{
return -1;
}
else if (this.age 2.TreeSet
继承与SortedSet,SortedSet是Set的子接口。
TreeSet实现了SortedSet,对元素自动排序，要求元素必须实现Comparable接口。
Map
特点：元素由键值组成，key是唯一，不可重复
方法：
put(Object k,Object v):把K-V这个键值放入Map中，如果k以及存在，那么新值就会替换旧值。
get(Object k):返回Map中对应的Value。
remove(Object k):删除Map中k对应的Value。
size():返回键值对应的数量。
ContainsKey(Object k)：判断k这个键是否存在。
ContainsValue(Object v):判断v这个值是否存在。
实现类：
1.HashMap 允许null作为key或value
2.HashTable 不允许null作为key或者value
3.Properties HashTable的子类，key和value都是String 一般用于配置文件的读取
4.TryMap 实现了SortedMap(Map的子接口)，自动对键排序。
遍历：
1.值遍历
values():返回Map中所有值的集合
eg:
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
for(Integer value:map.values())
{
System.out.println("值是：+"+value);
}
2.键遍历
keySet():返回Map中所有键的集合 Set
eg：
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
for(String keys:map.keySet())
{
System.out.println("值是：+"+map.get(keys));
}
3.键值对遍历
entrySet():返回Map中所有的键值对的集合
Map.Entry对象封装了一个key和一个value。
eg：
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
for(Map.Entry entry:map.entrySet())
{
System.out.println("键是： "+entry.getKey()+"值是： "+entry.getValue());
}
4.迭代器遍历
eg:
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
Iterator> iterator2 = map.entrySet().iterator();
while (iterator2.hasNext())
{
Entry entry = iterator2.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
2.泛型
我们首先定义一个简单的Box类：
public class Box {
private String object;
public void set(String object) { this.object = object; }
public String get() { return object; }
}
这是最常见的做法，这样做的一个坏处是Box里面现在只能装入String类型的元素，今后如果我们需要装入Integer等其他类型的元素，还必须要另外重写一个Box，代码得不到复用，使用泛型可以很好的解决这个问题。
public class Box {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
这样我们的Box类便可以得到复用，我们可以将T替换成任何我们想要的类型：
Box integerBox = new Box();
Box doubleBox = new Box();
Box stringBox = new Box();
通配符：
首先看下面的代码：
public void boxTest(Box n) { /* ... */ }
那么现在Box
public void boxTest(Box n) { /* ... */ }
该成以上就好了
？ 表示任何类型
？extends Number Number类或它的子类
? super Number Number类或它的任何父类
？extends Comparable 任何实现Comparable接口的类
3.内部类
既类中定义类，分为成员内部类，静态内部类，局部内部类，和匿名内部类
1.成员内部类
可以访问外部类的私有变量
创建成员内部类对象，必须先创建外部类对象，再通过外部类对象.new构造内部类对象
成员内部类不能有静态成员
外部类名.this 指向外部类当前对象
2.静态内部类
只能访问外部静态成员
创建静态内部类对象，不需要创建外部对象
定义在代码块、方法体内、作用域（使用花括号“{}”括起来的一段代码）内的类叫局部内部类。
3.局部内部类
局部内部类只能在代码代码块、方法体内和作用域中使用（如创建对象和使用类对象等）
局部内部类访问作用域内的局部变量，该局部变量需要使用final修饰。
可以使用abstract修饰，声明为抽象类
4.匿名内部类
只能使用一次，创建实例之后，类定义会立即消失（想要多次使用就要用到反射的知识了）
必须继承一个类（抽象的、非抽象的都可以）或者实现一个接口。如果父类（或者父接口）是抽象类，则匿名内部类必须实现其所有抽象方法。
不能是抽象类，因为匿名内部类在定义之后，会立即创建一个实例。
不能定义构造方法，匿名内部类没有类名，无法定义构造方法，但是，匿名内部类拥有与父类相同的所有构造方法。
可以定义代码块，用于实例的初始化，但是不能定义静态代码块。
可以定义新的方法和属性(不能使用static修饰)，但是无法显式的通过“实例名.方法名(参数)”的形式调用，因为使用new创建的是“上转型对象”（即父类声明指向子类对象）。
是局部内部类，所以要符合局部内部类的要求。