Java中集合

1.集合

1.1 集合的由来及集合继承体系图

*A:集合的由来

* 数组长度是固定的，当添加的元素超过了数组的长度时需要对数组重新定义，太麻烦，Java内部给我们提供了集合类，能存储任意对象，长度是可以改变的，随着元素的增加而增加，随着元素的减少而减少。

*B:数组和集合的区别

　　* 区别1：

　　　　* 数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值。

　　　　* 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象 Integer int Double double

　　* 区别2：

　　　　* 数组长度是固定的，不能自动增长

　　　　* 集合的长度是可变的，可以根据元素的增加而增长

*C:数组和集合什么时候用

　　* 1.如果元素个数是固定的，推荐用数组

　　 * 2.如果元素个数不是固定的，推荐用集合(用处更多)

*D:集合继承体系图

1.2 Collection 集合的基本功能测试

package com.se.test2;

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

public class Demo2 {
    public static void main(String[] args) {
//        demo1();
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        boolean b = c.remove("a");
        System.out.println(b); // true
        System.out.println(c); // [b, c, d]
//        c.clear(); //清空集合
//        System.out.println(c); // []
        boolean b1 = c.contains("c"); // 判断集合中是否包含"c"
        System.out.println(b1); // true
        System.out.println(c.isEmpty()); // 判断集合是否为空
        int size = c.size(); // 获取元素个数
        System.out.println(size);
    }

    public static void demo1() {
        Collection c = new ArrayList(); //多态，父类引用指向子类对象
        // add(E e)将指定元素添加到列表的尾部
        c.add("abc");
        c.add(true);
        c.add(100);
        c.add("abc");
        c.add(new Student("张三",19));
        c.add(new Student("李四",20));
        System.out.println(c); // 重写了toString()方法
    }
}

1.3 集合的遍历之集合转数组遍历

package com.se.test2;

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

public class Demo3 {
    public static void main(String[] args) {
//        demo();
        Collection c = new ArrayList();
        //Object obj = new Student("天气", 22);
        c.add(new Student("张三", 23));
        c.add(new Student("李四", 21));
        c.add(new Student("王五", 25));
        c.add(new Student("赵六", 26));
        //将集合转为数组
        Object[] arr = c.toArray();
        for (int i = 0; i < arr.length; i++) {
//            System.out.println(arr[i]);
            //在Student类中没有重写toString()时候，向下转型
            Student s = (Student) arr[i];
            System.out.println(s.getName() + "-----" + s.getAge());
        }
    }

    public static void demo() {
        Collection c = new ArrayList();
        c.add(1); // int --> Integer 自动装箱也就是向上转换
        c.add("b");
        c.add("c");
        c.add("d");

        //将集合转换成数组,一般不用这种方式
        Object[] arr = c.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

1.4 Collection 集合的带All功能测试

package com.se.test2;

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

public class Demo4 {
    public static void main(String[] args) {
//        demo();
//        demo2();
//        demo3();
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("c");
        c2.add("d");
        c2.add("e");
        // 调用的对象c1中的元素如果改变了就返回true,如果没有改变就返回false
        boolean b = c1.retainAll(c2); // 取交集
        System.out.println(b);
        System.out.println(c1);
    }

    public static void demo3() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        boolean b = c1.containsAll(c2); // 判断调用的集合是否包含传入的集合
        System.out.println(b);
    }

    public static void demo2() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList();
        c2.add("e");
        c2.add("f");
        c2.add("a");
        boolean b = c1.removeAll(c2); // 删除的是交集
        System.out.println(b);
        System.out.println(c1);
    }

    public static void demo() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");

        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("c");
        c2.add("d");
        c1.addAll(c2);
        //将c2中的每一个元素添加到c1中
        //c1.add(c2);
        //c1.add(c2); // 将c2看成一个对象添加到c1中
        System.out.println(c1);
        System.out.println(c1.size());
    }
}

1.5 集合的遍历之迭代器遍历

package com.se.test2;

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

