9.Java数组知识大全

news2024/11/27 8:40:57

文章目录

  • 前言
  • 一、数组介绍
  • 二、数组的定义域静态初始化
  • 三、数组元素访问
    • 数组地址中的小拓展:
  • 四、数组遍历
    • 1.获取数组里面的元素
    • 2.把数据存储到数组中
    • 3.遍历数组的最快方式
    • 4.遍历数组并求和
    • 5.统计个数
    • 6.变化数据
  • 五、数组动态初始化
    • 1.数组默认初始化值的规律
    • 2.数组动态初始化和静态初始化的区别
  • 六、数组内存图
    • 1.Java内存分配
    • 2.数组的内存图
    • 3.总结:
    • 4.两个数组指向同一个空间的内存
      • 总结:
  • 七、数组常见问题
    • 小结:
  • 八、数组常见操作
    • 1.求最值
    • 2.遍历数组求和
    • 3.交换数组中的数据
      • 方法一:
      • 方法二:
    • 4.打乱数组中的数据
  • 总结

前言

一、数组介绍

在这里插入图片描述
在这里插入图片描述

二、数组的定义域静态初始化

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class test8 {
    public static void main(String[] args) {
        //格式
        //静态初始化
        //完整格式
        //数据类型 [] 数组名=new 数据类型[]{元素1,元素2...};
        //简化格式
        //数据类型 [] 数组名={元素1,元素2...};

        //需求1:定义数组存储5个学生的年龄
        int[] arr1=new int[]{11,12,13,14};
        int[] arr2={11,12,13,14};

        //需求2:定义数组存储3个学生的姓名
        String[] arr3=new String[]{"zhangsan","lisi","wangwu"};
        String[] arr4={"zhangsan","lisi","wangwu"};

        //需求3:定义数组存储4个学生的身高
        double[] arr5=new double[]{1.93,1.65,1.68,1.71};
        double[] arr6={1.93,1.65,1.68,1.71};

    }
}

三、数组元素访问

在这里插入图片描述

数组地址中的小拓展:

