Java 集合（一）——Collection集合接口、Iterator 迭代器和泛型

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量259 收藏
点赞数
分类专栏： 重学 Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38478780/article/details/109296674
版权

一、前言

因为明年三四月份想换工作，也为了对 Java 语言有更深的理解，所以想重新学一遍 Java，把以前没有注意到的细节再巩固一下，因为现在时间还是有的，所以我决定重新的过一遍 Java 的知识点（至少比粗暴的刷 Java 面试题好）。我这里准备的学习资料主要有十大章，我们来看一下每章的目录名称（用的 Java 版本是目前用的最多的版本 Java 8）：

  1. Java 基础语法；
  2. 面向对象和封装；
  3. 常用 API 第一部分；
  4. 继承与多态；
  5. 常用 API 第二部分；
  6. 集合；
  7. 异常与多线程；
  8. File 类与 IO 流；
  9. 网络编程；
  10. JDK 8 新特性。

但是我不打算从第一章开始看，我决定从第 6 章 集合 开始，等 6 到 10 章学完，再学 1 到 5 章，我们来看一下集合这一章的目录：

  1. Collection 集合；
  2. 泛型；
  3. 综合案例 1；
  4. List 集合；
  5. Set 集合；
  6. Collections 工具类；
  7. Map 集合；
  8. 综合案例 2；

集合这一章的内容确实有点多，所以我们分三部分来讲解，让我们开始。

二、Collection 集合

2.1、集合概述

集合是 Java 中提供的一种容器，可以用来存储多个数据。集合和数组都是容器，它们的区别如下：

  • 数组的长度是固定的，集合的长度是可变的。
  • 数组中存储的是统一类型的元素，可以存储基本数据类型，也可以存储对象。集合存储的都是对象，不可以存储基本数据类型，而且对象的类型可以不一致。

2.2、集合框架

集合的框架如下所示，需要注意的点有：

  1. TreeSet 与 HashSet 是无序的，即存和取的元素的顺序有可能不一致，但是 LinkedHashSet 是有序的。
  2. 顶层不是接口就是抽象类，无法创建对象使用，需要底层的子类创建对象使用。

集合框架

2.3、Collection 集合常用功能

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

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

Collection 常用功能代码演示如下所示，输出结果大家可以自己复制到 Intellij IDEA 中查看。

public class CollectionDemo01 {

    public static void main(String[] args) {
        // 创建集合对象
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll); // 重写了toSting() 方法

        /**
         * public boolean add(E e)：把给定的对象添加到当前集合中。
         * 返回值是一个 boolean 值，一般都返回 true，可以不用接收
         */
        boolean b1 = coll.add("张三");
        System.out.println("b1:" + b1); // b1:true
        System.out.println(coll); // [张三]
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll); // [张三, 李四, 王五, 赵六, 田七]
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public boolean remove(E e)：把给定的对象在当前集合中删除。
         * 返回值是一个 boolean 值，集合中存在元素，删除元素，返回 true，集合中不存在的话，删除失败，返回 false
         */
        boolean b2 = coll.remove("赵六");
        System.out.println("b2:" + b2); // b2:true
        boolean b3 = coll.remove("赵四");
        System.out.println("b3:" + b3); // b3:false
        System.out.println(coll); // [张三, 李四, 王五, 田七]
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public boolean contains(E e)：判断当前集合中是否包含给定的对象。
         * 包含返回 true，不包含返回 false
         */
        boolean b4 = coll.contains("李四");
        System.out.println("b4:" + b4); // b4:true
        boolean b5 = coll.contains("赵四");
        System.out.println("b5:" + b5); // b5:false
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public boolean isEmpty()：判断当前集合是否为空。
         */
        boolean b6 = coll.isEmpty();
        System.out.println("b6:" + b6); // b6:false
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public int size()：返回集合中元素个数。
         */
        int size = coll.size();
        System.out.println("size:" + size);
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public Object[] toArray()：把集合转化成数组。
         */
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        /**
         * public void clear()：清空集合中的所有元素。
         * 但是不删除集合，集合还存在
         */
        coll.clear();
        System.out.println(coll); // []
        System.out.println(coll.isEmpty()); // true
    }
}

三、Iterator 迭代器

3.1、Iterator 接口概述

