(笔记)-集合框架-ArrayList

1.和数组的区别

    如果要存放多个对象，可以使用数组，但是数组有局限性。如声明长度后容易造成空间的浪费或者空间不够的问题，于是引入容器类的概念。 最常见的容器类就是 —— ArrayList 。 

public static void main(String[] args) {

        //容器类ArrayList，用于存放对象

        ArrayList heros = new ArrayList();

        heros.add( new Hero("盖伦"));

        System.out.println(heros.size());//输出容器已使用空间大小

        heros.add( new Hero("提莫"));    
        
        System.out.println(heros.size());//输出容器已使用空间大小
         
         //容器的容量（capacity）会随着对象的增加，自动增长。只需要不断往容器里增加对象（英雄）即可，不用担心会出现数组的边界问题。   

    }

2.ArrayList常用方法

add

//add有两种使用方式
public static void main(String[] args) {

        ArrayList heros = new ArrayList();


        // 1.把5个对象加入到ArrayList中

        for (int i = 0; i < 5; i++) {

            heros.add(new Hero("hero " + i));
        }

        // 2.在指定位置增加对象

        Hero specialHero = new Hero("special hero");

        heros.add(3, specialHero);


    }

contains

方法contains 判断一个对象是否在容器中
判断标准： 是否是同一个对象，而不是name是否相同

public static void main(String[] args) {

        ArrayList heros = new ArrayList();
        // 初始化5个对象
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i));
        }
        
        Hero specialHero = new Hero("special hero");
        heros.add(specialHero);
        System.out.println(heros);

        // 判断一个对象是否在容器中
        // 判断标准： 是否是同一个对象，而不是name是否相同

        System.out.print("虽然一个新的对象名字也叫 hero 1，但是contains的返回是:");

        System.out.println(heros.contains(new Hero("hero 1")));

        System.out.print("而对specialHero的判断，contains的返回是:");

        System.out.println(heros.contains(specialHero));

    }

输出结果如下

get
获取指定位置对象

public static void main(String[] args) {

        ArrayList heros = new ArrayList();
        // 初始化5个对象
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i));
        }

        Hero specialHero = new Hero("special hero");

        heros.add(specialHero);

        //获取指定位置的对象

        System.out.println(heros.get(5));

        //如果超出了范围，依然会报错

        System.out.println(heros.get(6));
    }

indexOf
用于判断一个对象在ArrayList中所处的位置
判断规则：同contains，判断标准是对象是否相同，而非对象的name值是否相等
当判断对象没有出现，则该方法返回 -1

public static void main(String[] args) {

        ArrayList heros = new ArrayList();
        // 初始化5个对象
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i));
        }
        Hero specialHero = new Hero("special hero");
        heros.add(specialHero);

        System.out.println(heros);
        System.out.println("specialHero所处的位置:"+heros.indexOf(specialHero));
        //返回值5
        System.out.println("新的英雄，但是名字是\"hero 1\"所处的位置:"+heros.indexOf(new Hero("hero 1")));
        //返回值-1
    }

remove
remove用于把对象从ArrayList中删除,可根据下标删除ArrayList的元素,也可以根据对象删除。

public static void main(String[] args) {

        ArrayList heros = new ArrayList();
        // 初始化5个对象

        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i));
        }
        Hero specialHero = new Hero("special hero");
        
        heros.add(specialHero);
        System.out.println(heros);
        
        System.out.println("删除下标是2的对象");
        heros.remove(2);
        System.out.println(heros);
        
        System.out.println("删除special hero");
        heros.remove(specialHero);
        System.out.println(heros);
    }

set
用于替换指定位置的元素

public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		
		System.out.println(heros);
		System.out.println("把下标是5的元素，替换为\"hero 5\"");
		heros.set(5, new Hero("hero 5"));
		System.out.println(heros);
	}

结果如下：

toArray

以把一个ArrayList对象转换为数组。

注意：如果要转换为一个特定对象的数组，那么需要传递一个特定对象的数组类型的对象给toArray()，这样toArray方法才知道，你希望转换为哪种类型的数组，否则只能转换为Object数组。

public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		System.out.println(heros);
		Hero hs[] = (Hero[])heros.toArray(new Hero[]{});//转换数组类型
		System.out.println("数组:" +hs);

	}

addAll

把另一个容器所有对象都加进来

public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}

		System.out.println("ArrayList heros:\t" + heros);
		 
		//把另一个容器里所有的元素，都加入到该容器里来
		ArrayList anotherHeros = new ArrayList();
		anotherHeros.add(new Hero("hero a"));
		anotherHeros.add(new Hero("hero b"));
		anotherHeros.add(new Hero("hero c"));
		System.out.println("anotherHeros heros:\t" + anotherHeros);
		heros.addAll(anotherHeros);
		System.out.println("把另一个ArrayList的元素都加入到当前ArrayList:");
		System.out.println("ArrayList heros:\t" + heros);
		
	}

结果如下：

clear

clear 清空一个ArrayList，这里不做赘述。

size

用于获取ArrayList的大小 ，这里不做赘述。

3.List接口

	//1.ArrayList实现了接口List
    //2.常见的写法会把引用声明为接口List类型
    //3.注意：是java.util.List,而不是java.awt.List
    //4.接口引用指向子类对象（多态）
	//因为ArrayList实现了List接口，所以List接口的方法ArrayList都实现了。

4.泛型（Generic ）

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

public static void main(String[] args) {
         
        //对于不使用泛型的容器，可以往里面放英雄，也可以往里面放物品
        List heros = new ArrayList();
         
        heros.add(new Hero("盖伦"));
        heros.add(new Item("冰杖"));
        //本来用于存放英雄的容器，现在也可以存放物品了
        
        //对象转型会出现问题
        Hero h1=  (Hero) heros.get(0);
        //尤其是在容器里放的对象太多的时候，就记不清楚哪个位置放的是哪种类型的对象了
         
        //引入泛型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);
        
    }

②书写方式

	//为了不使编译器出现警告，需要前后都使用泛型，像这样：
	List<Hero> genericheros = new ArrayList<Hero>();
	不过JDK7提供了一个可以略微减少代码量的泛型简写方式
    // List<Hero> genericheros2 = new ArrayList<>();

5.遍历

== 迭代器遍历 ==
使用迭代器Iterator遍历集合中的元素

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

== 增强型for遍历 ==
使用增强型for循环可以非常方便的遍历ArrayList中的元素十分方便。
不过增强型for循环也有不足：
无法用来进行ArrayList的初始化，无法得知当前是第几个元素了，当需要只打印单数元素的时候， 必须再自定下标变量。

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

ps:学习内容源自How2j