解释一下地址值的格式含义
[: 表示当前是一个数组
D: 表示当前数组里面的元素都是double类型的
I: 表示当前数组里面的元素都是int类型的
@: 表示一个间隔符号(固定格式)
776ec8df才是数组真正的地址值(十六进制)
平时我们习惯吧这个整体叫做数组的地址值

public class test8 {
    public static void main(String[] args) {
        //格式
        //静态初始化
        //完整格式
        //数据类型 [] 数组名=new 数据类型[]{元素1,元素2...};
        //简化格式
        //数据类型 [] 数组名={元素1,元素2...};

        //需求1:定义数组存储5个学生的年龄
        int[] arr1=new int[]{11,12,13,14};
        System.out.println(arr1);
//        int[] arr2={11,12,13,14};
//
//        //需求2:定义数组存储3个学生的姓名
//        String[] arr3=new String[]{"zhangsan","lisi","wangwu"};
//        String[] arr4={"zhangsan","lisi","wangwu"};
//
//        //需求3:定义数组存储4个学生的身高
//        double[] arr5=new double[]{1.93,1.65,1.68,1.71};
//        double[] arr6={1.93,1.65,1.68,1.71};

        /*扩展:
        解释一下地址值的格式含义
        [: 表示当前是一个数组
        D: 表示当前数组里面的元素都是double类型的
        I: 表示当前数组里面的元素都是int类型的
        @: 表示一个间隔符号(固定格式)
        776ec8df才是数组真正的地址值(十六进制)
        平时我们习惯吧这个整体叫做数组的地址值
         */

    }
}

在这里插入图片描述

四、数组遍历

1.获取数组里面的元素

2.把数据存储到数组中

在这里插入图片描述

public class test9 {
    public static void main(String[] args) {
        /*利用索引对数组中的元素进行访问
        1.获取数组里面的元素
        格式: 数组名[索引]


         */
        int[] arr={1,2,3,4};
        /*获取数组里面的第一个元素
        其实就是0所以上对应的元素
        int number=arr[0];
        System.out.println(number);//1
        获取数组中1索引上对应的数据,并直接打印出来
        System.out.println(arr[1]);//2
         */

        //2.把数据存储到数组中
        //格式: 数组名[索引]=具体数据/变量;
        //细节:一旦覆盖之后,原来的数据就不存在了
        arr[0]=100;
        System.out.println(arr[0]);

    }
}

在这里插入图片描述
在这里插入图片描述

3.遍历数组的最快方式

public class test10 {
    public static void main(String[] args) {
        //1.定义数组
        int arr[]={1,2,3,4,5};
        //2.获取数组里面所有的元素
        //格式:  数组名[索引]
        /*
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
         */

        //利用循环改进代码
        //开始条件:0
        //结束条件:数组的长度-1(最大索引)
        //但是当原始数组里面的元素过多,数量不便于数出时,5的位置处该写什么呢?
        /*for (int i = 0; i < 5; i++) {
            //i:0,1,2,3,4
            System.out.println(arr[i]);
        }*/

        //在Java当中,关于数组的一个长度属性,length
        //调用方式:  数组名.length
        for (int i = 0; i < arr.length; i++) {
            //i:0,1,2,3,4
            System.out.println(arr[i]);
        }
        
        //扩展:
        //自动的快速生成数组的遍历方式
        //idea提供的
        //数组名.fori
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        

    }

}

4.遍历数组并求和

在这里插入图片描述

public class test11 {
    public static void main(String[] args) {
        /*
        定义一个数组,存储1,2,3,4,5
        遍历数组得到每一个元素,求数组里面所有的数据和
         */
        //分析
        //1.定义一个数组并添加数据
        int[] arr={1,2,3,4,5};
        //求和变量
        int sum=0;
        //2.遍历数组得到一个数据,累加求和
        for (int i = 0; i < arr.length; i++) {
            //i 依次表示数组里面的每一个索引
            //arr[i] 依次表示数组里面的每一个元素
            sum=sum+arr[i];

        }
        //当循环结束之后,sum的值就是累加之后的结果
        System.out.println(sum);
    }
}

在这里插入图片描述

5.统计个数

在这里插入图片描述

import javax.imageio.metadata.IIOMetadataFormatImpl;

public class test12 {
    /*
    定义一个数组存储1,2,3,4,5,6,7,8,9,10
    遍历数组的到每一个元素,通技术组里面一共有多少能被3整除的数字
     */
    public static void main(String[] args) {
        //分析:
        //1.定义一个数组,存储1,2,3,4,5,6,7,8,9,10
        int[] arr={1,2,3,4,5,6,7,8,9,10};

        //定义一个变量,用来统计次数
        int count=0;
        //2.遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //i 表示数组里面的每一个索引
            //arr[i] 表示数组里面的每一个元素
            //3.判断当前元素是否为3的倍数,如果是的话,统计变量自增一次
            if (arr[i] % 3 == 0) {
                count++;
            }

        }
        System.out.println("数组中能被3整除的数字有"+count+"个");
    }

}

在这里插入图片描述

6.变化数据

在这里插入图片描述

public class test13 {
    public static void main(String[] args) {
        /*
        定义一个数组存储1,2,3,4,5,6,7,8,9,10
        遍历得到每一个元素
        要求:
        如果是奇数,将当前数字扩大两倍
        如果是偶数,将当前数字变为原来的1/2
         */

        //分析
        //1.定义一个数组存储数据
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        //2.遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]%2==0){
                arr[i]=arr[i]/2;
            }else {
                arr[i]=arr[i]*2;
            }
        }

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

在这里插入图片描述

五、数组动态初始化

在这里插入图片描述

1.数组默认初始化值的规律

    整数类型:默认初始化值0
    小数类型:默认初始化值0.0
    字符类型:默认初始化值'\u0000' 空格
    布尔类型:默认初始化值 false
    引用数据类型:默认初始化值 null