在程序开发中，经常需要遍历集合中的元素，针对这种需求，JDK 专门提供了一个接口 Iterator。Iterator 接口也是 Java 集合中的一员，主要用于迭代访问（即遍历）Collection 中的元素，因为 Iterator 对象也被称为迭代器，是一种通用的取出集合中元素的方式。

3.2、Iterator 接口常用方法

常用方法有一下两个：

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

3.3、迭代器的使用步骤

由于 Iterator 迭代器是一个接口，我们无法直接使用，需要使用 Iterator 接口的实现类对象，通过 Collection 接口中的 iterator() 方法返回迭代器的实现类对象。使用步骤如下：

  1. 使用集合中的 iterator() 方法获得迭代器的实现类对象，使用 Iterator 接口接收；
  2. 使用 Iterator 中的方法 hasNext() 判断还有没有下一个元素；
  3. 使用 Iterator 中的方法 next() 取出集合中的元素。

注意：Iterator 接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型。

3.4、增强 for 循环

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

格式：for(集合/数组的数据类型 变量名 : 集合名/数组名)
for(int i : arr)

Iterator 和增强 for 循环遍历集合代码演示如下所示，输出结果大家可以自己复制到 Intellij IDEA 中查看。

public class IteratorDemo02 {

    public static void main(String[] args) {
        // 创建集合对象
        Collection<String> coll = new ArrayList<>();
        coll.add("乔丹");
        coll.add("詹姆斯");
        coll.add("奥尼尔");
        coll.add("艾佛森");
        coll.add("科比");

        /**
         * 1、使用集合中的 iterator() 方法获得迭代器的实现类对象，使用 Iterator 接口接收；
         *      注意：Iterator<E> 接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
         * 2、使用 Iterator 中的方法 hasNext() 判断还有没有下一个元素
         * 3、使用 Iterator 中的方法 next() 取出集合中的元素。
         */
        Iterator<String> it = coll.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        // 利用 for 循环改写 while 循环
        for ( Iterator<String> it1 = coll.iterator();it1.hasNext();) {
            System.out.println(it1.next());
        }
        System.out.println("---------------------分割线-----------------------");
        System.out.println();

        // 可以用增强 for 循环遍历(不能用普通 for 循环遍历)
        for (String s : coll) {
            System.out.println(s);
        }
    }
}

3.5、迭代器的工作原理

  1. Iterator it = coll.iterator()：获取迭代器的实现类对象，并把引用（可以理解成指针）指向集合中的 -1 索引;
  2. it.hasNext():判断集合中还有没有下一个元素；
  3. it.next()：取出下一个元素，并把指针（这里用指针来说明好理解一点）向后移动一位。

四、泛型

4.1、泛型概述

泛型是一种未知的数据类型，当我们不知道用什么数据类型的时候，可以使用泛型，泛型也可以看成是一个变量，用来接收数据类型。ArrayList 集合在定义的时候（源码中就是利用泛型的），不知道集合中都会存储什么类型的数据，所以使用泛型。

4.2、使用泛型的优点与弊端

集合不使用泛型，默认的类型就是 Object 类型，可以存储任意类型的数据，但是同时也使得集合变得不安全，容易引发异常，所有使用泛型的优点有：

  1. 避免了类型转化的麻烦；
  2. 把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写代码的时候就会报错）。

使用泛型创建集合和不使用泛型创建集合代码演示如下所示，输出结果大家可以自己复制到 Intellij IDEA 中查看。

public class GenericDemo01 {

    public static void main(String[] args) {
    	// 不使用泛型
        //show01();
        // 使用泛型
        show02();
    }

    /**
     * 创建集合对象，不使用泛型
     * 好处：
     *      集合不使用泛型，默认的类型就是 Object 类型，可以存储任意类型的数据
     * 弊端：
     *      不安全，容易引发异常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        // 使用迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj);


            String s = (String) obj;
            // 运行后，会有异常
            System.out.println(s.length()); // java.lang.ClassCastException: Integer cannot be cast to String
        }
    }

    /**
     * 创建集合对象，使用泛型
     * 好处：
     *      1、避免了类型转化的麻烦
     *      2、把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写代码的时候就会报错）
     * 弊端：
     *      泛型是什么类型，只能存储什么类型的数据
     */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");

