Collection集合

Collection集合框架、List、泛型、数据结构、 Set、Map

——前言

第一次写博客，给大家详细介绍一下 Collection集合框架， Collection集合框架是javase中入门级别的内容，也是面试时经常问道的内容，学习Collection集合框架就必须学习数据结构和各个集合的底层结构，内容有点多我打算分为7章给大家详细讲解

第一章 Collection集合

• 集合：集合是java中提供的一种容器，可以用来存储多个引用数据类型的数据。

集合和数组既然都是容器，它们有什么区别呢？

• 数组的长度是固定的。集合的长度是可变的。
• 集合存储的都是引用数据类型。如果想存储基本类型数据需要存储对应的包装类类型。

知识点-- 单列集合常用类的继承体系

Collection：是单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口,分别是

• java.util.List: List的特点是元素存取有序、元素可重复 ;
  • List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，
• java.util.Set: Set的特点是元素不可重复。
  • Set接口的主要实现类有java.util.HashSet和java.util.LinkedHashSet，java.util.TreeSet。

为了便于初学者进行系统地学习，接下来通过一张图来描述集合常用类的继承体系

Collection集合: 是所有单列集合的父接口,所以定义了所有单列集合共有的方法
    List集合:是Collection集合的子接口,所以也表示单列集合(特点:元素存取有序,元素可重复)
        List集合的实现类: ArrayList类,LinkedList类
            
    Set集合: 是Collection集合的子接口,所以也表示单列集合(特点:元素不可重复)
        Set集合的实现类: HashSet类,LinkedHashSet类,TreeSet类

Collection 常用功能

• Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。
• Collection集合 常用功能

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中

tips: 有关Collection中的方法可不止上面这些，其他方法可以自行查看API学习。

public class Test {
     
    public static void main(String[] args) {
     
        // 创建Collection集合,限制集合中元素的类型为String类型
        Collection<String> col = new ArrayList<>();

        // public boolean add(E e)：  把给定的对象添加到当前集合中 。
        col.add("张三丰");
        col.add("张无忌");
        col.add("张翠山");
        col.add("曾阿牛");
        System.out.println("col:" + col);// [张三丰, 张无忌, 张翠山, 曾阿牛]

        // public void clear() :清空集合中所有的元素。
        //col.clear();
        //System.out.println("col:"+col);// []

        // public boolean remove(E e): 把给定的对象在当前集合中删除。
        col.remove("曾阿牛");
        System.out.println("col:" + col);// [张三丰, 张无忌, 张翠山]

        // public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
        boolean res1 = col.contains("曾阿牛");
        boolean res2 = col.contains("张无忌");
        System.out.println("res1:" + res1);// false
        System.out.println("res2:" + res2);// true

        // public boolean isEmpty(): 判断当前集合是否为空。
        boolean res3 = col.isEmpty();
        System.out.println("res3:" + res3);// false

        // public int size(): 返回集合中元素的个数。
        int size = col.size();
        System.out.println("size:" + size);// 3

        // public Object[] toArray(): 把集合中的元素，存储到数组中
        Object[] arr = col.toArray();
        System.out.println(Arrays.toString(arr));// [张三丰, 张无忌, 张翠山]

    }
}

第二章 Iterator迭代器

• 在程序开发中，经常需要遍历单列集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。

• 迭代的概念

• 获取迭代器对象

• Iterator接口的常用方法

迭代的概念

迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

获取迭代器对象

Collection集合提供了一个获取迭代器的方法：

• public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

Iterator接口的常用方法

• public E next():返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

案例演示

public class Test {
     
    public static void main(String[] args) {
     
        /*
            迭代:即Collection集合元素的通用获取方式。
                 在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来。
                 一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
            获取迭代器对象: 使用Collection集合的方法
                    public Iterator iterator(); 获取该集合对应的迭代器
            Iterator迭代器的方法:
                    public boolean hasNext();判断是否有元素可以迭代
                    public E next();获取可以迭代的元素
         */
        // 创建Collection集合,限制集合中元素的类型为String
        Collection<String> col = new ArrayList<>();

        // 添加元素到集合中
        col.add("张三丰");
        col.add("张翠山");
        col.add("张无忌");
        col.add("曾阿牛");

        // 获取col集合的迭代器对象
        Iterator<String> it = col.iterator();

        // 使用迭代器对象判断是否有元素可以迭代
        /*while (it.hasNext()) {
            // 如果有,就取出来
            String e = it.next();
            System.out.println(e);
        }*/
        // 快捷键:itit+回车
        while (it.hasNext()) {
     
            String e = it.next();
            System.out.println(e);
        }
    }
}

知识点-- 迭代器的常见问题

目标

• 理解迭代器的常见问题

路径

• 常见问题一
• 常见问题二

常见问题一

