DAY03_循环语句

news2024/12/23 11:09:37

1：for循环结构

来，继续啊，下面我们来学习循环结构语句，循环结构有三种语句，分别是：

  1. for循环

  2. while循环

  3. do…while循环

这三种循环可以做相同的事情，当然它们也有小的区别，至于它们的应用及区别，我们后面会详细讲解。这里我们来学习for循环

1.1 for循环结构

而在讲解for循环格式之前，我们先来看一下前面我们讲过的一个内容：这段代码的作用，是用来展示手机信息1000次。

 

还提到了这里的几个部分，分别是定义变量，条件判断，控制变量的变化，展示手机信息(可能被多次执行)

而for循环语句也是由这几部分组成。

格式：

 

格式说明：

  • 初始化语句：这里可以是一条或者多条语句，这些语句用来完成初始化操作(int i=1)

  • 条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体语句(i<=1000)

  • 循环体语句：这里可以是任意语句，这些语句可能被多次执行(展示手机信息)

  • 条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果(i+=1)

范例：

 执行流程：

 

知道了for循环的格式和执行流程后，下面我们到IDEA中去演示一下：

/*
    for循环结构
 */
public class ForDemo {
    public static void main(String[] args) {
        for(int i=1; i<=5; i+=1) {
            System.out.println("HelloWorld");
        }
    }
}

代码演示后，通过Debug查看了一下程序的执行流程，让我们更清晰for循环的执行流程。

讲解完毕后，大家赶快动手练习一下吧。

### 1.2 案例1(输出数据)

需求：在控制台输出1-5的数据

首先，我们来简单的分析一下：

**分析：**

① 反复进行输出的动作，使用循环结构

② 从1开始到5结束，设置初始化从1开始

③ 从1开始到5结束，设置判断条件为没有到5的时候继续执行，执行到超过5程序结束

④ 从1到5，每次增加1，设置条件控制每次+1

⑤ 将反复进行的事情写入循环结构内部，打印对应数据

分析完毕之后，我们到IDEA中去实现一下：

/*
    需求：在控制台输出1-5的数据
 */
public class ForTest01 {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
        System.out.println("--------------");

        for (int i = 1; i <= 5; i += 1) {
            System.out.println(i);
        }
        System.out.println("--------------");

        for (int i = 1; i <= 5; i += 2) {
            System.out.println(i);
        }
        System.out.println("--------------");

        //自增运算符：++
        //它跟在变量的后面表示变量的值+1
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        System.out.println("--------------");

        for (int i = 1; i <= 5; i++,i++) {
            System.out.println(i);
        }
        System.out.println("--------------");

        //我要获取数据5-1该怎么办呢？
        for (int i=5; i>=1; i-=1) {
            System.out.println(i);
        }
        System.out.println("--------------");

        for (int i=5; i>=1; i--) {
            System.out.println(i);
        }

    }
}

在讲解的过程中，我们还提出了自增运算符：++和自减运算符：--，并且演示了如何获取数据5-1。

讲解完毕后，大家赶快动手练习一下吧。

1.3 案例2(求和思想)

需求：求1-5之间的数据和，并把求和结果在控制台输出

首先，我们先到IDEA中去实现一下，然后再回来总结。

/*
    需求：求1-5之间的数据和，并把求和结果在控制台输出
 */
public class ForTest02 {
    public static void main(String[] args) {
        //定义一个求和变量，用于保存求和的结果
        int sum = 0;

        //我们通过for循环实现获取数据1-5
        for (int i=1; i<=5; i++) {
            //i,1,2,3,4,5
//            sum = sum + i;
            sum += i;
            /*
                第一次求和：sum = sum + i = 0 + 1 = 1
                第二次求和：sum = sum + i = 1 + 2 = 3
                第三次求和：sum = sum + i = 3 + 3 = 6
                第四次求和：sum = sum + i = 6 + 4 = 10
                第五次求和：sum = sum + i = 10 + 5 = 15
             */
        }

        //输出结果
        System.out.println("1-5的求和结果是：" + sum);
    }
}

最后，我们来总结一下求和思想的实现步骤：

实现步骤：

① 求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0

② 从1开始到5结束的数据，使用循环结构完成

③ 将反复进行的事情写入循环结构内部

此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中

④ 当循环执行完毕时，将最终数据打印出来

讲解完毕后，大家赶快动手练习一下吧。

1.4 案例3(求偶数和)

需求：求1-100之间的偶数和，并把求和结果在控制台输出