public class Demo5 {
    public static void main(String[] args) {
//        demo();
        Collection c = new ArrayList();
        c.add(new Student("张三", 20));
        c.add(new Student("李四", 21));
        c.add(new Student("王五", 22));
        c.add(new Student("赵六", 23));
        //获取迭代器
        Iterator it = c.iterator();
        while (it.hasNext()) {
//            System.out.println(it.next()); // 为重写toString()方法，打印出来的是地址值；重写toString()后可以输出
            //向下转型
            Student stu = (Student) it.next();
            System.out.println(stu.getName() + "----" + stu.getAge());
        }
        //for循环
//        for (Iterator it = c.iterator(); it.hasNext();){
//            System.out.println(it.next());
//        }
    }

    public static void demo() {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        c.add("e");
        Iterator it = c.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

1.6 List 集合存储学生对象并遍历

package com.se.test2;

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

public class Demo6 {
    public static void main(String[] args) {
//        Collection c = new ArrayList(); // 多态，祖先引用指向子类对象
        List list = new ArrayList();    // 多态，父类引用指向子类对象
        list.add("a");
        list.add("b");
        list.add("c");
        list.add(3,"f");
        list.set(1,"f"); // 把指定位置的元素给修改了
        System.out.println(list);
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

1.7 并发修改异常产生的原因及解决方法(了解)

也就是用iterator()迭代器，在遍历集合的同时不能修改集合，不然会引发异常ConcurrentModificationException异常

package com.se.test2;

import java.util.*;

public class Demo7 {
    /**
     * 需求：我有一个集合
     * 请问，我想判断里面有没有”world“这个元素，如果有，我就添加一个"javaee"元素,请写代码实现。
     * contains
     * 1.遍历集合的每一个元素
     * 2.取到每一个元素和world进行对比，如果相等了就把javaee添加到集合中
     * @param args
     */
    public static void main(String[] args) {
//        Collection c = new ArrayList();
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("world");
        list.add("d");
//        Iterator it = list.iterator();
//        while (it.hasNext()){
//            String str = (String)it.next();
//            if (str.equals("world")){
//                list.add("javaee"); // 遍历集合的同时，你修改集合了，会导致并发异常问题
//            }
//        }
        ListIterator lit = list.listIterator();
        while (lit.hasNext()){
            String str = (String) lit.next();
            if (str.equals("world")){
                // 遍历集合的同时，不使用集合list本身去做修改操作，而是用迭代器lit去修改
                lit.add("javaee");
            }
        }
        System.out.println(list);
    }
}

1.8 ListIterator(了解)

 

1.9 Vector 的特有功能

* A:Vector类概述

* B:Vector类特有功能

　　* public void addElement(E obj)

　　* public E elementAt(int index)

　　* public Enumeration elements()

1.10 数组结构之数组和链表

* A:数组

　　* 查询快，修改也快

　　* 增删慢

* B:链表

　　* 查询慢，修改也慢

　　* 增删快

1.11 List 的三个子类的特点

* A:List 的三个子类的特点

　　ArrayList:

　　　  底层数据结构是数组，查询快，增删慢，有序

　　　　线程不安全，效率高。

　　Vector:

　　　　底层数据结构是数组，查询快，增删慢

　　　　线程安全，效率低。

　　Vector 相对 ArrayList 查询慢(线程安全的)

　　Vector 相对 linkedList 增删慢(数组结构)

　　LinkedList:

　　　　底层数据结构是链表，查询慢，增删快。无序

　　　　线程不安全，效率高。

　　

　　Vector 和 ArrayList 的区别：

　　　　Vector 是线程安全的，效率低

　　　　ArrayList是线程不安全的，效率高

　　共同点:都是数组实现的

　　ArrayList 和 LinkedList 的区别

　　　　ArrayList 底层是数组结果，查询和修改快

　　　　LinkedList 底层是链表结构的，增和删比较快，查询和修改比较慢

　　共同点：都是线程不安全的

* B: List 有三个儿子，我们到底使用谁呢？

　　查询多用ArrayList

　　增删多用LinkedList

　　如果都多ArrayList