• 在进行集合元素获取时，如果集合中已经没有元素可以迭代了，还继续使用迭代器的next方法，将会抛出java.util.NoSuchElementException没有集合元素异常。

  public class Test1 {
         
      public static void main(String[] args) {
         
          /*
              常见问题一:在进行集合元素获取时，如果集合中已经没有元素可以迭代了，
                        还继续使用迭代器的next方法，将会抛出java.util.NoSuchElementException没有集合元素异常。
           */
          // 创建Collection集合,限制集合中元素的类型为String
          Collection<String> col = new ArrayList<>();
  
          // 添加元素到集合中
          col.add("张三丰");
          col.add("张翠山");
          col.add("张无忌");
          col.add("曾阿牛");
  
          // 获取迭代器对象
          Iterator<String> it = col.iterator();
  
          // 循环迭代
          while (it.hasNext()) {
         
              String e = it.next();
              System.out.println(e);
          }
  
          System.out.println("===============================");
          
          // 问题:报异常NoSuchElementException,没有找到集合元素异常
          // String e = it.next();
  
          // 解决办法:再重新获取一个迭代器
          // 获取迭代器对象
          Iterator<String> it1 = col.iterator();
  
          // 循环迭代
          while (it1.hasNext()) {
         
              String e = it1.next();
              System.out.println(e);
          }
      }
  }
  
  

• 解决办法: 如果还需要重新迭代,那么就重新获取一个新的迭代器对象进行操作

常见问题二

• 在进行集合元素迭代时，如果添加或移除集合中的元素 , 将无法继续迭代 , 将会抛出ConcurrentModificationException并发修改异常.

  public class Test2 {
         
      public static void main(String[] args) {
         
          /*
              常见问题二:
                    在进行集合元素迭代时，如果添加或移除集合中的元素 ,
                    将无法继续迭代 , 将会抛出ConcurrentModificationException并发修改异常.
           */
          // 创建Collection集合,限制集合中元素的类型为String
          Collection<String> col = new ArrayList<>();
  
          // 添加元素到集合中
          col.add("张三丰");
          col.add("张翠山");
          col.add("张无忌");
          col.add("曾阿牛");
  
          // 获取迭代器对象
          Iterator<String> it = col.iterator();
  
          // 循环迭代
          while (it.hasNext()) {
         
              String e = it.next();
              // 如果迭代出来的元素是张翠山,就添加一个殷素素到集合中
              /*if (e.equals("张翠山")){
                  col.add("殷素素");
              }*/
              // 解决办法:换允许并发修改的集合
  
              // 如果迭代出来的元素是张翠山,就删除该元素
              /*if (e.equals("张翠山")){
                  col.remove(e);
              }*/
              // 解决办法: 删除元素可以使用迭代器的remove()方法
              if (e.equals("张翠山")){
         
                  it.remove();
              }
          }
          System.out.println("col:"+col);
      }
  }
  
  

知识点-- 迭代器的实现原理

​ 我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

​ Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素。在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

知识点-- 增强for

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

for(元素的数据类型  变量名 : Collection集合or数组){
      
  	
}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

代码演示

public class Test {
     
    public static void main(String[] args) {
     
        // 使用增强for循环遍历集合:
        // 创建Collection集合,限制集合中元素的类型为String类型
        Collection<String> col = new ArrayList<>();

        // public boolean add(E e)：  把给定的对象添加到当前集合中 。
        col.add("张三丰");
        col.add("张无忌");
        col.add("张翠山");
        col.add("曾阿牛");

        // 快捷键: 集合名.for
        for (String e : col) {
     
            System.out.println(e);
        }

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

        // 使用增强for循环遍历数组
        String[] arr = {
     "张三丰",
                "张无忌",
                "张翠山",
                "曾阿牛"};

        // 快捷键:数组名.for
        for (String e : arr) {
     
            System.out.println(e);
        }
    }
}

tips:

增强for循环必须有被遍历的目标，目标只能是Collection或者是数组；

增强for（迭代器）仅仅作为遍历操作出现，不能对集合进行增删元素操作，否则抛出ConcurrentModificationException并发修改异常

小结

增强for循环:
	概述:jdk1.5之后提出的一个增强的for循环,底层采用的是迭代器
    格式:
        for(数据类型 变量名 : 数组名\集合名){
     }
    注意:增强for循环遍历操作的时候,不能对集合进行增删元素操作,否则会报并发修改异常
        增强for循环主要用来遍历数组和集合
    总结:
		Collection集合的遍历方式: 迭代器,增强for循环
            数组的遍历方式: 增强for循环,普通for循环(while)

第三章 泛型

• 集合不使用泛型的时候，存的时候什么类型都能存。但是取的时候就懵逼了。取出来啥也不是。

  public class Test1 {
         
      public static void main(String[] args) {
         
          // 集合不使用泛型的时候，存的时候什么类型都能存。但是取的时候就懵逼了。取出来啥也不是。
          // 创建一个单列集合,不指定泛型
          Collection col = new ArrayList();
  
          // 往集合中存储元素
          col.add("itheima");
          col.add("itcast");
          col.add(100);
          col.add(3.14);
          System.out.println(col);// [itheima, itcast, 100, 3.14]
  
          // 取元素
          // 需求:打印集合中字符串元素的字符长度
          for (Object obj : col) {
         
              String str = (String)obj;
              System.out.println(str.length());
          }
      }
  }
  
  