首先，我们来简单的分析一下：

分析：

① 对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同

② 对1-100的偶数求和，需要对求和操作添加限制条件

③ 限制条件是偶数才参与运算，因此条件应该是判断是否是偶数

④ 当循环执行完毕时，将最终数据打印出来

分析完毕之后，我们到IDEA中去实现一下：

/*
    需求：求1-100之间的偶数和，并把求和结果在控制台输出
 */
public class ForTest03 {
    public static void main(String[] args) {
        //1:求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
        int sum = 0;

        //2:对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
        for (int i=1; i<=100; i++) {
            //3:对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
            if(i % 2 == 0) {
                sum += i;
            }
        }

        //4:当循环执行完毕时，将最终数据打印出来
        System.out.println("1-100之间的偶数和是：" + sum);
    }
}

讲解完毕后，大家赶快动手练习一下吧。

1.5 案例4(水仙花数)

需求：在控制台输出所有的“水仙花数”

看到这个需求，我们首先要解决的问题就是，什么样的数据是“水仙花数”？它满足如下两个条件：

① 水仙花数是一个三位数

比如：111 222 333 370 371 520 999

② 水仙花数的个位、十位、百位的数字立方和等于原数

比如：

 

知道了什么是水仙花数后，我们再来回顾一下如何获取一个数据的个位，十位，百位：

假设一个三位数为x，则

  • 个位：x%10

  • 十位：x/10%10

  • 百位：x/100%10

了解了水仙花数相关的基础知识后，下面我们来说一下这个案例的实现步骤：

实现步骤：

① 获取三位数，通过循环实现

② 获取每一个三位数的个位，十位，百位

③ 判断该三位数是否是水仙花数

④ 输出水仙花数

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：在控制台输出所有的“水仙花数”
 */
public class ForTest04 {
    public static void main(String[] args) {
        //1:获取三位数，通过循环实现
//        for (int i=100; i<=999; i++) {
//
//        }

        for (int i = 100; i < 1000; i++) {
            //2:获取每一个三位数的个位，十位，百位
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;

            //3:判断该三位数是否是水仙花数
            if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
                //4:输出水仙花数
                System.out.println(i);
            }

        }

    }
}

讲解完毕后，大家赶快动手练习一下吧。

1.6 案例5(统计思想)

需求：统计“水仙花数”一共有多少个，并在控制台输出个数

首先，我们先到IDEA中去实现一下，然后再回来总结。

/*
    需求：统计“水仙花数”一共有多少个，并在控制台输出个数
 */
public class ForTest05 {
    public static void main(String[] args) {
        //定义一个统计变量，用于数据的统计，初始化值为0
        int count = 0;

        for (int i = 100; i < 1000; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;

            if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
//                System.out.println(i);
                //1,2,3,...
                count++;
            }
        }

        //输出水仙花的个数
        System.out.println("水仙花数一共有：" + count + "个");
    }
}

最后，我们来总结一下统计思想的实现步骤：

实现步骤：

① 定义统计变量count，初始化值为0

② 在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1

③ 输出统计变量的值

讲解完毕后，大家赶快动手练习一下吧。

1.7 案例6(回文数)

需求：输出所有五位数的回文数

看到这个需求，我们首先要解决的问题就是，什么样的数据是“回文数”？

那什么是“回文数”呢？一个数，无论是从左往右读,还是从右往左读，读起来都相同的数,叫做“回文数”

举例：

10101，12321：是回文数

12345：不是回文数

规律：

个位 = 万位

十位 = 千位

和百位无关

了解了回文数相关的基础知识后，我们来说一下这个案例的实现步骤：

实现步骤：

① 获取五位数，通过循环实现

② 获取每一个五位数的个位，十位，千位，万位

③ 判断该五位数是否是回文数

④ 输出回文数

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：输出所有五位数的回文数
 */
public class ForTest06 {
    public static void main(String[] args) {
        //1:获取五位数，通过循环实现
        for (int i = 10000; i < 100000; i++) {
            //2:获取每一个五位数的个位，十位，千位，万位
            int ge = i % 10;
            int shi = i / 10 % 10;
            int qian = i / 1000 % 10;
            int wan = i / 10000 % 10;

            //3:判断该五位数是否是回文数
            if ((ge == wan) && (shi == qian)) {
                //4:输出回文数
                System.out.println(i);
            }
        }

        //练习：统计五位数的回文数个数，并在控制台输出个数

    }
}

