java的集合类List系列(一)

Collection 类

本文主要是讲基础,大神们就不用在此浪费时间了,应该也没有大神看这些吧..

首先就先上图吧

为啥需要集合呢?

由于数组的长度是固定的,当添加元素超过数组长度时,那么我们就要重新定义更大的数组.而java提供的集合类就是为了这个问题而设计的.

集合与数组的区别

• 1,数组可以存储基本数据类型和引用数据类型(也就是对象的地址值),而集合只能存储引用数据类型(对象),但你会发现基本数据类型也可以存储(那是因为自动装箱的原因,其实内部已经将基本数据类型封装成对应的包装类.)

• 2,数组长度是固定的,不能自动增长,而集合长度是可变的,可以根据元素的增加而增长.

集合的功能方法

自己看API文档吧
常用的就几个
boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)

集合的遍历

• 第一种方式(数组)
  
  • 使用 toArray();

        Collection c= new ArrayList();
        c.add(new Student("张三",23));        
        c.add(new Student("李四",24));
        c.add(new Student("王五",25));
        c.add(new Student("赵六",26));
        //将集合转换成数组
        Object[] arr = c.toArray();             
        for (int i = 0; i < arr.length; i++) {
            //强转成Student
            Student s = (Student)arr[i];            
            System.out.println(s.getName() + "," + s.getAge());
        }

• 第二种方式(迭代器)
  
  • iterator();

            Collection c = new ArrayList();
            c.add("a");
            c.add("b");
            c.add("c");
            c.add("d");

            Iterator it = c.iterator(); //获取迭代器的引用  
            // 集合中的迭代方法(遍历)             
            while(it.hasNext()) {                           
                System.out.println(it.next());
            }

• 第三种方式:增强for循环
  
  • foreach(这底层也是用迭代器做的,所以有迭代器的缺点.)
    代码如下:

            ArrayList<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");

            for(String s : list) {
                System.out.println(s);
            }

那么迭代器的原理:

迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存取都是不一样的.而Collection 接口是继承 Iterable 接口的,而Iterable 中的构造就是Iterator 所以所有集合的子类都需要重写自己的迭代器,这就是多态的作用.

集合类中的List 也有自己特殊的方法,自己API吧.

* void add(int index,E element)
* E remove(int index)
* E get(int index)
* E set(int index,E element)

特别注意的:迭代遍历时的并发修改异常产生

说白点就是:在使用迭代器遍历的时候,修改了List的元素,就会产生并发修改异常.(因为你遍历的时候首先告诉Iterator有这个元素,但中途你就把它给改了或者删除了,那么Iterator就会找不到了.)

以下代码操作就会导致异常:

            List list = new ArrayList();
            list.add("a");
            list.add("b");
            list.add("g");
            list.add("d");
            list.add("e");

            Iterator it = list.iterator();
            while(it.hasNext()) {
                String str = (String)it.next();
                if(str.equals("g")) {
                    list.add("ffff");   
//这里会抛出ConcurrentModificationException并发修改异常        
                }
            }

那么解决方法:

1,使用 ListIterator

        ListIterator lit = list.listIterator();//如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
            while(lit.hasNext()) {
                String str = (String)lit.next();
                if(str.equals("g")) {
                    lit.add("ffff");    
                    //list.add("ffff");
                }
            }

2,使用 迭代器的remove方法

Iterator it= list.Iterator();//如果想在遍历的过程中添加元素,可以用Iterator中的add方法
            while(it.hasNext()) {
                String str = (String)it.next();
                if(str.equals("g")) {
                    it.remove();
                }
            }

List 的相关子类

List的三个子类的特点

    ArrayList:
        底层数据结构是数组，查询快，增删慢。
        线程不安全，效率高。
    Vector:
        底层数据结构是数组，查询快，增删慢。
        线程安全，效率低。
    Vector相对ArrayList查询慢(线程安全的)
    Vector相对LinkedList增删慢(数组结构)
    LinkedList:
        底层数据结构是链表，查询慢，增删快。
        线程不安全，效率高。

    Vector和ArrayList的区别
        Vector是线程安全的,效率低
        ArrayList是线程不安全的,效率高
    共同点:都是数组实现的
    ArrayList和LinkedList的区别
        ArrayList底层是数组结果,查询和修改快
        LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
    共同点:都是线程不安全的

Vector 类就自己查API 吧,因为少用.