public class test14 {
    public static void main(String[] args) {
        /*
        定义一个数组,用来存班级中50个学生的姓名
        姓名未知,等学生报名之后,再进行添加
         */
        //格式:
        //数据类型[] 数组名=new 数组类型[数组的长度]
        //在创建的时候,由我们自己指定数组的长度,由虚拟机给出默认的初始化值
        String[] arr=new String[50];
        //添加学生
        arr[0]="zhangsan";
        arr[1]="lisi";
        //获取
        System.out.println(arr[0]);//zhangsan
        System.out.println(arr[1]);//lisi
        System.out.println(arr[2]);//打印出来的是默认初始化值null

        //数组默认初始化值的规律
        //整数类型:默认初始化值0
        //小数类型:默认初始化值0.0
        //字符类型:默认初始化值'\u0000' 空格
        //布尔类型:默认初始化值 false
        //引用数据类型:默认初始化值 null
        int[] arr2=new int[3];
        System.out.println(arr2[0]);//0
        System.out.println(arr2[1]);//0
        System.out.println(arr2[2]);//0

    }
}

在这里插入图片描述

2.数组动态初始化和静态初始化的区别

在这里插入图片描述

六、数组内存图

1.Java内存分配


在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.数组的内存图

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
s
在这里插入图片描述

3.总结:

(1)只要是new出来的,一定是在堆里面开辟了一个小空间
(2)如果new了很多次,那么在堆里面有多个小空间,每个小空间都有各自的数据

4.两个数组指向同一个空间的内存

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

总结:

当两个数组指向同一个小空间时,其中一个数组对小空间中的值发生了改变,那么其他数组再次访问的时候都是修改之后的结果了

七、数组常见问题

在这里插入图片描述

public class test15 {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr={1,2,3,4,5};
        //长度:5
        //最小索引:0
        //最大索引:4(数组的长度-1)
        System.out.println(arr[10]);

        //小结:
        //索引越界异常
        //原因:访问了不存在的索引
        //避免:索引的范围
        
    }
}

在这里插入图片描述

小结:

    索引越界异常
    原因:访问了不存在的索引
    避免:索引的范围

八、数组常见操作

在这里插入图片描述

1.求最值

在这里插入图片描述
在这里插入图片描述

public class test16 {
    public static void main(String[] args) {
        //定义数组求最大值: 33,5,22,44,55

        //扩展问题
        //1.根据求最大值的思路,自己改写一下求最小值
        //2.为什么max要记录为arr[0],默认值不能为0呢?
        //不能写0,当数组元素里面有负数时,这时可能最终结果是数组原来不存在的数据
        //max的初始值一定要是数组中的值
        //循环的开始条件一定是0吗
        //循环的开始条件如果是0,那么第一次循环的时候就是自己和自己比了一下,对结果没有任何影响,但是效率偏低
        //为了提高效率,减少一次循环的次数,循环开始条件可以改为1

        //1.定义数组用来存储5个值
        int[] arr={33,5,22,44,55};
        //2.定义一个变量max用来存储最大值
        //临时认为0索引的数据是最大的
        int max=arr[0];
        //3.循环获取数组中的每一个元素
        //拿着每一个元素和max比较
        for (int i = 0; i < arr.length; i++) {
            //i索引 arr[i]元素
            if(arr[i]>max){
                max=arr[i];
            }
        }

        //4.当循环结束之后,max记录的是数组中的最大值
        System.out.println(max);//55
    }
}

在这里插入图片描述

2.遍历数组求和

在这里插入图片描述

import java.util.Random;

public class test17 {
    public static void main(String[] args) {
        /*
        需求:
        生成10个1-100之间的随机数存入数组
        1.求出所有数据的和
        2.求所有数据的平均数
        3.统计有多少个数据比平均数小
         */

        //分析:
        //1.定义数组:
        int[] arr=new int[10];
        //2.把随机数存入到数组中
        Random r=new Random();

        for (int i = 0; i < arr.length; i++) {
            int number=r.nextInt(100)+1;
            //把生成的随机数添加到数组中
            arr[i]=number;
        }
        //1.求和
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum=sum+arr[i];
        }
        System.out.println("数组中所有数据的和为:"+sum);


