1. 集合(Collection.List.ArrayList)
优势：效率高
劣势：不够灵活，需要预先指定大小
2. 链表(Collecttion.List.LinkedList)
3. 哈希(Collecttion.set.HashSet)
4. 哈希(Map.HashMap)
5. collection方法
Collection<String> c = new ArrayList<String>();
Collection<String> b = new ArrayList<String>();
#容器大小
c.size();
#容器是否为空
c.isEmpty();
#增加引用
c.add("town");
#移出引用（对象未被删除）
c.remove("town");
#移出所有引用
c.clear();
#转换为数组
c.toArray;
#是否包含
c.Contains("town");
#添加所有b元素到c中
c.addAll(b)；
#从c中移出与b相同的元素
c.removeAll(b);
#从c中移出与b不同的元素
c.retainAll(b);
#c是否包含完全包含b
c.ContainsAll(b);
6. 泛型
本质：数据类型的参数化，泛型的处理在编译器中进行。
<T.E.V><class>
用于指定容器内所能存入的数据类型。
类泛型：类实例化时可以实例化多种集合
public class MyCollection<E>{
Object[] objs = new Object[5];
public void set(E e,int index){
Object[index] = e;
}
public E get(int index){
return (E) objs[index];
}
public static void main(String[] args){
MyCollection<String> mc = new MyColletion<String>();
mc.set("town",0);
String a = mc.get(0);
}
}
集合泛型：规定集合内所能填入的内容
ArrayList<APHero> heros = new ArrayList<APHero>();
public class TestGeneric {
public static void main(String[] args) {
ArrayList<APHero> heros = new ArrayList<APHero>();
//只有APHero可以放进去
heros.add(new APHero());
//ADHero甚至放不进去
//heros.add(new ADHero());
//获取的时候也不需要进行转型，因为取出来一定是APHero
APHero apHero = heros.get(0);
}
}
通配符
ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型
heroList 的泛型可能是Hero
heroList 的泛型可能是APHero
heroList 的泛型可能是ADHero
所以 可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的
但是，不能往里面放东西，因为
放APHero就不满足<ADHero>
放ADHero又不满足<APHero>
import java.util.ArrayList;
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
public class TestGeneric {
public static void main(String[] args) {
ArrayList<APHero> apHeroList = new ArrayList<APHero>();
apHeroList.add(new APHero());
ArrayList<? extends Hero> heroList = apHeroList;
//? extends Hero 表示这是一个Hero泛型的子类泛型
//heroList 的泛型可以是Hero
//heroList 的泛型可以使APHero
//heroList 的泛型可以使ADHero
//可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的
Hero h= heroList.get(0);
//但是，不能往里面放东西
heroList.add(new ADHero()); //编译错误，因为heroList的泛型 有可能是APHero
}
}
ArrayList heroList<? super Hero> 表示这是一个Hero泛型或者其父类泛型
heroList的泛型可能是Hero
heroList的泛型可能是Object
可以往里面插入Hero以及Hero的子类
但是取出来有风险，因为不确定取出来是Hero还是Object
public class TestGeneric {
public static void main(String[] args) {
ArrayList<? super Hero> heroList = new ArrayList<Object>();
//? super Hero 表示 heroList的泛型是Hero或者其父类泛型
//heroList 的泛型可以是Hero
//heroList 的泛型可以是Object
//所以就可以插入Hero
heroList.add(new Hero());
//也可以插入Hero的子类
heroList.add(new APHero());
heroList.add(new ADHero());
//但是，不能从里面取数据出来,因为其泛型可能是Object,而Object是强转Hero会失败
Hero h= heroList.get(0);
}
}
?
只能以Object的形式取出来
并且不能往里面放对象，因为不知道到底是一个什么泛型的容器
//?泛型通配符，表示任意泛型
ArrayList<?> generalList = apHeroList;
//?的缺陷1： 既然?代表任意泛型，那么换句话说，你就不知道这个容器里面是什么类型
//所以只能以Object的形式取出来
Object o = generalList.get(0);
//?的缺陷2： 既然?代表任意泛型，那么既有可能是Hero,也有可能是Item
//所以，放哪种对象进去，都有风险，结果就什么什么类型的对象，都不能放进去
generalList.add(new Item()); //编译错误 因为?代表任意泛型，很有可能不是Item
generalList.add(new Hero()); //编译错误 因为?代表任意泛型，很有可能不是Hero
generalList.add(new APHero()); //编译错误 因为?代表任意泛型，很有可能不是APHero
如果希望只取出，不插入，就使用? extends Hero
如果希望只插入，不取出，就使用? super Hero
如果希望，又能插入，又能取出，就不要用通配符？
泛型不能进行父子类型转换。
应用：二叉树
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
public class Node<T> {
// 左子节点
public Node<T> leftNode;
// 右子节点
public Node<T> rightNode;
// 值
public T value;
// 插入 数据
public void add(T t) {
// 如果当前节点没有值，就把数据放在当前节点上
if (null == value)
value = t;
// 如果当前节点有值，就进行判断，新增的值与当前值的大小关系
else {
// 新增的值，比当前值小或者相同
if ((Double) t >((Double)value) ) {
if (null == leftNode)
leftNode = new Node();
leftNode.add(t);
}
// 新增的值，比当前值大
else {
if (null == rightNode)
rightNode = new Node();
rightNode.add(t);
}
}
}
// 中序遍历所有的节点
public List<T> values() {
List<T> values = new ArrayList<T>();
// 左节点的遍历结果
if (null != leftNode)
values.addAll(leftNode.values());
// 当前节点
values.add( value);
// 右节点的遍历结果
if (null != rightNode)
values.addAll(rightNode.values());
return values;
}
public static void main(String[] args) {
double randoms[] = new double[] { 67.1, 7, 30, 73, 10, 0.1, 78.1, 81, 10, 74 };
Node roots = new Node();
for (double number : randoms) {
roots.add(number);
}
System.out.println(roots.values());
}
}
