• 集合之究极进阶最终形态之暴龙战士！

    Collection：“我本是java界的集合之王，却被给诡计多端的List、Set、Map所害！List弃我！Set逐我！Map甚至想谋朝篡位替代我！小伙子我将把我全部功力传授于你，给你一个机会打败它们！我只想夺回我在集合界的地位！。”

    目录

    Collection

    集合基础知识回顾

    集合类体系结构-单列集合

    集合类体系结构-双列集合

    单列集合中的存储问题

    Collection集合概述和使用

    Collection集合的常用方法

    Collection集合的遍历

    集合的使用步骤

    案例:Collection集合存储学生对象并遍历

    Collection

    集合基础知识回顾

    当时学习了ArrayList集合,还用ArrayList集合完成了学生管理系统。在集合基础知识部分就已经说过了集合类的特点。

    1. 集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变。

    集合类体系结构-单列集合

    集合最主要的作用就是用来存储和取出数据的。

    现在我有三个数据的，很明显这三个数据是单列的，那么这样的数据在集合中存储它是通过Collection来实现的，所以说Collection集合它是单列集合。

    集合类体系结构-双列集合

    这样的数据就是有itcast1张三、itcast2李四、itcast3王五，这样的双列数据组成的。他都输由双列组成的，这样的数据在存储中是通过Map集合来实现的，所以Map集合也被称做双列集合。

    单列集合中的存储问题

    看这里图中数据出现了两个张三，这样的数据在单列集合中我们是同List集合实现的，所以说List集合中存储的元素是可重复的。

    如果我们在集合中存储张三、李四、张三，但是第二个张三没有存储成功，那么这种数据存储我们在单列集合中使用的是Set集合来实现的，所以说Set集合存储数据的时候元素是不能重复的。

    这些集合都是接口并不能直接创建对象并使用，所以我们还要来学习具体的实现类。

    注意：用浅蓝色标记的是接口，红色窗口标记的是实现类。

         在List下面，我们学习过ArrayList也是最常用的集合之一，我们也要学习LinkedList，至于其他的实现类我们不学习。

         在Set下面我们重要学习HashSet和TreeSet，其他的不学习。

         在Map下面我们重点学习HashMap，其他的不学习，而这里没有讲解的集合类它们可以按照讲解的格式自学并使用。

         我们在学习的时候学的是接口，而在使用的时候使用的就是实现类。为什么会首先学习接口呢？

    答：比如说我们学得Collection接口将来在学习List接口和Set接口的时候我们只需要学习它们的特有功能就可以了；再比如说在学习ArrayList和LinkedList的时候，我也只需要学习它们的特有功能就可以了。而在使用的时候，要使用具体的实现类，因为接口是抽象的是不能创建对象并实例化的。他必须通过具体的实现类来创建对象并实例化。

    Collection集合概述和使用

    先到帮助文档中查看。

    他在java.util包下，所以使用它需要导包。<E>表示泛型，表示集合中的元素类型。再往下看：

    看上述描述，它是一个接口继承自Iterable<E>类，JDK不提供此接口的任何直接实现，他提供了更具体的子接口的实现，如Set和List说明，Collection这个接口他并没有具体的实现类，他将来想要创建对象就必须使用它的子接口Set或者List来创建对象。

    Collection集合概述：

    1. 是单列集合的顶层接口，他表示一组对象，这些对象称为Collection的元素。
    2. JDK不提供此接口的任何直接实现，他提供更具体的子接口（如Set和List）实现。

    创建Collection集合的对象

    1. 多态的方式
    2. 具体的实现类ArrayList（学过的），List接口继承自Collection接口，所以我们就可以通过具体的实现类ArrayList来创建Collection对象。

    程序演示：

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3.  
    4. /*
    5.     创建Collection集合的对象
    6.         多态的方式
    7.         ArrayList()
    8.  */
    9. public class CollectionDemo01 {
    10.     public static void main(String[] args) {
    11.         //1.创建Collection集合对象
    12.         Collection<String> collection = new ArrayList<String>();
    13.  
    14.         //2.添加元素,boolean add(E e);
    15.         collection.add("hello");
    16.         collection.add("world");
    17.         collection.add("java");
    18.  
    19.         //3.输出集合对象
    20.         System.out.println(collection);//[hello, world, java]
    21.         /*
    22.         4.注意,我们输出的collection对象是new出来的,输出的结果不是地址值说明它
    23.         有重写toString方法.
    24.          */
    25.     }
    26. }

    Collection集合的常用方法

    注意：使用clear方法会将集合中的所有元素都干掉，所以使用它的时候要慎重。

    先演示一下如何查看一个类的所有信息：

    然后我们来找boolean add(E)方法:

    由此可见调用add这个方法他永远返回的都是true。

    （或者直接跟进到类中，按下Alt+7 与上图效果同理）

    程序演示：

    1. /*
    2.     Collection集合的常用方法:
    3.         boolean add(E a):添加元素.
    4.         boolean remove(Object o):从集合中一处指定的元素.
    5.         void clear():清空集合中的元素.
    6.         boolean contains(Object o):判断集合中是否存在指定的元素
    7.         boolean isEmpty():判断集合是否为空
    8.         int size():集合的长度,也就是集合中元素的个数
    10.     Alt+7可以打开一个窗口可以看到一个类的,所有信息.
    11.  */
    12. public class CollectionDemo02 {
    13.     public static void main(String[] args) {
    14.         //1.创建集合对象
    15.         Collection<String> c = new ArrayList<String>();
    16.         //2.boolean add(E a):添加元素.返回一个boolean类型的结果
    17.         System.out.println(c.add("hello"));//true,添加成功
    18.         System.out.println(c.add("world"));//true
    19.         System.out.println(c.add("java"));//true
    20.         System.out.println(c.add("java"));//true,这里还是true说明这个集合可以添加重复的
    21. //        System.out.println(c);//输出集合中的元素,[hello, world, java]
    22.         //3.跟进查看add方法,可以看到add方法永远都是返回的true说明它可以无限制添加重复内容
    23.         System.out.println("--------------");
    24.  
    25.         //4.boolean remove(Object o):从集合中一处指定的元素.
    26.         System.out.println(c.remove("world"));//true,说明移除成功
    27.         System.out.println(c.remove("javaweb"));//false,说明集合中没有就不会删除任何数据
    28.         System.out.println(c);//[hello, java, java]
    29.         System.out.println("--------------");
    30.  
    31.         //5.void clear():清空集合中的元素.注意返回值是void,所以直接使用对象调用即可
    32.         c.clear();
    33.         System.out.println(c);//[]
    34.         System.out.println("--------------");
    35.  
    36.         //6. boolean contains(Object o):判断集合中是否存在指定的元素
    37.         System.out.println(c.contains("java"));//因为上一步clear将集合中所有的数据都删除了,所以判断结果为false
    38.         //7.添加数据再判断
    39.         c.add("hello");
    40.         c.add("world");
    41.         c.add("java");
    42.         System.out.println(c.contains("java"));//true,说明集合中这个元素是存在的,注意这只是判断不会做其他的操作
    43.         System.out.println(c.contains("javaweb"));//false,因为集合元素中没有javaweb这个元素
    44.         System.out.println("--------------");
    45.  
    46.         //8.boolean isEmpty():判断集合是否为空
    47.         System.out.println(c.isEmpty());//false,不为空
    48.         c.clear();//删除集合中的所有元素
    49.         System.out.println(c.isEmpty());//true,为空
    50.         System.out.println(c);//[]
    51.         System.out.println("--------------");
    52.  
    53.         //int size():集合的长度,也就是集合中元素的个数
    54.         System.out.println(c.size());//0,因为集合中没有元素,所以长度为0
    55.         c.add("java");
    56.         c.add("is my favourite");
    57.         System.out.println(c.size());//2,集合中有两个元素
    58.         System.out.println(c);//[java, is my favourite]
    59.     }
    60. }

    Collection集合的遍历

    iterator概述：

    Iterator：迭代器，集合的专用遍历方式

    1. Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到。
    2. 迭代器是通过集合的iterator（）方法得到的，所以我们说它是依赖于集合而存在的。

    先到帮助文档中查看：

    迭代器是一个接口，他在java.util包下，所以使用它需要导包，他也有泛型，这里的泛型<E>和集合中的泛型是一致的。

    重点说里面的两个方法。

    1. E next（）：用于获取下一个元素的值。
    2. Boolean hasNext（）：用于做判断的，如果迭代中有更多元素，则返回true；如果没有元素就返回false。

    程序演示：

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Iterator;
    4.  
    5. /*
    6.     Iterator:迭代器,集合的专用遍历方式.
    7.         	Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到。
    8.         	迭代器是通过集合的iterator（）方法得到的，所以我们说它是依赖于集合而存在的。
    10.     Iterator中的常用方法:
    11.         	E next（）：用于获取下一个元素的值。
    12.         	Boolean hasNext（）：用于做判断的，如果迭代中有更多元素，则返回true；如果没有元素就返回false。
    14.  */
    15. public class IteratorDemo {
    16.     public static void main(String[] args) {
    17.         //1.创建集合对象
    18.         Collection<String> c = new ArrayList<String>();
    19.         //2.添加元素
    20.         c.add("java");
    21.         c.add("is");
    22.         c.add("my");
    23.         c.add("favourite");
    24.         //3.遍历集合,Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到。
    25.         Iterator<String> iterator = c.iterator();
    26.         /*
    27.         4.跟进一下iterator方法看一下这是一个什么东西
    28.         Iterator<E> iterator();这里找到的是Collection的接口里面来了,
    29.         但是我们最终要找的是iterator最终实现的方法,所以我们要跟进ArrayList集合.
    30.         按下Alt+7找到iterator方法:
    31.             public Iterator<E> iterator() {
    32.                 return new Itr();
    33.             }
    34.         这里返回值是该接口Iterator<E>所以返回值应该是一个该接口的的实现类对象,
    35.         所以Itr应该实现了Iterator<E>接口.所以我们要跟进Itr
    36.             private class Itr implements Iterator<E>{...}
    37.         这是一个类并实现了一个接口,Itr这个类是定义在ArrayList集合里面的,那么由此可见
    38.         Itr这个类是一个内部类,这就是内部类的应用场景,在这个内部类里面重写了next方法,hasNext方法,
    39.         forEachRemaining方法,等等.
    40.         我们通过Iterator<String> iterator = c.iterator();这个方法它返回的是Iterator具体的实现类,Itr的对象;
    41.         所以这是通过多态的形式来得到的Iterator的对象的.
    42.          */
    43. //        System.out.println(iterator.next());//得到了第一个元素 java
    44.         //5.接着怎么拿数据呢?不知道没关系,再写一次
    45. //        System.out.println(iterator.next());//这一次得到is
    46. //        System.out.println(iterator.next());//my
    47. //        System.out.println(iterator.next());//favourite
    48.         //6.当集合中所有元素都输出之后,我们不小心多复制了一个
    49. //        System.out.println(iterator.next());//报错:NoSuchElementException
    50.         //7.拿到异常类名到帮助文档中查看,表示被求的元素不存在
    51.  
    52.         System.out.println("--------------------");
    53.  
    54.         //8.Boolean hasNext（）：用于做判断的，如果迭代中有更多元素，则返回true；如果没有元素就返回false。
    55.         //使用if判断,获取元素之前判断集合中下一个有没有元素,如果有就获取,前提是需要把上面的iterator.next方法注视掉否则,这if不出来啊
    56.         /*
    57.         if(iterator.hasNext()){
    58.             System.out.println(iterator.next());
    59.         }
    60.         if(iterator.hasNext()){
    61.             System.out.println(iterator.next());
    62.         }
    63.         if(iterator.hasNext()){
    64.             System.out.println(iterator.next());
    65.         }
    66.         if(iterator.hasNext()){
    67.             System.out.println(iterator.next());
    68.         }
    69.         if(iterator.hasNext()){
    70.             System.out.println(iterator.next());
    71.         }//由于我们只有四个元素,这第五个if他经过判断为false就不会往if内部执行.
    72.          */
    73.  
    74.  
    75.         //10.使用循环改进,先注释掉上面的所有if语句
    76.         while(iterator.hasNext()){
    77. //            System.out.println(iterator.next());//尽量将这个获取到的元素值保存到变量中,然后再来输出变量
    78.             String next = iterator.next();
    79.             System.out.println(next);
    80.         }
    81.     }
    82. }

    集合的使用步骤

    创建了一个集合,往集合内添加了三个字符串元素,最后通过迭代器遍历集合。

    详解：

    首先创建了一个集合：

    接着添加第一个元素hello：

    hello就添加到这个集合中了，接着添加第二个元素world：

    在写来添加第三个元素：

    接着往下执行，我们要得到一个迭代器：

    被这个红色框框圈起来的就是迭代器中有的元素，那么在这里我们用一个箭头指向一开始的位置：

    接下来做判断：

    然后程序就问这个方法有元素吗？hasNext（）方法就返回一个true 说到有元素啊。然后程序就说有元素那我就进来看看，然后程序说it小老弟你去给我查一下下一个元素，it小老弟就找它的next方法，说n哥下一个元素是啥啊，next就说：是hello啊哥。it小老弟把next方法的原话就返回给了程序，程序说我不听，你给String s老弟说就行了，然后s老弟就把it告诉它的话记下来了(也就获取到了hello这个元素)。

    然后箭头就得指向下一个位置:

    程序再往下走,就在控制台输出hello:

    接着回到while()括号里的判断:

    然后又进来问有元素吗?有!有就进入内部,通过next方法获取到world这个元素。然后箭头指向下一个：

    然后在控制台输出world，并回到while（…）判断有没有元素：

    有元素！既然有就又进来了，通过next方法获取到java这个元素，箭头指向下一个元素，并且在控制台输出java这个元素：

    接着再回到判断，问还有元素吗？发现这次没有了他就进不去，他就往下执行，这个程序就结束了：

    叙述集合的使用（图解）：

    案例:Collection集合存储学生对象并遍历

    需求:创建一个学生对象的集合,存储三个学生对象,使用程序实现再控制台遍历该集合。

    思路:

    • 定义学生类
    • 创建Collection集合对象
    • 创建学生对象
    • 把学生添加到集合
    • 遍历集合(迭代器方式)
    • 输出

    代码演示:

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Iterator;
    4. /*
    5.     需求:创建一个学生对象的集合,存储三个学生对象,使用程序实现再控制台遍历该集合。
    6.         思路:
    7.         ①	定义学生类
    8.         ②	创建Collection集合对象
    9.         ③	创建学生对象
    10.         ④	把学生添加到集合
    11.         ⑤	遍历集合(迭代器方式)
    12.         ⑥	输出
    14.  */
    15.  
    16. public class Student {
    17.     public int sid;
    18.     public String name;
    19.  
    20.     public Student() {
    21.     }
    22.  
    23.     public Student(int sid, String name) {
    24.         this.sid = sid;
    25.         this.name = name;
    26.     }
    27.  
    28.     public int getSid() {
    29.         return sid;
    30.     }
    31.  
    32.     public void setSid(int sid) {
    33.         this.sid = sid;
    34.     }
    35.  
    36.     public String getName() {
    37.         return name;
    38.     }
    39.  
    40.     public void setName(String name) {
    41.         this.name = name;
    42.     }
    43. }
    44.  
    45. class Iterator_Student {
    46.     public static void main(String[] args) {
    47.         //1.创建集合
    48.         Collection<Student> collection = new ArrayList<Student>();
    49.  
    50.         //2.给第一个学生添加信息
    51.         Student student1 = new Student();
    52.         student1.setSid(1001);
    53.         student1.setName("双宝");
    54.  
    55.         //3.给第二个学生添加信息
    56.         Student student2 = new Student();
    57.         student2.setSid(1002);
    58.         student2.setName("智宝");
    59.  
    60.         //4.给第三个学生添加信息
    61.         Student student3 = new Student(1003,"昔年");
    62.  
    63.         //5.将学生添加到集合
    64.         collection.add(student1);
    65.         collection.add(student2);
    66.         collection.add(student3);
    67.  
    68.         //6.创建Iterator对象返回集合中的迭代器
    69.         Iterator<Student> iterator = collection.iterator();
    70.         System.out.println("学号"+ "\t\t" + "姓名");
    71.         //7.遍历集合
    72.         while(iterator.hasNext()){
    73.             //8.将得到的元素赋值到next变量中
    74.             Student next = iterator.next();
    75.             System.out.println(next.getSid() + "\t" + next.getName());
    76.         }
    77.  
    78.     }
    79. }

    --欢迎大家与我交流java知识

  • 相关阅读:
    python class init 用法
    深度学习 - 46.DIN 深度兴趣网络
    查询企业信息的四种方法
    【代码随想录】二刷-链表
    Java线程定时器
    实现人工智能的去中心化，权力下放是最佳途径！
    Python（二）
    [JAVAEE]—进程和多线程的认识
    核对不同文件夹所含内容的差异并提取缺失内容：Python代码
    Kotlin的关键字 lateinit 和 lazy
  • 原文地址：https://blog.csdn.net/weixin_67796933/article/details/125436652