        //2.平均数
        int avg=sum/arr.length;
        System.out.println("数组中平均数为:"+avg);

        //3.统计有多少个数据比平均数少
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<avg){
                count++;
            }
        }
        System.out.println("在数组中,一共有"+count+"个数据,比平均数小");


        //遍历数据,验证答案
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+" ");
        }
    }
}

在这里插入图片描述

3.交换数组中的数据

在这里插入图片描述

方法一:

public class test18 {
    public static void main(String[] args) {
        /*
        需求:定义一个数组,将数组中0索引和最大索引的值进行交换
         */

        int[] arr={1,2,3,4,5};
        //利用第三方变量进行交换
        int temp=arr[0];
        arr[0]=arr[4];
        arr[4]=temp;
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + " ");
        }


    }
}

在这里插入图片描述

方法二:

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
一直交换到 i = j 或者 i > j

public class test19 {
    public static void main(String[] args) {
        /*
        需求:定义一个数组,存入1,2,3,4,5,交换首尾索引对应的元素
        交换前:1,2,3,4,5
        交换后:5,2,3,4,1
         */
        
        int[] arr={1,2,3,4,5};
        //利用循环去交换数据
        for (int i = 0,j=arr.length-1; i <j; i++,j--) {
            //交换变量i和变量j指向的元素
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
            
        }
        //当循环结束之后,那么数据中的数据就实现了首尾交换
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+" ");
        }
    }
}

在这里插入图片描述

4.打乱数组中的数据

在这里插入图片描述

import java.util.Random;

public class test20 {
    public static void main(String[] args) {
        /*
        需求:定义一个数组,存入1~5,要求打乱数组中所有数据的顺序
         */

        //难点:
        //如何获取数组中的随机索引
        // int[] arr={1,2,3,4,5};
        //索引范围: 0 1 2 3 4
//        Random r=new Random();
//        int randomindex=r.nextInt(arr.length);
//        System.out.println(randomindex);

        //1.定义数组存储1-5
        int[] arr={1,2,3,4,5};
        //2.循环遍历数组,从0索引开始打乱数据的顺序
        Random r=new Random();
        for (int i = 0; i < arr.length; i++) {
            //生成一个随机索引
            int randomindex=r.nextInt(arr.length);
            //拿着随机索引指向的元素,与i指向的元素进行交换
            int temp =arr[i];
            arr[i]=arr[randomindex];
            arr[randomindex]=temp;
        }
        //当循环结束之后,那么数组中所有的数据已经打乱顺序了
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+" ");
        }
    }
}

在这里插入图片描述
在这里插入图片描述

总结

今天的内容你是否有所收获呢友友们🥰如果有写的不对的地方,欢迎大家帮我指正.最后,希望友友们点赞收藏一下博客关注后续的Java学习内容哦~😘💕💕

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

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

相关文章

单绞机控制算法模型（Simulink仿真）

单绞机控制算法模型（Simulink仿真）

线缆行业单绞机PLC控制算法详细解读可以参看下面的文章链接： 线缆行业单绞机控制算法（详细图解+代码）_RXXW_Dor的博客-CSDN博客在了解单绞机之前需要大家对收放卷以及排线控制有一定的了解，不清楚的可以参看下面几篇博客，这里不再赘述，受水平和能力所限，文中难免出现错…
阅读更多...
【JavaEE】认识线程Thread类及常用方法线程状态

【JavaEE】认识线程Thread类及常用方法线程状态

目录 一&#xff1a;认识线程&#xff1a; 二、线程的优点&#xff1a; 三、进程和线程的区别&#xff08;面试题&#xff09;&#xff1a; 四、第一个多线程程序&#xff1a; 五、创建线程的方式&#xff1a; 六、Thread类及常用方法 Thread类常见构造方法&#xff1…
阅读更多...
整理介绍字符函数和字符串函数+内存函数

整理介绍字符函数和字符串函数+内存函数