在案例的最后，我们留下了一个练习，大家记得完成哦。

讲解完毕后，大家赶快动手练习一下吧。

1.8 案例7(逢七过)

需求：朋友聚会的时候可能会玩一个游戏：逢七过。

规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。

为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。

这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。

首先，我们来简单的分析一下：

分析：

① 数据的范围1-100之间，用循环很容易实现

② 要满足的条件是：数字包含7(个位是7，或者十位是7)，或者是7的倍数

假如有一个数据：x
​
判断个位为7：x%10 == 7
​
判断十位为7：x/10%10 == 7
​
判断是7的倍数：x%7 == 0

分析完毕后，我们来说一下实现步骤：

实现步骤：

① 获取1-100之间的数据，通过循环实现

② 判断数字包含7或者是7的倍数

判断数据：要么个位是7，要么十位是7，要么能够被7整除

③ 在控制台输出满足条件的数据

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：朋友聚会的时候可能会玩一个游戏：逢七过。
 */
public class ForTest07 {
    public static void main(String[] args) {
        //1:获取1-100之间的数据，通过循环实现
        for (int i = 1; i <= 100; i++) {
            //2:判断数字包含7或者是7的倍数(判断数据：要么个位是7，要么十位是7，要么能够被7整除)
            if ((i % 10 == 7) || (i / 10 % 10 == 7) || (i % 7 == 0)) {
                //3:在控制台输出满足条件的数据
                System.out.println(i);
            }
        }

    }
}

讲解完毕后，大家赶快动手练习一下吧。

2：while循环结构

2.1 while循环结构

接下来，我们学习while循环结构语句

格式：

范例：

/*
    while循环结构
 */
public class WhileDemo {
    public static void main(String[] args) {
        int i = 1;
        while (i<=5) {
            System.out.println("HelloWorld");
            i++;
        }
    }
}

代码演示后，通过Debug查看了一下程序的执行流程，让我们更清晰while循环的执行流程。

最后，我们再来总结一下while循环的执行流程：

执行流程：

 

讲解完毕后，大家赶快动手练习一下吧。

2.2 案例1(求奇数和)

需求：求1-100之间的奇数和，并把求和结果在控制台输出

首先，我们来简单的分析一下：

分析：

① 对1-100的奇数求和，和前面讲解的偶数求和几乎是完全一样，仅仅是判断条件不同

② 判断条件是奇数才参与运算，因此条件应该是判断是否是奇数

③ 当循环执行完毕时，将最终数据打印出来

分析完毕之后，我们到IDEA中去实现一下：

/*
    需求：求1-100之间的奇数和，并把求和结果在控制台输出
 */
public class WhileTest01 {
    public static void main(String[] args) {
        //定义求和变量，初始化值为0
        int sum = 0;

        //获取1-100之间的数据
//        int i = 1;
//        while (i<=100) {
//            //判断数据是否是奇数
            if(i%2 != 0) {
                sum += i;
            }
//
//            if(i%2 == 1) {
//                sum += i;
//            }
//
//            i++;
//        }

        int i = 1;
        while (i <= 100) {
            sum += i;
            i += 2; //1,3,5,7...99,101
        }

        //输出结果
        System.out.println("1-100之间的奇数和是：" + sum);
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3 案例2(珠穆朗玛峰)

需求：世界最高峰珠穆朗玛峰(8848.86m)，我现在有一张足够大的纸张，厚度为：0.001m。请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

首先，我们来简单的分析一下：

分析：

① 因为要反复折叠，所以要使用循环，该选for循环还是while循环呢？

<font color='red'>**小技巧：循环次数明确，使用for循环；循环次数不明确，使用while循环**</font>
​
这里不知道折叠多少次，这种情况下更适合使用while循环

② 纸张每折叠一次，厚度加倍，因此要先定义纸张厚度，在循环中使厚度加倍

③ 什么时候就停止折叠了呢？直到纸张的厚度大于等于珠峰的高度，反言之，就要折叠

④ 要求的是统计折叠次数，所以会用到统计思想

分析完毕后，我们来说一下实现步骤：

实现步骤：

① 定义统计变量，初始化值为0

② 定义纸张厚度变量和珠峰高度变量

③ 用while循环实现反复折叠，判断条件是纸张厚度小于珠峰高度

④ 循环体中要做两件事情：一是纸张厚度加倍，二是统计变量+1

⑤ 当循环结束，输出统计变量的值

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：世界最高峰珠穆朗玛峰(8848.86m)，我现在有一张足够大的纸张，厚度为：0.001m。
         请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
 */
public class WhileTest02 {
    public static void main(String[] args) {
        //1:定义统计变量，初始化值为0
        int count = 0;

        //2:定义纸张厚度变量和珠峰高度变量
        double paper = 0.001;
        double zf = 8848.86;

        //3:用while循环实现反复折叠，判断条件是纸张厚度小于珠峰高度
        while (paper < zf) {
            //4:循环体中要做两件事情：一是纸张厚度加倍，二是统计变量+1
            paper *= 2;

            count++;
        }

        //5:当循环结束，输出统计变量的值
        System.out.println("要折叠" + count + "次");
    }
}

讲解完毕后，大家赶快动手练习一下吧。

3：do-while循环结构

3.1 do-while循环结构

接下来，我们学习do-while循环结构语句

格式：

 

 

/*
    do...while循环结构
 */
public class DoWhileDemo {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("HelloWorld");
            i++;
        } while (i<=5);
    }
}

