集合（Collection List） 数据结构概述

集合

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

A:集合的由来
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
java提供多种集合类，它们的数据结构不同，但它们肯定有共性的内容，比如存储，获取，判断等，通过把共性部分向上提取，就能得到一个集合的继承体系结构图。
B:数组和集合的区别
(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
C:集合继承体系图

Collection集合

1，Collection集合的功能

A:Collection的功能概述(通过API查看即可得到)
	a:添加功能
		boolean add(Object obj):添加一个元素
		boolean addAll(Collection c):添加一个集合的元素  (给一个集合添加进另一个集合中的所有元素)
	b:删除功能
		void clear():移除所有元素
		boolean remove(Object o):移除一个元素
		boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 
		如果没有交集元素 则删除失败 返回false
	c:判断功能
		boolean contains(Object o)：判断集合中是否包含指定的元素	
		boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
		比如：1，2，3 containsAll 12=true   1,2,3 containsAll 2,3,4=false
		boolean isEmpty()：判断集合是否为空
	d:获取功能
		Iterator<E> iterator()(重点)
		boolean hasNext ()
           如果仍有元素可以迭代，则返回 true。 判断还有没有下一个元素可以迭代
        E next ()
           获取元素，并移动到下一个位置
		e:长度功能
			int size():元素的个数
			面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
		f:交集功能
			//例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化 ,如果没有取到交集元素，那么A集合就会清空掉
			boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
		g:把集合转换为数组
			Object[] toArray()

collection功能的测试

public class Test1 {
    public static void main(String[] args) {
        //从上往下学习，先看根接口中的方法
        //采用多态
        Collection collection=new ArrayList();
        //Collection集合的基本功能测试
        //添加功能
        //添加一个元素 boolean add(Object obj) 返回值表示是否添加成功
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        boolean b=collection.add(100);
        System.out.println(b);//true
        //把一个集合中的元素，添加到一个集合中 boolean addAll(Collection c)
        Collection list2 = new ArrayList();
        list2.add(400);
        list2.add(500);
        list2.add(600);
        boolean c=collection.addAll(list2);
        System.out.println(collection);
        //删除功能
        //boolean remove(Object o):移除一个元素
        boolean b1=collection.remove("aaa");
        System.out.println(collection);
        //清空集合 void clear():移除所有元素
        list2.clear();
        System.out.println(list2);
        System.out.println("=====================");
        Collection collection1 = new ArrayList();
        collection1.add("aaa");
        collection1.add("bbb");
        collection1.add("ccc");
        collection1.add("ddd");
        //boolean removeAll(Collection c) 删除的元素是两个集合的交集元素
        //如果有交集元素被删除，就返回true，没有就返回false
        boolean e=collection.removeAll(collection1);
        System.out.println(e);
        System.out.println(collection);
        System.out.println("=======================");
        //判断功能
        //boolean contains(Object o)：判断集合中是否包含指定的元素
        boolean f=collection.contains(500);
        System.out.println(f);//true
        //boolean containsAll(Collection c)  判断集合中是否包含指定的集合中的所有元素
        Collection d=new ArrayList();
        d.add(100);
        d.add(400);
        d.add(500);
        d.add(600);
        boolean ff=collection.containsAll(d);
        System.out.println(ff);//true
        System.out.println("==================");
        //交集功能
        Collection list1 = new ArrayList();
        list1.add(100);
        list1.add(200);
        list1.add(300);
        list1.add(700);
        Collection list3 = new ArrayList();
        list3.add(100);
        list3.add(200);
        list3.add(300);
        list3.add(400);
        list3.add(500);
        list3.add(600);
        //boolean retainAll(Collection c):获取两个集合的交集元素 如果没有取到交集元素，A集合会清空掉
        boolean b2=list1.retainAll(list3);
        System.out.println(b2);//如果取完交集后，A集合对比他之前的元素，发生过变化，就返回true，如果没有发生过变化，就返回false
        System.out.println(list1);
    }
}

2，Collection集合的遍历

转成数组后遍历

public class Test2 {
    public static void main(String[] args) {
        //把集合转换为数组
        Collection list2 = new ArrayList();
        list2.add(100);
        list2.add(200);
        list2.add(300);
        list2.add(400);
        list2.add(500);
        list2.add(600);
        //自己实现
        Integer[] integers = new Integer[list2.size()];
        Iterator iterator=list2.iterator();
        int i=0;
        while (iterator.hasNext()){
            Integer ii=(Integer)iterator.next();
            integers[i]=ii;
            i++;
        }
        System.out.println(Arrays.toString(integers));
        //只需要调用方法即可 toArray()
        Object[] f=list2.toArray();
        System.out.println(Arrays.toString(f));
    }
}

使用迭代器遍历：

public class Test {
    public static void main(String[] args) {
        //遍历Collection 集合
        Collection collection = new ArrayList();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        //Iterator<E> iterator () 返回在此 collection 的元素上进行迭代的迭代器
        Iterator iterator = collection.iterator();
        //java.util.ArrayList$Itr 迭代器 是ArrayList的内部类
        //通过迭代器，来迭代集合中的元素
        /* 接口 Iterator<E>  迭代器中的方法
           boolean hasNext ()
           如果仍有元素可以迭代，则返回 true。 判断还有没有下一个元素可以迭代
           E next ()
           返回迭代的下一个元素  移动到下一个位置
         * */
        while (iterator.hasNext()){
            iterator.next();//注意：不要多次使用next方法
        }
    }
}

3,迭代器的原理及源码解析

迭代器原理:	为什么迭代器不定义成一个类 , 而是定义成一个接口?
               假设迭代器定义的是一个类，这样我们就可以创建该类的对象，调用该类的方法来实现集合的遍历，但是，java中提供了很多的集合类，而这些集合类的数据结构不同，所以，存储的方式和遍历的方式应该是不同的，所以不定义成迭代器类。
               而无论是那种集合，都应该具备获取元素的操作，而且，最好再辅助以判断功能。在获取前先判断，这样更不容易出错。也就是说，判断和获取功能应该是一个集合遍历所具备的，而每种集合的方式又不一样，所以我们把这两个功能提取出来，并不给出具体实现，这种方式就是接口。
               在具体的子类中，以内部类的方式实现。
迭代器源码解析
public interface Iterator<E>{
   public abstract boolean hasNext();
   public abstract  E next();
}
public interface Iterable<T>{
    Iterator<T> iterator();
}
public interface Collection extends Iterable{
    Iterator<E> iterator();
}
public interface List extends Collection{
    Iterator<E> iterator();
}
public class ArrayList implements List{
    public Iterator<E> iterator(){
        return new Itr();
    }
    private class Itr implements Iterator<E>{
        public boolean hasNext(){.实现....}
        public E next(){..实现....}
    }
}

List集合

1，List概述及特点

List概述及特点:	元素有序(存的顺序和取的顺序一致),并且每一个元素都存在一个索引.元素可以重复.

2,List集合的特有功能

List集合的特有功能概述
	void add(int index,E element):	在指定索引处添加元素
	int indexOf(Object o)返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1
    
	E remove(int index):移除指定索引处的元素  返回的是移除的元素
	E get(int index):获取指定索引处的元素
	E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
	List<E> subList(int fromIndex, int toIndex)
	返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

特有功能测试

public class Test {
    public static void main(String[] args) {
       //List集合的特有功能测试
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        //在指定索引处添加元素
        list.add(1,300);
        System.out.println(list);
        //通过索引来获取元素
        Object o=list.get(0);
        System.out.println(o);
        //返回此列表中第一次出现的指定元素的索引
        int i=list.indexOf(100);
        System.out.println(i);
        //返回此列表中最后出现的指定元素的索引
        int j=list.lastIndexOf(200);
        System.out.println(j);
        //删除功能
        //根据元素删除 返回的是 是否删除成功
        boolean b=list.remove(Integer.valueOf(100));//元素和索引区分不出来 手动包装一下，就区分出来了
        System.out.println(b);
        System.out.println(list);
        //根据索引删除元素，返回的是你删除的那个元素
        Object q=list.remove(0);
        System.out.println(q);
        System.out.println(list);
        System.out.println("===========================");
       //替换功能
       //E set ( int index, E element) 根据索引来替换集合中的元素，返回的是替换之前的旧元素
        List list1 = new ArrayList();
        list1.add(100);
        list1.add(200);
        list1.add(300);
        list1.add(400);
        Object e=list1.set(0,1000);
        System.out.println(e);
        System.out.println(list1);
        //截取功能
        //List<E> subList(int fromIndex, int toIndex) 根据起始索引和终止索引，截取集合中的一部分元素到一个新集合中
        List list2=list1.subList(0,3);
        System.out.println(list2);

    }
}

3,List集合的遍历

public class Test1 {
    public static void main(String[] args) {
        //遍历list集合
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
        list.add(600);
        //遍历方式1 父接口的迭代器遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //遍历方式2 List集合里面有 get() 和 size()配合可以使用 for循环来遍历
       for (int i=0;i<list.size();i++){
           Object o=list.get(i);
           Integer num=(Integer)o;
           System.out.println(num.intValue());
       }
       //遍历方式3 可以使用List自己特有的迭代器
        /*
        ListIterator<E> listIterator ()  返回此列表元素的列表迭代器（按适当顺序）。
        ListIterator 继承自 Iterator
        */
        ListIterator listIterator=list.listIterator();
        while (listIterator.hasNext()){
            Object o=listIterator.next();
            System.out.println(o);
        }
    }
}

4,ListIterator的特有功能

ListIterator 继承自Iterator  可以使用Iterator中的方法
​	A:ListIterator的特有功能
​		boolean hasPrevious():			是否存在前一个元素
​		E previous():					返回列表中的前一个元素
​		以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历  这样指针才能移到最后
​		如果直接反向遍历是没有效果的  因为指针默认位置就在最前面 他前面没有元素

反向迭代

public class Test2 {
    public static void main(String[] args) {
        /*
      ListIterator 中的特有的方法 可以进行反向迭代
      boolean hasPrevious ()
      如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
      E previous ()
      返回列表中的前一个元素。*/
        //先进行正向迭代，才能进行反向迭代 使用同一个迭代器对象
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //正向迭代
        ListIterator listIterator=list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        //反向迭代
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }
}

并发修改异常产生的原因及解决方案

A:案例演示
	需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
B:ConcurrentModificationException出现
	我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
	原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器  那么迭代器已经知道了集合的元素个数
	这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法）打乱了迭代器的迭代顺序 那迭代器不同意 就报错了
C:解决方案 我们用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
	a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
	b:集合遍历元素，集合修改元素

	解决方案2 使用for循环遍历集合 添加元素 不会报错

例

public class Test3 {
    public static void main(String[] args) {
      //并发修改异常产生的原因及解决方案
      /* A:
        案例演示
        需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，
        如果有，我就添加一个 "javaee" 元素，请写代码实现。*/
        List list = new ArrayList();
        list.add("aaa");
        list.add("world");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        //遍历集合，然后判断
        //如果用集合的add方法添加元素，会报异常
        //使用迭代器  ConcurrentModificationException 并发修改异常
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String ele=(String)listIterator.next();
            if ("world".equals(ele)){
                //使用迭代器自己的方法来增删
                listIterator.add("javaee");
            }
        }
        System.out.println(list);
    }
}