本篇重点介绍处理字符和字符串的库函数的使用和注意事项 本篇重点本篇重点介绍处理字符和字符串的库函数的使用和注意事项前言&#xff1a;求字符串长度strlen拷贝字符串函数strcpy&#xff08;追加&#xff09;连接字符串函数strcat比较两个字符串函数strcmp对上面改进字符串函…
阅读更多...
Mac应用程序无法打开或文件损坏的处理方法

Mac应用程序无法打开或文件损坏的处理方法

很多用户在安装 盗版 Mac软件的时候&#xff0c;经常会遇到提示“xxx.app已损坏&#xff0c;打不开。您应该将它移到废纸篓“或”打不开的xxx.app&#xff0c;因为它来自身份不明的开发者”&#xff0c;等多种打不开盗版软件的各种提示&#xff0c;正版软件则不会出现。 错误截…
阅读更多...
17种编程语言实现排序算法-基数排序

17种编程语言实现排序算法-基数排序

开源地址 https://gitee.com/lblbc/simple-works/tree/master/sort/ 覆盖语言&#xff1a;C、C、C#、Java、Kotlin、Dart、Go、JavaScript(JS)、TypeScript(TS)、ArkTS、swift、PHP。 覆盖平台&#xff1a;安卓(Java、Kotlin)、iOS(SwiftUI)、Flutter(Dart)、Window桌面(C#)、…
阅读更多...
事件冒泡和时间捕获

事件冒泡和时间捕获

事件冒泡和事件捕获 最近&#xff0c;在复习Vue的时候&#xff0c;发现自己对于事件冒泡和事件捕获的理解存在一定的错误。于是想写一份笔记来总结一下事件冒泡和事件捕获。✌✌✌ 一、事件 1、事件的三个阶段&#xff1a;事件捕获->事件目标->事件冒泡 捕获阶段&am…
阅读更多...
MySQL 性能优化浅析及线上案例

MySQL 性能优化浅析及线上案例

作者&#xff1a;京东健康 孟飞 1、 数据库性能优化的意义 业务发展初期&#xff0c;数据库中量一般都不高&#xff0c;也不太容易出一些性能问题或者出的问题也不大&#xff0c;但是当数据库的量级达到一定规模之后&#xff0c;如果缺失有效的预警、监控、处理等手段则会对用户…
阅读更多...
设计模式学习（十二）：Decorator装饰器模式

设计模式学习（十二）：Decorator装饰器模式

一、什么是Decorator模式假如现在有一块蛋糕&#xff0c;如果只涂上奶油&#xff0c;其他什么都不加&#xff0c;就是奶油蛋糕。如果加上草莓&#xff0c;就是草莓奶油蛋糕。如果再加上一块黑色巧克力板&#xff0c;上面用白色巧克力写上姓名&#xff0c;然后插上代表年龄的蜡烛…
阅读更多...
JavaEE5-Spring更简单的读取和存储对象

JavaEE5-Spring更简单的读取和存储对象

目录 1.存储Bean对象 1.1.前置工作&#xff1a;在配置文件中设置bean扫描的根路径&#xff08;重要&#xff09; 1.2.添加注解存储Bean对象到Spring中 1.2.1.类注解(添加到某个类上&#xff0c;将当前的类存储到Spring中)&#xff1a;Controller&#xff0c;Service&#x…
阅读更多...
树,堆,二叉树的认识

树,堆,二叉树的认识

1.树概念及结构 1.1树的概念 注意&#xff1a;树形结构中&#xff0c;子树之间不能有交集&#xff0c;否则就不是树形结构 1.2 树的相关概念 1.3 树的表示 树结构相对线性表就比较复杂了&#xff0c;要存储表示起来就比较麻烦了&#xff0c;既然保存值域&#xff0c;也要保存…
阅读更多...
Gateway服务网关

Gateway服务网关

Gateway服务网关一、网关介绍二、gateway快速入门1.创建gateway服务&#xff0c;引入依赖2.编写启动类3.编写基础配置和路由规则4.重启测试5.网关路由的流程图三、断言工厂四、过滤器工厂1.路由过滤器的种类2.请求头过滤器3.默认过滤器4.总结五、全局过滤器1.全局过滤器作用2.自…
阅读更多...
fpga实操训练（系统开发和硬件接口）

