06-集合

1.Collection集合

1.1数组和集合的区别【理解】

• 相同点

  都是容器,可以存储多个数据

• 不同点

  • 数组的长度是不可变的,集合的长度是可变的

  • 数组可以存基本数据类型和引用数据类型

    集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

public static void main(String[] args) {
        int[] arr1={1,2,3};
        String[] arr2={"a","b","c"};
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));

        System.out.println("----------------------");

        ArrayList<String> list1 = new ArrayList<>();
        list1.add("a");list1.add("b");list1.add("c");
        System.out.println(list1);

        //ArrayList<int> list2 = new ArrayList<>();//报错 只能存储引用数据类型 不能存储基本数据类型
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1);list2.add(2);list2.add(3);
        System.out.println(list2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.2集合类体系结构【理解】

蓝色外框都是接口、红色外框都是具体实现类

1.3Collection 集合概述和使用【应用】

• Collection集合概述

  • 是单列集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
  • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

• 创建Collection集合的对象

  • 多态的方式
  • 具体的实现类ArrayList

Collection集合常用方法(所有单列集合：list和set都 继承了的(共有)的方法)

代码1：add&remove

	public static void main(String[] args) {
        Collection<String> c =new ArrayList<>();//只能new实现类 不能new接口
        // boolean add(E e) | 添加元素
        c.add("aaa");c.add("bbb");c.add("ccc");
        System.out.println(c);//[aaa, bbb, ccc]
        //boolean remove(Object o)   | 从集合中移除指定的元素(成功返回true 失败返回false)
        print("remove");
        System.out.println(c.remove("aaa"));//true
        System.out.println(c.remove("ddd"));//false
        System.out.println(c);//[bbb, ccc]
    }

    public static void print(String s){
        System.out.println("-----------"+s+"-----------");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

代码2:removeIf

    public static void main(String[] args) {
        Collection<String> c =new ArrayList<>();//只能new实现类 不能new接口
        c.add("aaa");c.add("bbb");c.add("ccc");c.add("dddd");

        //boolean removeIf(Object o) | 根据条件进行删除
        /*removeIf底层会遍历集合,得到集合中的每一个元素
         s依次表示集合中的每一个元素
         就会把这每一个元素都到lambda表达式中去判断一下
         如果返回的是true,则删除
         如果返回的是false,则保留不删除.*/
        c.removeIf(  (String s)->{return s.length()==3;}/*删除长度为3的*/  );//传入lambda表达式 条件删除
        System.out.println(c);//[dddd]
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

代码3：清空集合中的元素

    public static void main(String[] args) {
        Collection<String> c =new ArrayList<>();//只能new实现类 不能new接口
        c.add("aaa");c.add("bbb");c.add("ccc");c.add("dddd");
        // void clear() | 清空集合中的元素
        System.out.println(c);//[aaa, bbb, ccc, dddd]
        c.clear();
        System.out.println(c);//[]
    }
1
2
3
4
5
6
7
8

代码4：判断集合中是否存在指定元素

    public static void main(String[] args) {
        Collection<String> c =new ArrayList<>();//只能new实现类 不能new接口
        c.add("aaa");c.add("bbb");c.add("ccc");c.add("dddd");

        //boolean contains(Object o) | 判断集合中是否存在指定的元素
        System.out.println(c.contains("aaa"));//true
        System.out.println(c.contains("cccc"));//false
    }
1
2
3
4
5
6
7
8

代码5：集合判空、集合长度

    public static void main(String[] args) {
        Collection<String> c =new ArrayList<>();//只能new实现类 不能new接口
        c.add("aaa");c.add("bbb");c.add("ccc");c.add("dddd");
        // boolean isEmpty() | 判断集合是否为空 
        System.out.println(c.isEmpty());//false
        // int size() | 集合的长度，也就是集合中元素的个数
        System.out.println(c.size());//4
    }
1
2
3
4
5
6
7
8

1.4Collection集合的遍历【应用】

• 迭代器介绍

  • 迭代器,集合的专用遍历方式
  • Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

• Iterator中的常用方法

  ​ boolean hasNext(): 判断当前位置是否有元素可以被取出
  ​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

• Collection集合的遍历

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

        //1.获取迭代器对象
        //迭代器对象一旦被创建出来，默认指向集合的0索引处
        Iterator<String> it = list.iterator();
        while (it.hasNext()){//当前位置是否有元素可以被取出
            System.out.println(it.next());//取出当前位置的元素 + 将迭代器往后移动一个索引的位置
        }
    }
1
2
3
4
5
6
7
8
9
10
11

• 迭代器中删除的方法

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

        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if("b".equals(s)){
                it.remove();
                //迭代器不会因为删除而导致指针混乱(应该自动帮你实现了it--啥的 或者it一起左移了)
            }
        }
        System.out.println(list);//[a, c, d]
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

普通根据下标删除的弊端

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

        for (int i = 0; i < list.size(); i++) {
            if("b".equals(list.get(i))){//ArrayList 才有get方法 Collection没有
                list.remove(i);
                i--;//必须i-- 否则bug list.remove(i);会自动将后面元素整体后移动(标准顺序表)然后表长-1
                //System.out.println(list.size());
            }
        }
        System.out.println(list);//[a, c, d]
        //remove后不加 i--;  输出[a, b, c, d] 原因，每次remove后集合元素会整体前移，然后i++,正好错过了相邻的b

        list.add("e");list.add("e");
        System.out.println(list);
        while (list.contains("e")) //结合api删除 多快 不过可能时间效率太慢了 不提倡
            list.remove("e");//一次remove只能删除一个
        System.out.println(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.5增强for循环【应用】

• 介绍

  • 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
  • 实现Iterable接口的类才可以使用迭代器和增强for
  • 简化数组和Collection集合的遍历 （Map接口没有继承Iterable接口 不能直接用 ）

• 格式

  ​ for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {

  ​ // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

  ​ }

• 代码

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

        //只能是数组或者Collection(单列集合)  Map不能用(需要自己实现Iterable接口后才可以用)
        for (String s : list) {
            System.out.print(s+" ");//a b b c d
        }
    }
1
2
3
4
5
6
7
8
9

注意：增强for无法修改集合

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

        //只能是数组或者Collection(单列集合)  Map不能用(需要自己实现Iterable接口后才可以用)
        for (String s : list) {
            s="q";//s只是list元素(新地址下)的一个副本 不要妄想通过增强for修改集合
        }
        System.out.println(list);//[a, b, b, c, d]
    }
