Ⅶ.容器

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());

        }
    }