        // 使用迭代器遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
            System.out.println(s.length());
        }
    }
}

4.3、定义含有泛型的类

含有泛型的类定义如下代码所示：

public class GenericDemo02<E> {

    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }

    public static void main(String[] args) {
        GenericDemo02<String> g1 = new GenericDemo02();
        g1.setName("testGeneric");
        System.out.println(g1.getName());

        GenericDemo02<Integer> g2 = new GenericDemo02();
        g2.setName(123);
        System.out.println(g2.getName());
    }
}

4.4、定义含有泛型的方法

定义含有泛型的方法，泛型需要定义在方法的修饰符和返回值类型之间，定义格式如下所示：

修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)) 

public <E> void method01(E e) {
    System.out.println(e);
}

// 静态方法
public static <E> void method2(E e) {
    System.out.println(e);
}

4.5、定义并使用含有泛型的接口

含有泛型的接口如下所示：

public interface GenericInterface04<I> {
    public abstract void method(I i);
}

含有泛型的接口的使用方式有两种：

  1. 在定义接口的实现类的时候指定接口的泛型。
    public class GenericInterface04Impl1 implements GenericInterface04<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}
  2. 接口使用什么泛型，实现类就使用什么泛型，类跟着接口走。就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型；
    public class GenericInterface04Impl2<I> implements GenericInterface04<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

4.6、泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符 <?> 表示，但是使用通配符只能作为方法的参数传递，不能定义对象。泛型通配符的使用如下所示：

public class GenericDemo05 {

    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");

        printArray(list1);
        printArray(list2);
    }

    public static void printArray(ArrayList<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

4.7、受限泛型

泛型的上限限定：
格式：类型名称 <? extends E> 对象名称
意义：只能接受 E 类型及其子类。

泛型的下限限定：
格式：类型名称 <? super E> 对象名称
意义：只能接受 E 类型及其父类。

受限泛型代码演示如下所示，大家可以自己复制到 Intellij IDEA 中查看。

public class GenericDemo06 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();

        /**
         * Integer extends Number extends Object
         * String extends Object
         */

        getElement1(list1);
        getElement1(list2); // 报错
        getElement1(list3);
        getElement1(list4); // 报错

        getElement2(list1); // 报错
        getElement2(list2); // 报错
        getElement2(list3);
        getElement2(list4);
    }

    // 泛型的上限：此时的泛型？，必须是 Number 类型或者是 Number 类型的子类
    public static void getElement1(Collection<? extends Number> coll) {
    }

    // 泛型的下限：此时的泛型？，必须是 Number 类型或者是 Number 类型的父类
    public static void getElement2(Collection<? super Number> coll) {
    }
}

五、集合综合案例——斗地主

综合案例步骤：

  1. 准备牌：
    54 张牌存储到一个集合中；
    特殊牌：大王，小王；
    其他 52 张牌：
        定义一个数组，存储 4 种花色 ♥ ♦ \color{red}{♥ ♦} ♥♦ ♠ ♣ \color{black}{♠ ♣} ♠♣；
        定义一个数组，存储 13 个序号[2、A、K…3]；
    循环嵌套遍历上面两个数组，组装 52 张牌[ ♥ 2 \color{red}{♥2} ♥2， ♦ A \color{red}{♦A} ♦A， ♥ K \color{black}{♥K} ♥K， ♣ Q \color{black}{♣Q} ♣Q，…]；
  2. 洗牌
    利用集合工具类 Collections.shuffle() 来随机打乱集合中元素的位置；
  3. 发牌
    发牌要求如下：
        一人 17 张牌，剩余 3 张作为底牌，一人一张轮流发牌(集合的索引 % 3)；
        定义四个集合，存储 3 个玩家的牌和底牌；
  4. 看牌
    直接打印集合，遍历存储玩家和底牌的集合；

具体实现代码如下所示：

public class DouDiZhu {