代码演示后，通过Debug查看了一下程序的执行流程，让我们更清晰do-while循环的执行流程。

最后，我们再来总结一下do-while循环的执行流程：

执行流程：

 

讲解完毕后，大家赶快动手练习一下吧。

3.2 三种循环的区别

前面我们讲解了三种循环语句的格式和执行流程，下面我们来讲解这三种循环语句的区别。

而关于这三种循环语句的区别，我们先到IDEA中去讲解，然后再回来总结：

/*
    三种循环的区别
 */
public class LoopTest {
    public static void main(String[] args) {
//        //for循环
//        for (int i = 3; i < 3; i++) {
//            System.out.println("我爱Java");
//        }
//        System.out.println("--------");
//
//        //while循环
//        int j = 3;
//        while (j < 3) {
//            System.out.println("我爱Java");
//            j++;
//        }
//        System.out.println("--------");
//
//        //do...while循环
//        int k = 3;
//        do {
//            System.out.println("我爱Java");
//            k++;
//        } while (k < 3);

//        //for循环
//        for (int i = 1; i < 3; i++) {
//            System.out.println("我爱Java");
//        }
        System.out.println(i);
//        System.out.println("--------");
//
//        //while循环
//        int j = 1;
//        while (j < 3) {
//            System.out.println("我爱Java");
//            j++;
//        }
//        System.out.println(j);
//        System.out.println("--------");

        //死循环
//        for (;;) {
//            System.out.println("for...");
//        }

//        while (true) {
//            System.out.println("while...");
//        }

        do {
            System.out.println("do...while...");
        } while (true);

    }
}

讲解完毕后，回到资料，我们总结一下：

三种循环语句的区别：

for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）

do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）

for和while的区别：

条件控制语句所控制的自增变量，在for循环结束后，就不可以继续使用了

条件控制语句所控制的自增变量，在while循环结束后，还可以继续使用

死循环格式：

for(;;){}

while(true) {}

do{}while(true);

由于循环语句的区别，只是大家需要理解的知识点，故这里不需要练习，我们在后面的使用中，在慢慢体会即可。

4：continue和break

4.1 continue和break

来，继续啊，下面我们来学习跳转控制语句，为了讲解跳转控制语句，这里我们给出几个场景看一看：

场景一：周一到周五上班，周六日不上班

 

 

刚才的场景中，重点介绍了两个跳转关键字：

  • continue 用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行

  • break 用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环

了解了这两个跳转关键字之后，下面我们到IDEA中去体验一下：

/*
   continue:用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
   break:用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
*/
public class ControlDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i % 2 == 0) {
//                continue;
                break;
            }

            System.out.println(i);
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/455597.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【LeetCode】322. 零钱兑换

【LeetCode】322. 零钱兑换

322. 零钱兑换&#xff08;中等&#xff09; 思路 由于题目提到 「每种硬币的数量是无限的」&#xff0c;所以这道题本质上完全背包问题&#xff0c;我直接使用了空间压缩的写法。dp[j] 表示当前区间在 [0, i]的硬币可以表示成 j 的最小数量。注意&#xff0c;这里把 dp数组初始…
阅读更多...
windows安装sqli-labs靶场，两种方式

windows安装sqli-labs靶场，两种方式

1、安装phpstudy 官网打不开了&#xff0c;下载地址在这儿https://download.csdn.net/download/weixin_59679023/87711536 双击安装 点自定义安装&#xff0c;选择安装目录&#xff0c;注意目录不要有空格和中文 安装完成启动红框内的两个服务 2、安装sqli靶场 这个包支持ph…
阅读更多...
4.23学习周报

