java集合-细嚼慢咽系列（二）

1、Collection集合

1、Collection集合概述

Collection集合只能存储单个单个的“对象”元素，不能存储基本数据类型，又因为Collection是接口，无法实例化对象，所以创建集合都是使用多态机制进行创建。

2、迭代器（Iterator）

1、概念

首先，迭代器是一个对象，因为创建它的代价小，常被称为轻量级对象，也是一种设计模式。使用迭代器遍历容器，就不必关心容器的数量，遍历开始和结束都由迭代器对象的方法来管理。

2、迭代器迭代原理

迭代器对象遍历集合是通过其方法来操控的，下面来了解下迭代器迭代的原理：

1、迭代器对象是由Collection对象调用iterator方法创建出来的，迭代器刚开始没有指向容器中的第一个元素。

2、使用迭代器对象调用hasNext()方法检查容器中是否还有元素。

3、使用迭代器对象调用next()方法获得容器中的下一个元素。

3、迭代器迭代步骤

//1、创建迭代器对象
Collection c = new ArrayList();
Iterator it = c.iterator();

//检查容器中是否还有元素
while(it.hasNext()){

    //有元素，执行并获得容器中的下一个元素
    Object ob = it.next();

    //输出元素
    System.out.println(ob);
}

3、Collection集合常用方法

Collection常用方法

方法	描述
boolean add(E e)	向集合中添加元素
boolean contains(Object object)	判断集合中是否含有object元素
boolean isEmpty()	判断集合是否为空，即元素个数是否为0
int size()	获取集合中的元素个数
Object[] toArray()	将集合转换成数组
void remove(Object o)	删除该集合中指定的元素
void clear()	清除集合中所有元素