    public static void main(String[] args) {
        // 1、准备牌
        // 定义一个存储 54 张牌的集合；
        ArrayList<String> poker = new ArrayList<>();
        // 定义两个集合，一个存储牌的花色，一个存储牌的序号
        String[] colors = {"♠", "♥", "♣", "♦"};
        String[] numbers = {"2", "A", "k", "q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
        // 先把大王和小王存储到poker集合中
        poker.add("大王");
        poker.add("小王");
        // 循环嵌套两个数组，组装52张牌
        for (String number : numbers) {
            for (String color : colors) {
                // 把组装好的牌存到poker集合中
                poker.add(color + number);
            }
        }

        // 2、洗牌
        // 利用集合工具类 Collections.shuffle() 来随机打乱集合中元素的位置；
        Collections.shuffle(poker);

        // 3、发牌
        // 定义四个集合，存储 3 个玩家的牌和底牌；
        ArrayList<String> player01 = new ArrayList<>();
        ArrayList<String> player02 = new ArrayList<>();
        ArrayList<String> player03 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();

        // 4、遍历poker集合，获取每一种牌
        // 使用poker集合的索引 % 3 给三个玩家轮流发牌，最后剩余三张牌给底牌
        for (int i = 0; i < poker.size(); i++) {
            String p = poker.get(i);
            if (i >= 51) {
                dipai.add(p);
            } else if (i % 3 == 0) {
                player01.add(p);
            } else if (i % 3 == 1) {
                player02.add(p);
            } else {
                player03.add(p);
            }
        }
		
		// 方便起见直接打印
        System.out.println("玩家1的牌：" + player01);
        System.out.println("玩家2的牌：" + player02);
        System.out.println("玩家3的牌：" + player03);
        System.out.println("底牌：" + dipai);
    }
}

打印结果如下所示：

结果1
结果2

六、小结

集合第一部分中我们讲了 Collection集合接口、Iterator 迭代器、泛型和斗地主综合案例，下一节我们讲数据结构、List 集合和 Set 集合。

七、源码

文章中用到的所有源码已上传至 github，有需要的可以去下载。

萌果爱吃芒果
关注
专栏目录
24-集合--集合概述+Collection+Iterator+集合类的关系图
ruyu00的博客
08-22 582
一、概述 1、集合是专门用于存储对象的，存的是对象的地址值（存储任意数量的具有共同属性的对象 -- 意义与作用相同） 2、集合的特点： （1）用于存储对象的容器（存的是对象的地址值） （2）集合的长度是可变的（数组长度固定） （3）集合中不可以存储基本数据类型 -- 基本数据类型通过自动拆箱/装箱可以转换成引用数据类型（数组可以存储基本数据类型） 3、集合因为内部的数据结构（对象的存储...
Collection集合,Iterator迭代器,泛型,List集合,ListIterator迭代器,集合遍历
liu_yan_hui的博客
10-24 376
文章目录Collection集合Iterator迭代器的体系结构迭代器的注意事项:泛型什么是泛型泛型可以应用在哪些地方泛型的高级通配符List集合ListIterator迭代器List集合的遍历方式: Collection集合 public interface Collection<E> extends Iterable<E> 是一个接口,需要用子实现类去创建对象 比如 Collection c=new ArrayList(); boolean add(E e) 向集合末尾添加元素
迭代器，泛型集合
刘大洋的博客
03-01 149
迭代器，泛型集合 迭代器Iterator Set keys=dogMap.keySet();//取出所有key的集合 Iterator it=keys.iterator()//获取Iterator对象 使用Iterator接口遍历ArrayList集合步骤 1.导入Iterator接口 2.使用集合的iterator()方法返回Iterator 3.while()循环遍历 4.使用Iterator的hasNest()方法判断 是否存在下一个可访问的元素 5.使用Iterator的next()方法返回要
Java学习【阶段一[06]】集合（01集合类）
qq_41915980的博客
11-11 171
一、集合概述 ArrayList<E>是我们前面学过的一个集合 集合：集合是java中提供的一个容器，可以用来存储多个数据 集合与数组的区别 数组长度固定，集合长度可变 数组中存储的是同一类型的元素，可以存储基本数据类型值也可以存储对象。集合存储的都是对象不能存储基本数据类型，而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储 int [ ]arr=new...
集合框架二(HasMap接口,iterator,泛型集合)
匿名攻城狮
06-08 546
Map接口常用方法: Map c = new HashMap();//声明 c.put(Object key,Object val)//以"键-值"方式存储 c.get(Object key);//通过key获得val c.size();//返回元素个数 c.containsKey(Object key);//判断键是否存在 c.containsValue(Object val);//判断值是否...
java——Collection集合、Iterator迭代器、泛型
m0_52196529的博客
10-19 225
java——Collection集合、Iterator迭代器、泛型
Java中Collection集合、Iterator迭代器、泛型
ONESTARの博客
06-29 3582
目录 一、集合继承关系 二、Collection接口 1、Collection 集合创建格式 2、Collection 接口的基本方法 三、Iterator 迭代器 1、Iterator 迭代器的实现 2、Iterator 迭代器中常用的方法 四、集合迭代中的转型 五、泛型 1、泛型的定义 2、泛型类 3、泛型接口 4、泛型通配符 5、泛型限定 集合是Java中提供...
Collection集合&Iterator迭代器&泛型
m0_63158445的博客
02-22 485
** Collection、Iterator、泛型、数据结构 能够说出集合与数组的区别 数组: 1.是引用数据类型的一种,可以存储多个元素 2.数组的长度是固定的 int[] arr1 = new int[10]; int[] arr2 = {1,2,3}; 3.数组即可以存储基本类型的数据,又可以存储引用数据类型的数据 int[],double[],String[],Student[] 集合: 1.是引用数据类型的一种,可以存储多个元素 2.集合的长度是可以变化的(可以往集
Java Iterator接口遍历单列集合迭代器原理详解
08-25
Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，为了让初学者能更好地理解迭代器的工作原理，接下来通过一个图例来演示Iterator对象迭代元素的过程： 在调用Iterator的next方法时，迭代器...
Day17 Java 集合和泛型.pdf
08-09
遍历时通常会使用Iterator迭代器来安全地遍历集合中的元素。 接下来详细了解一下Map的几种常见实现类： 1. HashMap是最常用的Map实现类，它允许键和值为null，且不保证映射的顺序。它的put方法是线程不安全的，...
java集合之——Collection接口；一文摸清楚collection和它子接口
m0_58702068的博客
09-28 594
文章目录**Collection与其子接口****前言****Collection方法****List接口****List接口中的方法****ArrayList类****前序：****实现****Vector类****前序****实现****构造方法****Vector 类和 ArrayList 类的区别****LinkedList类****前序****实现****LinkedList可以用来模拟栈的数据结构****LinkedList可以用来模拟队列(单端和双端)的数据结构****Set接口****前言*
Java(七)——集合框架---Collection (集合) 、Iterator接口、List接口
MrDaKai的博客
10-26 223
- 集合框架介绍 - 集合框架的继承体系 - 集合的顶层接口Collection - 迭代器Iterator接口：遍历集合对象、Iterator接口迭代器的实现原理、Iterator接口的抽象方法 - 并发异常 - 集合存储自定义对象并迭代 - 集合的接口List - List接口自己的方法 (带有索引) - List集合的特有迭代器 - List接口的实现类的数据结构
Java---集合框架（3）--- 泛型/Iterator
cat_watch的博客
09-14 131
泛型优点 泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。 泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。 Iterator 一个Collection中使用迭代器方法来获取迭代器实例 Iterator<String&..
13 Collection、Iterator、泛型
朱古力的博客
05-14 590
文章目录Collection、Iterator、泛型一、Collection集合1. Collection集合概述2. 集合框架介绍3. Collection集合常用方法二、Iterator迭代器1. Iterator接口介绍2. 迭代器的代码实现3. 迭代器的实现原理4. 增强`for`循环三、泛型1. 泛型的概念2. 使用泛型的好处3. 定义和使用含有泛型的类4. 定义和使用含有泛型的方法5. 定义和使用含有泛型的接口6. 泛型通配符 Collection、Iterator、泛型 一、Collectio
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 287
Arthas sysenv（查看JVM的环境变量）
Java企业面试题3
m0_74972727的博客
09-15 921
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 211
faiss版本 faiss-v1.7.4。
Java集合框架详解：Collection、迭代器与泛型
"这篇文档主要介绍了Java中的Collection集合、常用方法、迭代器的使用以及泛型和数据结构的基础知识。作者在整理过程中突破了泛型使用的难点，并指出数据结构在Java中的理解重在原理。" Java集合框架是编程中非常...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值