fpga实操训练（系统开发和硬件接口）

【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 相信很多学习fpga的同学都会有这样的一个感受，一开始fpga学习还比较简单，但是一旦涉及到呼吸灯、uart、spi、iic、ddr2后面就会越来越难。遇到这样的困难之后，学习的激情一下子少…
阅读更多...
从零搭建一个组件库（一）项目环境搭建

从零搭建一个组件库（一）项目环境搭建

文章目录前言monorepo架构1.monorepo架构的优势2.使用pnpm搭建monorepo架构&#xff08;1&#xff09;全局安装pnpm&#xff08;2&#xff09;初始化项目&#xff08;3&#xff09;新建workspace.yaml文件4.不同包之间的相互引用TypeScript支持1.安装TypeScript2.初始化TypeScr…
阅读更多...
http三次握手四次挥手详解

http三次握手四次挥手详解

1、 TCP的三次握手和四次挥手实质就是TCP通信的连接和断开。 三次握手&#xff1a;为了对每次发送的数据量进行跟踪与协商&#xff0c;确保数据段的发送和接收同步&#xff0c;根据所接收到的数据量而确认数据发送、接收完毕后何时撤消联系&#xff0c;并建立虚连接。 四次挥…
阅读更多...
C++6:STL-模拟实现string

C++6:STL-模拟实现string

string时STL中的模板库之一&#xff0c;类似于专门处理字符串的数据结构&#xff0c;在模拟实现并探讨其中构造的巧妙之处之前&#xff0c;我们短浅的认识一下STL是什么 目录 什么是STL STL的诞生 关于string string的模拟实现 构造函数和析构函数 实现简单的string打印 …
阅读更多...
【蓝桥杯】简单数论2——快速幂矩阵快速幂

【蓝桥杯】简单数论2——快速幂矩阵快速幂

1、快速幂 1.1运算模 定义&#xff1a;模运算为a除以m的余数&#xff0c;记为a mod m&#xff0c;有a mod m a % m。 模运算是大数运算中的常用操作&#xff1a;如果一个数太大&#xff0c;无法直接输出&#xff0c;或者不需要直接输出&#xff0c;可以把它取模后&#xff0…
阅读更多...
Android 深入系统完全讲解（37）

Android 深入系统完全讲解（37）

7.5 源码讲解 dlopen 打开动态库 dlsym 找到符号 (*print_func)(); 调用方法 我们可以看到&#xff0c;要使用一个 so 库的某个方法&#xff0c;就上面三步骤&#xff0c;加载 &#xff0c;查找 &#xff0c;使用 。我 们这里调用了 so 库中的 my_print 方法。 7.6 运行 我们把…
阅读更多...
Linux——进程间通信

Linux——进程间通信

文章目录前言1. 进程间通信方式的一些标准&#xff1a;2. 管道2.1 什么是管道2.2 管道的原理2.3 匿名管道2.3.1 实例代码1. demo代码2. 总结管道的特点&#xff0c;理解以前的管道 |3. 扩展——进程池2.4 管道读写规则2.5 命名管道2.5.1 创建一个命名管道2.5.2 命名管道的打开规…
阅读更多...
Python break用法详解

Python break用法详解

我们知道&#xff0c;在执行 while 循环或者 for 循环时&#xff0c;只要循环条件满足&#xff0c;程序将会一直执行循环体&#xff0c;不停地转圈。但在某些场景&#xff0c;我们可能希望在循环结束前就强制结束循环&#xff0c;Python 提供了 2 种强制离开当前循环体的办法&a…
阅读更多...
路由处理及功能（实现了权限控制vue admin）

路由处理及功能（实现了权限控制vue admin）

界面简化 将 template 改为&#xff1a; <template><div class"login-container"><el-formref"loginForm":model"loginForm":rules"loginRules"class"login-form"autocomplete"on"label-positio…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023