4.23学习周报

文章目录 前言文献阅读摘要简介方法结果结论 时间序列预测学习总结 前言 本周阅读文献《A novel hybrid model for water quality prediction based on synchrosqueezed wavelet transform technique and improved long short-term memory》&#xff0c;文献主要提出一种新型混…
阅读更多...
动力节点Springsecurity笔记06-13基于数据库的方法授权

动力节点Springsecurity笔记06-13基于数据库的方法授权

6 密码处理 6.1 为什么要加密&#xff1f; csdn 密码泄露事件 泄露事件经过&#xff1a;https://www.williamlong.info/archives/2933.html 泄露数据分析&#xff1a;https://blog.csdn.net/crazyhacking/article/details/10443849 6.2加密方案 密码加密一般使用散列函数&a…
阅读更多...
react-9 函数式写法rsc，配合HOOKS基础钩子函数

react-9 函数式写法rsc，配合HOOKS基础钩子函数

函数组件和类组件区别&#xff1a; 1.函数组件中没有this 2.函数组件无需继承 3.函数组件默认没有状态&#xff0c;想要使用组件状态必须通过 HOOK 函数引入 4.函数组件默认没有生命周期函数 5.函数组件的渲染&#xff0c;只需要一次函数调用即可 useState &#xff1a;用…
阅读更多...
【react全家桶学习】react中JSX语法规则

【react全家桶学习】react中JSX语法规则

目录 JSX的定义 XML的含义 JSX的语法规则 &#xff08;1&#xff09;定义类名&#xff0c;用className而不是class &#xff08;2&#xff09;如何使用内联样式设置样式 &#xff08;3&#xff09;虚拟dom必须只有一个根标签 &#xff08;4&#xff09;在react组件中使用变…
阅读更多...
谷歌将发布全新搜索引擎，你期待吗？

谷歌将发布全新搜索引擎，你期待吗？

Google一身自带AI属性的新搜索最首要的目标并非急于取代传统搜索引擎&#xff0c;或者说彻底打败ChatGPT&#xff0c;而是能够用全新的产品说服用户&#xff0c;变得与竞争对手同样“强大、能力出众以及顺应AI潮流”。 对于Google而言&#xff0c;搜索就是命脉。Google每年的收…
阅读更多...
Java基础——多线程创建

Java基础——多线程创建

&#xff08;1&#xff09;什么是线程&#xff1f; 线程(thread)是一个程序内部的一条执行路径。程序中只有一条执行路径&#xff0c;那么这个程序就是单线程的程序。 &#xff08;2&#xff09;多线程是什么&#xff1f; 多线程是指从软硬件上实现多执行流程的技术。 &…
阅读更多...
Python入门教程+项目实战-10.5节: 程序实战-冒泡排序算法

Python入门教程+项目实战-10.5节: 程序实战-冒泡排序算法

目录 10.5.1 排序算法简介 10.5.2 冒泡排序算法 10.5.3 系统学习python 10.5.1 排序算法简介 所谓排序&#xff0c;是指将数据集合中的元素按从小到大的顺序进行排列&#xff0c;或按从大到小的顺序进行排列。前者称为升序排序&#xff0c;后者称为降序排序。在数据结构与算…
阅读更多...
jenkins自动化部署配置

jenkins自动化部署配置

文章目录 1. jenkins 插件安装2. 配置2.1 全局工具配置2.2 全局配置2.2.1 gitee 配置 3. 创建任务添加gitee ssh jenkins 开机自启动 1. jenkins 插件安装 ant Build Failure AnalyzerBuild Monitor ViewBuild Timeout dockerEmail Extension Plugin giteegithubgradle javama…
阅读更多...
【11 EL表达式JSTL 学习笔记 】

【11 EL表达式JSTL 学习笔记 】

EL表达式 学习笔记 1. EL表达式介绍2. EL表达式的基本使用3. EL 表达式获取数据4. EL注意事项5. EL表达式运算符关系运算符逻辑运算符empty&三元运算符 6. EL表达式细节7. EL表达式11个隐式对象8. JSTL8.1 JSTL的基本使用 1. EL表达式介绍 简化了 java代码块和jsp表达式的…
阅读更多...
ChatGPT的开源平替，终于来了！

ChatGPT的开源平替，终于来了！

