day15（集合）

1.集合的由来及集合继承体系图

a.集合的由来
  数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
b.数组和集合的区别

• 区别1 :

  * 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
  * 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
  

• 区别2:

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

• c.数组和集合什么时候用

  * 如果元素个数是固定的推荐用数组
  * 如果元素个数不是固定的推荐用集合
  

2.Collection集合的基本功能测试

    boolean add(E e) //添加
    boolean remove(Object o) //删除(第一次)
    void clear() //清除
    boolean contains(Object o) //包含
    boolean isEmpty() //检查是否为空
    int size() //大小

3.集合的遍历

• a. 把集合转成数组，可以实现集合的遍历

    Object[] arr = coll.toArray();  

• b.迭代器遍历

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

4.Collection集合的带All功能测试

• boolean addAll(Collection c)
• boolean removeAll(Collection c)

• boolean containsAll(Collection c)

  一个集合中是否包含另一个集合,如果包含则返回true，否则返回false
  

• boolean retainAll(Collection c)

  retainAll 取交集,如果调用的那个集合发生了改变则返回true，否则返回false
  

5.迭代器的原理及源码解析

• 迭代器原理:

  *迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

• 查看源码

6.List集合的特有功能概述和测试

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

7.并发修改异常

• a.我有一个集合，请问，我想判断里面有没有”world”这个元素，如果有，我就添加一个”javaee”元素，请写代码实现。

public class Bingfa {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            String string = (String) iterator.next();
            if(string.equals("b")){
                list.add("d");
            }
        }
        System.out.println(list);
    }
} 
//这里会抛出ConcurrentModificationException并发修改异常

• b.ConcurrentModificationException出现原因
  
  • 迭代器遍历，集合修改集合(在Collection上进行迭代时，通常不允许另一个线性修改该 Collection。)
• c.解决方案
  
  • 迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)

public class Bingfa {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        ListIterator iterator = list.listIterator();
        while(iterator.hasNext()){
            String string = (String) iterator.next();
            if(string.equals("b")){
                iterator.add("d");
            }
        }
        System.out.println(list);//[a, b, d, c]
    }
}

8.ListIterator

• boolean hasNext()是否有下一个
• boolean hasPrevious()是否有前一个
• Object next()返回下一个元素
• Object previous();返回上一个元素

public class Temp1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("a");
        list.add("b");
        //ArrayList封装了一个实现了ListIterator接口的内部类ListItr
        ListIterator iterator = list.listIterator();
        if(iterator.hasNext()){
            System.out.println(iterator.next()); //a
        }
        if(iterator.hasPrevious()){
            System.out.println(iterator.previous()); //a
        }
    }
}

9.Vector类

a.特有功能

* public void addElement(E obj)
* public E elementAt(int index)

b.迭代

            Vector v = new Vector();        //创建集合对象,List的子类
            v.addElement("a");
            v.addElement("b");
            v.addElement("c");
            v.addElement("d");

            //Vector迭代
            Enumeration en = v.elements();  //获取枚举
            while(en.hasMoreElements()) {   //判断集合中是否有元素
            System.out.println(en.nextElement());//获取集合中的元素
            }

10.数据结构之数组和链表

• A:数组
  
  • 查询快修改也快
  • 增删慢
• B:链表
  
  • 查询慢,修改也慢
  • 增删快

11.List的三个子类的特点

• a.List的三个子类的特点

  • ArrayList:
    底层数据结构是数组，查询快，增删慢。
    线程不安全，效率高。
  • LinkedList:
    底层数据结构是链表，查询慢，增删快。
    线程不安全，效率高。

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

  • Vector和ArrayList的区别
    Vector是线程安全的,效率低
    ArrayList是线程不安全的,效率高

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

• b.使用

  • 查询多用ArrayList
  • 增删多用LinkedList
  • 如果都多ArrayList

12.链表的分类

• 单向链表
• 单向循环列表
• 双向链表
• 双向循环链表

//单向链表
public class Node_main {
    public static void main(String[] args) {
        Node node1 = new Node("节点1");
        Node node2 = new Node("节点2");
        Node node3 = new Node("节点3");
        Node node4 = new Node("节点4");

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;

        //添加(在node2和node3之间添加节点node5)
        Node node5 = new Node("节点5");
        node2.next = node5;
        node5.next = node3;
        System.out.println(node2.next.getData());

        //删除节点(删除node2)
        node1.next = node5;
        node5.next = node3;
        System.out.println(node1.next.getData());
    }
}

class Node {
    private String data;
    public Node next; //后一个元素

    public Node(String str) {
        this.data = str;
    }
    public String getData() {
        return data;
    }
}

//双向链表
public class Node2_main {
    public static void main(String[] args) {
        Node2 node1 = new Node2("节点1");
        Node2 node2 = new Node2("节点2");
        Node2 node3 = new Node2("节点3");
        Node2 node4 = new Node2("节点4");

        node1.next = node2;
        node2.prev = node1;

        node2.next = node3;
        node3.prev = node2;

        node3.next = node4;
        node4.prev = node3;

        //添加(在node2和node3之间添加node5)
        Node2 node5 = new Node2("节点5");
        node2.next = node5;
        node5.prev = node2;
        node5.next = node3;
        node3.prev = node5;
        System.out.println(node2.next.getData());

        //删除(删除node2)
        node2.prev = null;
        node2.next = null;
        node1.next = node5;
        node5.prev = node1;
        System.out.println(node1.next.getData());
    }
}

class Node2 {
    private String data;
    public Node2 prev; //前一个元素
    public Node2 next;  //后一个元素

    public Node2(String str) {
        this.data = str;
    }
    public String getData() {
        return data;
    }
}