数据结构

栈和队列

A:数据结构概述及常见数据结构
	数据结构其实就是存储数据的格式
	分类:	栈 , 队列 , 数组 , 链表 , 树 , 哈希表
B:栈特点: 	先进后出
C:队列: 	先进先出

数组和链表

A:数组特点:	查询快 , 增删慢
B:链表特点: 	查询慢 , 增删快

List的三个子类的特点

A:List的三个子类的特点
	ArrayList:
		底层数据结构是数组，查询快，增删慢。
		线程不安全，效率高。
	Vector:
		底层数据结构是数组，查询快，增删慢。
		线程安全，效率低。
	LinkedList:
		底层数据结构是链表，查询慢，增删快。
		线程不安全，效率高。
B:List有三个儿子，我们到底使用谁呢?
得看  要安全还是要效率
  是查找多还是增删多

据的格式
分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表
B:栈特点: 先进后出
C:队列: 先进先出

[外链图片转存中...(img-C9jeV78e-1589358189038)]

## 数组和链表

A:数组特点: 查询快 , 增删慢
B:链表特点: 查询慢 , 增删快

[外链图片转存中...(img-N66cZ7vP-1589358189040)]

## List的三个子类的特点

A:List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
B:List有三个儿子，我们到底使用谁呢?
得看 要安全还是要效率
是查找多还是增删多