最近这段时间&#xff0c;一个号称全球最大ChatGPT开源平替项目Open Assistant引起了大家的注意。 这不最近还登上了GitHub的Trending热榜。 https://github.com/LAION-AI/Open-Assistant 根据官方的介绍&#xff0c;Open Assistant也是一个对话式的大型语言模型项目&#xff…
阅读更多...
RUST 每日一省：生命周期作用域

RUST 每日一省：生命周期作用域

生命周期 一个变量的生命周期就是它从创建到销毁的整个过程。 作用域 我们声明的每个变量都有作用域。作用域其实是变量和值存在的环境。作用域是由一对花括号表示的。例如&#xff0c;使用块表达式会创建一个作用域&#xff0c;即任何以花括号开头和结尾的表达式。此…
阅读更多...
RabbitMQ-整合mqtt

RabbitMQ-整合mqtt

用 springboot rabbitmq可以搭建物联网&#xff08;IOT&#xff09;平台&#xff0c;rabbitmq 不是消息队列吗&#xff0c;原来rabbitmq有两种协议&#xff0c;消息队列是用的AMQP协议&#xff0c;而用在智能硬件中的是MQTT协议。 一、rabbitmq是什么&#xff1f; RabbitMQ就…
阅读更多...
一张图了解GPU、CUDA、CUDA toolkit和pytorch的关系

一张图了解GPU、CUDA、CUDA toolkit和pytorch的关系

文章目录 GPU、Cuda Driver和 Cuda Toolkit的图解关系省流&#xff0c;简略版本要实现多版本的cuda怎么办 复杂版&#xff08;你要是觉得简略版说的太简单&#xff0c;这里给你找文档证明&#xff09;一、Nvidia Driver和CUDA Toolkit的关系安装GPU显卡驱动Nvidia Driver 二、C…
阅读更多...
uniapp请求图片时候发现提示GET http://localhost:xxxx/undefined 401，undefined:1解决办法【伸手党福利】

uniapp请求图片时候发现提示GET http://localhost:xxxx/undefined 401，undefined:1解决办法【伸手党福利】

同理解决问题&#xff1a;所有请求发起完成之后执行业务逻辑 目录 现象原因解决办法方法1&#xff1a;提前给变量一个非空默认值方法2&#xff1a;使用前端图片代替后端方法3&#xff1a;使用异步加载判断&#xff1a;注意&#xff1a;这种直接在页面判断内容是否为空或者undef…
阅读更多...
Java JVM基础入门（一）：jvm的组成、串池、常量池、常用程序调优参数

Java JVM基础入门（一）：jvm的组成、串池、常量池、常用程序调优参数

JVM JVM是java的虚拟机&#xff0c;java的运行环境&#xff08;java二进制字节码的运行环境&#xff09; 好处&#xff1a; 一次编写&#xff0c;到处运行自动内存管理&#xff0c;垃圾回收功能 JDK、JRE、JVM的关系图 常见的JVM&#xff1a; oracle的Hotspot是我们通常使…
阅读更多...
矿山电子封条智能监管算法 yolov8

矿山电子封条智能监管算法 yolov8

矿山电子封条智能监管系统通过YOLOv8python网络模型技术&#xff0c;矿山电子封条智能监管算法模型在对矿井人数变化、生产作业状态、出入井人员等情况实时监测分析&#xff0c;发现煤矿人员作业及状态异常动态及时告警&#xff0c;自动将报警信息推送给后台。YOLOv8 算法的核心…
阅读更多...
k8s部署ingress-nginx步骤

k8s部署ingress-nginx步骤

目录 一、ingress简介 二、部署ingress controller、ingress-service 三、创建对外服务deployment和service 四、创建HTTP代理yaml 五、测试 六、公网域名测试 七、参考博客 一、ingress简介 service的作用体现在两个方面&#xff0c;对集群内部&#xff0c;它不断跟踪…
阅读更多...
[计算机图形学]光线追踪的基本原理(前瞻预习/复习回顾)

[计算机图形学]光线追踪的基本原理(前瞻预习/复习回顾)

一、光栅化的弊端 我们为什么要用光线追踪呢&#xff0c;在之前的篇章中&#xff0c;我们提到了&#xff0c;光栅化的方式很难表示一些全局的效果&#xff0c;如(1)软阴影&#xff0c;(2)Glossy的反射(类似镜子但又不像镜子那么光滑的材质&#xff0c;如打磨的铜镜和一些金属)&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023