代码演示 

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTest1 {
    //迭代器遍历集合
    public static void iterators(Collection c){
        System.out.println("遍历集合：");
        Iterator it = c.iterator();
        while(it.hasNext()){
            Object o = it.next();
            /*这里面不能调用集合的remove方法，会出现异常
            删除元素只能通过迭代器的remove()方法，删除迭代器新近返回的元素
            例：it.remove();*/
            System.out.print(o + "\t");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        //使用多态机制创建Collection集合
        Collection c = new ArrayList();

        //boolean add(E e) ---> 向集合中添加元素（增）
        c.add(1);
        c.add(2);
        c.add(3);
        c.add(4);
        c.add("第五");

        //boolean contains(Object object) ---> 判断集合中是否含有object元素（查）
        System.out.println("c集合中是否含有3，答：" + (c.contains(3)?"是":"否"));
        //输出：c集合中是否含有3，答：是      注意：这里使用了三目运算符来优化输出结果

        //boolean isEmpty() ---> 判断集合是否为空，即元素个数是否为0，底层调用size()
        System.out.println("c集合是否为空：" + (c.isEmpty()?"是":"否"));
        //输出：c集合是否为空：否

        //int size() ---> 获取集合中的元素个数
        System.out.println("c集合中的元素个数为：" + c.size());
        //输出：c集合中的元素个数为：5

        //调用本类中封装好的静态方法：public static void iterators(Collection c)遍历集合
        iterators(c);
        /*输出：
        遍历集合：
        1	2	3	4	第五	*/

        //void remove(Object o) ---> 删除该集合中指定的元素（删）
        c.remove("第五");
        iterators(c);
        /*输出：
        遍历集合：
        1	2	3	4*/

        //void clear() ---> 清除集合内元素
        c.clear();
        System.out.println("c集合是否为空：" + (c.isEmpty()?"是":"否"));
        //输出：c集合是否为空：是

        c.add(1);
        c.add(2);
        Integer integer = new Integer(2);
        
        iterators(c);
        System.out.println("c集合是否包含对象integer" + (c.contains(integer)?"是":"否"));
        /*输出：c集合是否包含对象integer：是
        因为integer是一个全新的Integer对象，所以如果不调用equals方法
        则integer和c集合中的2的引用不相等，返回false，现在返回true，
        说明 contains底层调用了integer对象的equals方法*/
        
        c.remove(integer); //（删）
        System.out.println("c集合中的元素个数为：" + c.size());
        /*输出：c集合中的元素个数为：1 说明c.remove(integer);执行成功
        和上面的contains类似，同样说明remove方法底层调用了integer对象的
        eqauls方法*/

        //Object[] toArray() ---> 将集合c转换成Object[]数组
        Object[] objects = c.toArray();
        System.out.println("objects的数组长度为："+ objects.length);
        //输出:objects的数组长度为：1    Collection没有length属性，故说明转换成功
    }
}

2、Collection>List

1、List概论

List接口是Collection接口下的子接口，不仅继承了Collection的一些特性和方法，还在Collection集合的基础上添加了自己的一些特性和方法。

2、List特性

1、List集合存储元素是有序的，此处有序是指存储时集合中元素顺序和取出时集合中元素顺序一致，不会被打乱，这种结果也是因为List集合中的元素都有下标，从0开始，以1递增。因此可以通过下标遍历集合。

2、List集合存储元素是可重复的，即List集合中可以存在两个相同的元素，只是下标不同。

3、List集合的常用方法

List集合中的常用方法在其实现类都完全被实现了

List集合常用方法

方法	说明
void add(int index, E element)	将element元素放在集合中指定index位置
E set(int index, E element)	修改集合中指定下标index处的元素为element
E get(int index)	获取集合中指定下标index的元素
int indexOf(Object o)	获取集合中指定对象o第一次出现时的索引
int lastIndexOf(Object o)	获取集合中指定对象o最后一次出现时的索引
E remove(int index)	删除集合中指定下标index处的元素

代码演示

package javase.Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class CollectionList {
    //迭代器遍历Collection集合函数
    public static void iterators(Collection<Object> c){
        System.out.println("遍历集合：");
        Iterator<Object> it = c.iterator();
        while(it.hasNext()){
            Object ob = it.next(); // next() 返回的是一个Object对象
            System.out.println(ob);
        }
    }
    //JDK5新特性：增强for循环输出集合元素函数
    public static void forEach(Collection<Object> collection){
        System.out.println("遍历集合：");
        for (Object o:collection) {
            System.out.print(o+"\t");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        //List是接口，故使用多态创建List集合
        List list = new ArrayList();
        //像集合中添加Object对象元素
        for (int i = 0; i < 5; i++){
            //自动装箱 + 自动类型转换
            list.add(i);
        }
        //调用forEach函数输出集合中数据
        forEach(list); // 0	  1	  2	  3   4

        //List集合常用方法

        /*（增）
        void add(int index, E element)
        ---> 将元素放入指定下标位置
        将“第三个元素”放入第三个位置上
        */
        list.add(2,"第三个元素");
        forEach(list); // 0	 1	第三个元素	2	3	4

        /*（改）
        E set(int index, Object element)
        ---> 修改指定下标的元素为 element
        将第二元素：1 修改为“第二个元素”
        */
        list.set(1,"第二个元素");
        forEach(list); // 0	第二个元素	第三个元素	2	3	4

        /*（查）
        E get(int index)
        ---> 获取指定下标的元素（故可通过此方法遍历List集合）
        获取list集合中第4个元素，并且使用此方法遍历集合
        */
        System.out.println("list集合中第4个元素为：" + list.get(3));
        System.out.println("使用list.get(int index)遍历集合list：");
        for (int i = 0; i < list.size(); i++){
            System.out.println( list.get(i));
        }

        /*
        int indexOf(Object o)
        ---> 获取指定对象o第一次出现处的索引
        int lastIndexOf(Object o)
        ---> 获取指定对象o最后一次出现处的索引
        现将list第2个元素换成3，然后输出1在list集合中第一次出现和最后一次出现的的索引
        */
        System.out.println("将list第2个元素换成3");
        list.set(1,3);
        forEach(list);  //输出：0	3	第三个元素	2	3	4
        System.out.println("3在集合list中第一次出现的索引为：" + list.indexOf(3));
        //输出：3在集合list中第一次出现的索引为：1
        System.out.println("3在集合list中最后一次出现的索引为：" + list.lastIndexOf(3));
        //输出：3在集合list中最后一次出现的索引为：4

        /*（删）
        Object remove(int index)
        ---> 删除指定下标处的元素
        现将第一个元素删除
        */
        System.out.println("删除第一个元素");
        list.remove(0);
        forEach(list);  //输出：3	第三个元素	2	3	4

    }

}

4、List下的实现类 

List下的实现类的主要方法都是对Collection接口的间接实现和List接口的实现，下面主要谈谈List实现类的底层数据结构和特性。

1、ArrayList类

• ArrayList集合底层的数据结构是数组，初始化容量为10，非线程安全，容量不够时，会自动扩容，为原数组的1.5倍。
• 查询元素和操作尾部元素元素效率高，随机增删元素效率低

2、LinkedList类

• LinkedList集合底层的数据结构是双向链表
• 查询元素效率低，随机增删元素效率高。

3、Vector类

• vector集合和ArrayList集合底层结构相似，不同点是Vector集合的很多方法使用synchronized关键字修饰，所以是线程安全的，但是效率低，现在保证线程又了其他的方式，所以了解即可。