java集合框架（一）ArrayList

1、ArrayList常用方法

ArrayList 实现了List接口，常见的写法会把引用声明为接口List类型

public class TestCollection {
    public static void main(String[] args) {
        ArrayList heros = new ArrayList();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero"+i));
        }
        System.out.println(heros);
        //在指定位置增加对象
        Hero specialHero = new Hero("special hero");
        heros.add(3, specialHero);
        System.out.println(heros);
        //判断对象是否在容器中
        System.out.println(heros.contains(specialHero));
        //获取指定位置的对象
        System.out.println(heros.get(3));
        //获取对象所处位置
        System.out.println(heros.indexOf(specialHero));
        System.out.println(heros.indexOf(new Hero("hero1")));
        //删除对象
        heros.remove(2);
        System.out.println(heros);
        heros.remove(specialHero);
        System.out.println(heros);
        //替换指定位置元素
        heros.set(3,new Hero("替换"));
        System.out.println(heros);
        //获取容器的大小
        System.out.println(heros.size());
        //转换为数组
        Hero hs[] = (Hero[])heros.toArray(new Hero[]{});
        System.out.println(hs);
        //把另一个容器的所有对象都加进来
        ArrayList anotherHeros = new ArrayList();
        anotherHeros.add(new Hero("a"));
        anotherHeros.add(new Hero("b"));
        anotherHeros.add(new Hero("c"));
        heros.addAll(anotherHeros);
        System.out.println(heros);
        //清空数组
        heros.clear();
        System.out.println(heros);
    }
}

2、泛型Generic

不指定泛型的容器，可以存放任何类型的元素
指定了泛型的容器，只能存放指定类型的元素以及其子类

• 泛型简写：
  List<Hero> genericheros = new ArrayList<Hero>();
  List<Hero> genericheros2 = new ArrayList<>();

public class TestCollection {
    public static void main(String[] args) {
        //对于不使用泛型的容器，可以往里面放英雄，也可以往里面放物品
        List heros = new ArrayList();
        heros.add(new Hero("盖伦"));
        //本来用于存放英雄的容器，现在也可以存放物品了
        heros.add(new Item("冰杖"));
        //对象转型会出现问题
        Hero h1=  (Hero) heros.get(0);
        //尤其是在容器里放的对象太多的时候，就记不清楚哪个位置放的是哪种类型的对象了
        Hero h2=  (Hero) heros.get(1);
        //引入泛型Generic
        //声明容器的时候，就指定了这种容器，只能放Hero，放其他的就会出错
        List<Hero> genericheros = new ArrayList<Hero>();
        genericheros.add(new Hero("盖伦"));
        //如果不是Hero类型，根本就放不进去
        //genericheros.add(new Item("冰杖"));
        //除此之外，还能存放Hero的子类
        genericheros.add(new APHero());
        //并且在取出数据的时候，不需要再进行转型了，因为里面肯定是放的Hero或者其子类
        Hero h = genericheros.get(0);
    }
}

3、遍历容器

• （1）for循环遍历

public class TestCollection {
    public static void main(String[] args) {
        List<Hero> heros = new ArrayList<Hero>();
        // 放5个Hero进入容器
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero name " + i));
        }
        // 第一种遍历 for循环
        System.out.println("--------for 循环-------");
        for (int i = 0; i < heros.size(); i++) {
            Hero h = heros.get(i);
            System.out.println(h);
        }
    }
}

• （2）迭代器遍历

public class TestCollection {
    public static void main(String[] args) {
        List<Hero> heros = new ArrayList<Hero>();
        //放5个Hero进入容器
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero name " +i));
        }
        //第二种遍历，使用迭代器
        System.out.println("--------使用while的iterator-------");
        Iterator<Hero> it= heros.iterator();
        //从最开始的位置判断"下一个"位置是否有数据
        //如果有就通过next取出来，并且把指针向下移动
        //直到"下一个"位置没有数据
        while(it.hasNext()){
            Hero h = it.next();
            System.out.println(h);
        }
        //迭代器的for写法
        System.out.println("--------使用for的iterator-------");
        for (Iterator<Hero> iterator = heros.iterator(); iterator.hasNext();) {
            Hero hero = (Hero) iterator.next();
            System.out.println(hero);
        }
    }
}

• （3）增强型for循环遍历

public class TestCollection {
    public static void main(String[] args) {
        List<Hero> heros = new ArrayList<Hero>();
        // 放5个Hero进入容器
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero name " + i));
        }
        // 第三种，增强型for循环
        System.out.println("--------增强型for循环-------");
        for (Hero h : heros) {
            System.out.println(h);
        }
    }
}