1
2
3
4
5
6
7
8
9
10

三种循环使用场景

2.List集合

2.1List集合的概述和特点【记忆】

• List集合的概述
  • 有序集合,这里的有序指的是存取顺序
  • 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
  • 与Set集合不同,列表通常允许重复的元素
• List集合的特点
  • 存取有序
  • 可以重复
  • 有索引

2.2List集合的特有方法【应用】

List接口就有的

• 代码1：list基本使用

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//类型采用List接口类型
        list.add("aaa");list.add("bbb");list.add("bbb");

        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("---------------");
        for (String s : list) {
            System.out.println(s);             
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 代码2：List.add(index,element) 指定位置插入

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//类型采用List接口类型
        list.add("aaa");list.add("bbb");list.add("ccc");

        // void add(int index,E element)	在此集合中的指定位置插入指定的元素
        // 原来位置上的元素往后挪一个索引.
        list.add(0,"qqq");
        System.out.println(list);//[qqq, aaa, bbb, ccc]
}
1
2
3
4
5
6
7
8
9

• 代码3：List.remove(0) 删除指定位置处的元素

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//类型采用List接口类型
        list.add("aaa");list.add("bbb");list.add("ccc");

        // E remove(int index)  删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
        String s = list.remove(0);
        System.out.println(s);//aaa
        System.out.println(list);//[bbb, ccc]
        /* boolean remove(Object o) //Collection就有，继承下来的
          从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。 */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 代码4.1：List.set(index,元素) 修改指定索引处的元素 （被替换的那个元素,在集合中就不存在了）
• 代码4.2：List.get(int index) 返回指定索引处的元素

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//类型采用List接口类型
        list.add("aaa");list.add("bbb");list.add("ccc");

        // E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
        String s = list.set(0, "qqq");
        System.out.println(s);//aaa  (返回被修改消失的元素)
        System.out.println(list);//[qqq, bbb, ccc]

        // E get(int index)	 返回指定索引处的元素
        String s1 = list.get(0);
        System.out.println(s1);//qqq
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.数据结构

3.1数据结构之栈和队列【记忆】

• 栈结构

  ​ 先进后出

• 队列结构

  ​ 先进先出

3.2数据结构之数组和链表【记忆】

• 数组结构

  ​ 查询快、增删慢

• 队列结构

  ​ 查询慢、增删快

4.List集合的实现类

4.1List集合子类的特点【记忆】

• ArrayList集合

  ​ 底层是数组结构实现，查询快、增删慢 （add、remove、get…算法完全就是顺序表的那些操作，需要知道）
  [ArrayList.get(i) 数组当然可以随机访问(查看源码也确实有个数组)]

ArrayList.java源码里面一句话: private static final int DEFAULT_CAPACITY = 10;
则：初试数组容量0，第一次申请数组容量10 (以后再满了应该是1.5倍地增长 还带有原来数组元素的复制)

• LinkedList集合

  ​ 底层是链表结构实现，查询慢、增删快（add、remove、get…算法完全就是链表的那些操作，需要知道）

LinkedList也有get(i)方法，只不过效率很低罢了 [List接口继承下来的嘛]

    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");list.add("bbb");list.add("ccc");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));//链表的get(i)方法，效率很低
        }

        System.out.println("----------------------------");
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

        System.out.println("----------------------------");
        for (String s : list) {
            System.out.println(s);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.2LinkedList集合的特有功能【应用】

• 特有方法

  方法名	说明
  public void addFirst(E e)	在该列表开头插入指定的元素
  public void addLast(E e)	将指定的元素追加到此列表的末尾
  public E getFirst()	返回此列表中的第一个元素
  public E getLast()	返回此列表中的最后一个元素
  public E removeFirst()	从此列表中删除并返回第一个元素
  public E removeLast()	从此列表中删除并返回最后一个元素

5.泛型