• 使用泛型

  • 使用泛型在编译期直接对类型作出了控制，只能存储泛型定义的数据

  public class Test2 {
         
      public static void main(String[] args) {
         
          // 使用泛型在编译期直接对类型作出了控制，只能存储泛型定义的数据
          
          // 创建一个单列集合,不指定泛型
          Collection<String> col = new ArrayList<>();
  
          // 往集合中存储元素
          col.add("itheima");
          col.add("itcast");
          //col.add(100);// 编译报错
          //col.add(3.14);// 编译报错
          System.out.println(col);// [itheima, itcast]
  
          // 取元素
          // 需求:打印集合中字符串元素的字符长度
          for (String s : col) {
         
              System.out.println(s.length());
          }
  
      }
  }
  
  

• 泛型：可以在类或方法中预知地使用未知的类型。在使用的时候,确定泛型的具体数据类型

tips:泛型的作用是在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

小结

略

知识点–定义和使用含有泛型的类

目标

• 定义和使用含有泛型的类

路径

• 定义含有泛型的类
• 确定泛型具体类型

讲解

定义含有泛型的类

• 格式:

  定义含有泛型的类:
      public class 类名<泛型变量>{
         
      }
      泛型变量: 任意字母,一般会使用E
  

• 案例:

public class MyGenericClass<E> {
     
    // 成员变量
    E e;

    // 成员方法
    public void method1(E e){
     
        System.out.println(e);
    }

}

使用含有泛型的类

• 创建泛型类对象的时候,指定泛型的具体数据类型

public class Test {
     
    public static void main(String[] args) {
     
        /*        
            使用含有泛型的类: 创建泛型类对象的时候,指定泛型的具体数据类型
         */
        MyGenericClass<String> mc1 = new MyGenericClass<>();
        mc1.e = "itheima";
        mc1.method1("itcast");

        System.out.println("==========================");
        MyGenericClass<Integer> mc2 = new MyGenericClass<>();
        mc2.method1(100);
    }
}

知识点–定义和使用含有泛型的方法

定义含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }
泛型变量可以是任意字母,一般会使用T

例如，

// 定义一个含有泛型的方法
public static <T> T method(T t){
     
    System.out.println("method..."+t);
    return t;
}

确定泛型具体类型

调用方法时，确定泛型的类型

public class Test {
     
    public static void main(String[] args) {
     
        /*
            定义含有泛型的方法:
                修饰符 <泛型变量> 返回值类型 方法名(形参列表){方法体}
                注意: 泛型变量可以是任意字母,一般使用T

            使用含有泛型的方法: 调用方法的时候,指定泛型的具体数据类型

         */
        String res1 = method("itheima");
        Integer res2 = method(100);
    }

    // 定义一个含有泛型的方法
    public static <T> T method(T t){
     
        System.out.println("method..."+t);
        return t;
    }
}

知识点–定义和使用含有泛型的接口

定义含有泛型的接口

定义格式：

修饰符 interface 接口名<代表泛型的变量> {  }

例如，

public interface MyGenericInterface<E> {
     
    public abstract void method1(E e);
    public abstract void method2(E e);
}

确定泛型具体类型

使用格式：

1、定义实现类时确定泛型的类型

public class 类名 implements 接口名<具体的数据类型>{
     
}

例如

// 实现类实现接口的时候,确定接口泛型的具体数据类型
public class MyImp1 implements MyGenericInterface<String>{
     

    @Override
    public void method1(String s) {
     
        System.out.println(s);
    }

    @Override
    public void method2(String s) {
     
        System.out.println(s);
    }
}

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

实现类实现接口的时候,不确定接口泛型的具体数据类型,创建实现类对象的时候确定泛型的具体数据类型
    public class 类名<泛型变量> implements 接口名<泛型变量>{
     
    }

例如

public class MyImp2<E> implements MyGenericInterface<E> {
     
    @Override
    public void method1(E e) {
     
        System.out.println(e);
    }

    @Override
    public void method2(E e) {
     
        System.out.println(e);
    }
}

确定泛型：

/*
 * 使用
 */
public class GenericInterface {
     
    public static void main(String[] args) {
     
        // 创建实现类对象
        MyImp2<String> imp2 = new MyImp2<>();
        imp2.method1("java");

        // 创建实现类对象
        MyImp2<Integer> imp3 = new MyImp2<>();
        imp3.method1(100);
    }
}

小结

知识点-- 泛型通配符

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示泛型通配符。

此时只能接受数据,不能往该集合中存储数据。

例如:

public class Test {
     
    public static void main(String[] args) {
     
        /*
            泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示泛型通配符。
            注意:泛型没有多态
         */
        //ArrayList