五、数组——Java基础篇

news2025/7/13 0:54:36

五、数组

1、数组元素的遍历

1.1数组的遍历：将数组内的元素展现出来

1、普通for遍历：根据下表获取数组内的元素
2、增强for遍历：
for（数据元素类型 变量名：数组名）{
变量名：数组内的每一个值
}

区别：
（1）、需要下标：就是用普通for，不需要下标使用增强for
（2）、增强遍历的底层原理就是普通for

public class Travesal1 {
    public static void main(String[] args) {
        String[] sArr={"安其拉","妲己","吕布"};
        //增强for遍历
        for (String e : sArr) {
            System.out.println("e = " + e);
        }
        
        
        //普通for遍历
        for(int index=0;index<sArr.length;index++){
            String ele=sArr[index];
            System.out.println("ele = " + ele);
        }
    }
}

class Travesal02{
    public static void main(String[] args) {
        int[] arr={30,20,40,50,90,80};
        //增强for遍历
        for (int i : arr) {
            System.out.println("增强for= " + i+"");
        }

        //普通for遍历
        for (int e = 0; e < arr.length; e++) {
            System.out.println("普通for =" + arr[e]);

        }
    }
}
1.2 定义一个整形数组

int[] arr={66,77,88,99,11,22,33};
获取总和？

   public class TrversalExer2 {
    public static void main(String[] args) {
        int[] arr={66,77,88,99,11,22,33};
   //定义变量记录总和
    int sum=0;
    //增强遍历
    for(int e:arr){
        sum+=e;
    }
    //普通遍历
//        for (int i = 0; i < arr.length; i++) {
//            sum+=arr[i];
//        }
        System.out.println("总和为：" + sum);
    }
}
1.3 定义一个整型数组，获取最大值和标出下标?

int[] arr={66,77,88,99,11,22,33};

public class TrversalExer_1{
    public static void main(String[] args) {

        //1、定义数组
        int[] arr={66,77,88,99,11,22,33};
        //todo定义变量 记录最大值，下标
        int maxNum=0;
        int index=0;
        //2、开始遍历
        for (int i = 0; i < arr.length; i++) {
            //数组中的每一个元素与假设的”int maxNum=1;“进行比较，如果数组元素>假设值，则元素是最大值
            if(arr[i]>maxNum){
                maxNum=arr[i];
                //记录最大值下标
                index=i;
            }
        }
        //3、展示数组
        System.out.println("最大值是：" + maxNum+",下标是"+index);
    }
}
class TrversalExer_2{
    public static void main(String[] args) {
        //1.定义变量
        int[] arr={66,77,88,99,11,22,33};
        //2.定义变量记录最小值下标
        int minNum=arr[0];
        int index=0;

        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<minNum){
                minNum=arr[i];
                index=1;

            }
        }
        System.out.println("最小值三十：" + minNum+",下标是"+index);

    }
}

2、Java虚拟机的内存划分

​ 为了提高运算效率，就对空间进行了不同的区域划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
在这里插入图片描述

​ 程序运行时才会在虚拟机上开辟内存，内存区域划分的目的，提高运算效率

1 .栈：存储着方法内的局部变量信息。
2 .堆：对象。new的对象，包括数组，都存在堆中。
3 .本地方法栈：Java并不是万能的，有些功能时无法实现的额，需要救助与其他语言来实现，通过调用本地方法调用其他语言。
4 .方法区（元空间）：静态信息，常量信息，类中的描述信息。
5 .程序计数器：存储计算机下一条指令的地址。

2.1 怎么画栈堆图
public class JVMMemory3 {
    public static void main(String[] args) {
        int m=10;
        int[] arr=new int[3];

        arr[0]=99;
        arr[2]=66;
        System.out.println("arr[0] = " + arr[0]);
        System.out.println("arr[1] = " + arr[1]);
        System.out.println("arr[3] = " + arr[3]);

    }
}

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

2.2 输出英文星期几

​ 用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词
​ {“Monday”,“Tuesday”,“Wednesday”,“Thursday”,“Friday”,“Saturday”,“Sunday”}

public class ArrayExer4 {
    public static void main(String[] args) {
        /*
        
        **/
        //1、准备数组
        String[] arr={"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
        //2、创建键盘输入对象
        Scanner in=new Scanner(System.in);
        //3、接受数组
        System.out.println("请输入数字1-7：");
        int month=in.nextInt();
        //4、展示单词
        String mesage = arr[month - 1];
        System.out.println("mesage = " + mesage);
        //5、关闭资源
        in.close();
    }
}
2.3 从键盘读入学生成绩，找出最高分，并输出学生成绩等级
- 成绩>=最高分-10  等级为’A’
    - 成绩>=最高分-20  等级为’B’
    - 成绩>=最高分-30  等级为’C’
    - 其余            等级为’D’
    提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
    请您输入第1个学生的成绩
    90
    请您输入第2个学生的成绩
    80
    请您输入第3个学生的成绩
    70
    请您输入第4个学生的成绩
    60
    请您输入第5个学生的成绩
    80

class ArrayExery_2{
    public static void main(String[] args) {
        //1、创建键盘输入对象
        Scanner in=new Scanner(System.in);
        //2、获取学生的个数
        System.out.println("请输入学生的个数：");
        int count=in.nextInt();
        //3、创建数组，存储学生的成绩
        int[] arr=new int[count];
        //4、遍历数组、存储成绩
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请您输入第"+(i+1)+"个学生的成绩");
            int soure=in.nextInt();
            arr[i]=soure;
        }
        //5、过去最高成绩
        int maxsoure=arr[0];
        for (int i : arr) {
            if(i>maxsoure){
               maxsoure=i;
            }
        }
        System.out.println("maxsoure = " + maxsoure);
        //6、判断学生的等级

        for (int i = 0; i < arr.length; i++) {
            int score = arr[i];
            if(score>=maxsoure-10){
                System.out.println("第"+(i+1)+"个学生成绩等级是：A");
            }else if(score>=maxsoure-20){
                System.out.println("第"+(i+1)+"个学生成绩等级是：A");
            }else if(score>=maxsoure-30){
                System.out.println("第"+(i+1)+"个学生成绩等级是：A");
            }else{
                System.out.println("第"+(i+1)+"个学生成绩等级是：A");
            }

        }
        //7、关闭资源
        in.close();
    }
}

3、冒泡排序

在这里插入图片描述

3.1 冒泡排序的准备
public class BubbleSort5 {
    public static void main(String[] args) {
        int m=20;
        int n=10;
        System.out.println("交换前：m = " + m+",n="+n);
         int temp=m;
         m=n;
         n=temp;

        System.out.println("交换后：m = " + m+",n="+n);
        int[] arr={77,66,55,44,33,22,11};
        System.out.println("arr = " + arr);//地址值：[I@5b480cf9
        //Arrays.toString(arr)+soutv,展示arr中的值
        System.out.println("Arrays.toString(arr) = " + Arrays.toString(arr));
    }

}
3.2 冒泡排序的基础写法
class BubbleSort_1{
    public static void main(String[] args) {
        int[] arr={77,66,55,44,33,22,11};
        System.out.println("排序前 = " + Arrays.toString(arr));
        //todo-1:数组元素时7个，最多6次有序
            for (int i = 0; i < arr.length-1; i++) {
        //todo进行每一次排序,-1:为了防止下标越界
        for(int j=0;j<arr.length-1;j++){
            //如果前一个>后一个，，两个数进行交换
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
        System.out.println("排序中 = " + Arrays.toString(arr));
    }
    System.out.println("排序后 = " + Arrays.toString(arr));
}
}
3.3 冒泡排序的优化
class BubbleSort_2{
    public static void main(String[] args) {
        int[] arr={77,66,55,44,33,22,11};
        System.out.println("排序前 = " + Arrays.toString(arr));
        //todo-1:数组元素时7个，最多6次有序
    for (int i = 0; i < arr.length-1; i++) {
        //假设此次排序已经有序，若是假设失败
        boolean flag=true;
        //todo进行每一次排序,-1:为了防止下标越界
        // -i:为了专注于无序部分即可，不需要对有序部分排序
        for(int j=0;j<arr.length-1-i;j++){
            //如果前一个>后一个，，两个数进行交换
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
                //如果有前一个>后一个则假设失败，数组无序
                flag=false;
            }
        }
        if(flag){
            break;
        }
        System.out.println("排序中 = " + Arrays.toString(arr));
    }
    System.out.println("排序后 = " + Arrays.toString(arr));
}
3.4 定义一个数组存储学生的成绩求总分平均分
3.5 定义一个数字 对数组元素进行反转

​ 10 20 30 40 50 60 70

​ 70 60 50 40 30 20 10

3.6 定义一个数组 键盘输入一个数字 判断此数字是否在数组内

​ 请您输入一个数
​ 55
​ 有此元素 55 下标是 3

​ 请您输入一个数
​ 99
​ 查无此元素 99

import java.util.Scanner;
public class ArrayText {
    public static void main(String[] args) {
        //1、创建键盘输入对象
        Scanner in=new Scanner(System.in);
        //2、获取成绩
        System.out.println("请问您要存储几个学生的成绩");
        int count=in.nextInt();
        //3、创建数组
        int[] arr=new int[count];
        //4、遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请您输入第"+(i+1)+"个学生的成绩");
            arr[i]=in.nextInt();
        }
        //4.1获取最大值、最小值、总成绩
        int maxNum=arr[0] , minNum=arr[0],sum=0;
        for (int e : arr) {
            if(e>maxNum){
                maxNum=e;
            }
            if(e<minNum){
                minNum=e;
            }

            sum+=e;
        }
        //5、展示总成绩，平均分，
        System.out.println("总成绩 = " + sum+",最高成绩="+maxNum+",最低成绩="+minNum+",平均分"+sum/arr.length);

        //6、关闭资源
        in.close();
    }
}

4、反转

4.1 反转1（开辟了新内存进行反转）
public class Reverse7 {
    public static void main(String[] args) {
        int[] arr={11,22,33,44,55,66,77};
        //反转前
        System.out.println("反转前 = " + Arrays.toString(arr));
        //反转
        //1、创建一个新数据 长度为7
        int[] newArr=new int[arr.length];
        //2、将旧数据内容 反转后存储到新数组内
        int index=0;
        for(int i=arr.length-1;i>=0;i--){
            newArr[index]=arr[i];
            //更改index下标
            index++;
        }
        //3、将新数组地址赋值给旧数组
        arr=newArr;
        //反转后
        System.out.println("反转后 = " + Arrays.toString(arr));
    }
}
4.2 反转2（就在原来的内存上进行反转）

在这里插入图片描述

class Reverse7_1{
    public static void main(String[] args) {
        int[] arr={11,22,33,44,55,66,77};
        //反转前
        System.out.println("反转前 = " + Arrays.toString(arr));
        //反转
        for(int i=0;i<arr.length/2;i++){
            int temp=arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;
        }
        //反转后
        System.out.println("反转后 = " + Arrays.toString(arr));
    }
}
4.3 反转3

在这里插入图片描述

LIndex=0左边从0开始，RIndex=arr.length-1右边往左开始，，左边<右边，，左边一直加，右边一直减

class Reverse7_3{
    public static void main(String[] args) {
        int[] arr={11,22,33,44,55,66,77};
        //反转前
        System.out.println("反转前 = " + Arrays.toString(arr));
        //反转
        //LIndex=0左边从0开始，RIndex=arr.length-1右边往左开始，，左边<右边，，左边一直加，右边一直减
        for(int LIndex=0,RIndex=arr.length-1;LIndex<RIndex;LIndex++,RIndex--){
            int temp=arr[LIndex];
            arr[LIndex]=arr[RIndex];
            arr[RIndex]=temp;
        }
        //反转后
        System.out.println("反转后 = " + Arrays.toString(arr));
    }
}
4.5 数组元素的扩容
4.6找出所有的偶数并求和
public class EvenTest8 {
    public static void main(String[] args) {
        int[] arr={10,11,12,13,14,15,16,17};
        //找出所有的偶数并求和
        int sum=0;
        for (int e : arr) {
            if(e%2==0){
                sum+=e;
            }
        }
        System.out.println("sum = " + sum);
    }
}
4.7 数组扩容（数组已经满了，再添加元素）
class EvenTest8_1{
    public static void main(String[] args) {
        String[] arr={"张三","王五","李四"};
        //1.创建一个新数组
        String[] newArr = new String[arr.length << 1];
        //2.将旧数组赋值为新数组
        for (int i = 0; i < arr.length; i++) {
            newArr[i]=arr[i];
        }
        //3.将新数组地址赋值给旧数组
        arr = newArr;
        arr[3]="安其拉";
        System.out.println("Arrays.toString(arr) = " + Arrays.toString(arr));
    }
}

在这里插入图片描述

5、总结

5.1数组元素的遍历

（1）普通for（值+fori）

（2）增强for（值+for）：底层是普通for

5.2 数组元素的内存图

（1）单个数组

（2）多个数组

（3）两个数组指向同一个地址

5.3数组的小算法

（1）顺序查找

（2）冒泡排序

（3）特殊值

（4）反转

（5）数组的扩容

6、二维数据的初始

7、二维数组的静态初始化

静态初始化：编译时确定数组的长度以及内容
形式1：
数据类型[][] 数据名={{},{}};
形式2：
数据类型[][] 数组名=new 数据类型[][]{{“李白”,“李三”},{“安其拉”,“哈哈”,“喜喜”}};

public class DoublearrayTest_1 {
    public static void main(String[] args) {
        System.out.println("---------静态数组------------");
        int[][] arr = {{20, 40, 60}, {11, 22, 33, 44}, {55, 66, 77, 88, 99},{100,200}};
        System.out.println("arr.length = " + arr.length);//4
        System.out.println("arr[0] = " + arr[0]);
        //第一个一维数组中的第三个元素
        System.out.println("arr[0][2] = " + arr[0][2]); //60
        System.out.println("arr[2][4] = " + arr[2][4]); //99
        System.out.println("arr[3].length = " + arr[3].length);//2

        String[][] arr1;
        arr1=new String[][]{{"李白","李三"},{"安其拉","哈哈","喜喜"}};
        System.out.println("arr1.length = " + arr1.length);//2
        System.out.println("arr1[1][2] = " + arr1[1][2]); //喜喜

    }
}

8、二维数组的动态初始化

动态初始化：编译时确定数组的长度和默认值
形式1：规则矩形
数据类型[][] 数组名=new 数据类型[ 数组1][ 数值2]；
数值1：一位数组的的个数
数组2：一维数组内元素的个数

class DoublearrayTest1_2 {
    public static void main(String[] args) {
        //数据类型[][] 数组名=new 数据类型[数组1][数值2]；
        int[][] arr = new int[5][6];
        System.out.println("arr.length = " + arr.length);
        System.out.println("arr[0].length = " + arr[0].length);
        System.out.println("arr[4].length = " + arr[4].length);
        System.out.println("arr[0][0] = " + arr[0][0]);

    }
}

​ 形式2：非规则矩形
​ 数据类型[][] 数组名=new 数据类型[数组1][][ ]；
​ 数值1：一位数组的的个数

class DoublearrayTest1_2 {
    public static void main(String[] args) {
        //数据类型[][] 数组名=new 数据类型[数组1][]；
        int[][] iArr = new int[3][];
        System.out.println("iArr[0] = " + iArr[0]);
        iArr[0] = new int[6];
        iArr[0][0] = 66;
        iArr[1] = new int[]{33,55,77};
    }
}

8、二维数组的遍历

public class Taversal_2 {
    public static void main(String[] args) {
        String[][] arr = {{"侵权","王五"},{"嗯嗯","让人","头疼"},{"右移","哈哈","更改","得到"}};
//只遍历第一个一维数组，其他的依次类推
        //        for(int i=0;i<arr[0].length;i++){
//            System.out.println(arr[0][i]+"\t");
//        }
        for (String[] eleArr : arr) {
            //对一堆数组再次遍历
            for (String e : eleArr) {
                System.out.println(e+"\t");
            }
            System.out.println();
        }
    }
}
class Taversal2_1{
    public static void main(String[] args) {
        int[][] arr={{11,22},{33,44,55}};
        for (int[] eleArr : arr) {
            for (int e : eleArr) {
                System.out.println(e+"\t");
            }
        }
    }
}

9、二维数组的内存图

​ 二位数组的元素是一维数组，一维数组不是基本类型数据，不是基本那就是引用，引用数据类型默认值null。
在这里插入图片描述

10、二维数组求最值

public class BoubleArrayExer_3 {
    public static void main(String[] args) {
        //获取最大值/最小值
        int[][] arr={{111,222,333},{10,20,30},{-1,-2,99}};
        //定义变量记录最大值和最小值
        int maxNum=arr[0][0];
        int minNum=arr[0][0];
        //遍历数据，获取每一个值
        for (int[] eleArr : arr) {
            for (int e : eleArr) {
                //如果数组元素>假设得最大值 则说明数组元素是最大值
                if(e>maxNum){
                    maxNum=e;
                }
                //如果数组元素<假设得最小值 则说明数组元素是最小值
                if(e<minNum){
                    minNum=e;
                }
            }
        }
        System.out.println("最大值 = " + maxNum+",最小值 = " + minNum);
    }
}

键盘输入一个正整数 ，动态 创建长度为输入的数得二维数组，遍历此二维数组再控制台。
1
22
333
4444
55555

class BoubleArrayExer3_1{
    public static void main(String[] args) {
        //1、创建键盘输入对象
        Scanner in=new Scanner(System.in);
        //2、获取数组得长度
        System.out.println("请您输入数组的长度：");
        int length = in.nextInt();
        //3、创建二维数组
        int[][] arr=new int[length][];
        //4、遍历数组给元素赋值
        //4.1遍历二维数据获取每一个一维数组下标
        for (int i = 0; i < arr.length; i++) {
            //4.2给一位数组开辟空间（初始化）
            arr[i] = new int[i + 1];
            //4.3遍历一维数组，给每一个元素赋值
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j]=i+1;
            }
        }
//        System.out.println("arr[0] = " + arr[0]);
//        arr[0]=new int[0+1];
//        arr[0][0]=0+1;
//        arr[1]=new int[1+1];
//        arr[1][0]=1+1;
//        arr[1][1]=1+1;
//        arr[2]=new int[2+1];
//        arr[2][0]=2+1;
//        arr[2][1]=2+1;
//        arr[2][2]=2+1;
        //5、展示数据
        for (int[] eleArr : arr) {
            for (int e : eleArr) {
                System.out.print(e);
            }
            System.out.println();
        }
        //6、关闭资源
        in.close();
    }
}

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

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

相关文章

家庭游泳池：阳台上可安装的泳池

家庭游泳池：阳台上可安装的泳池

游泳池可根据场地大小选择安装在室内或室外&#xff0c;这种的泳池规格尺寸相对来说较大&#xff0c;较适合于大型体育场馆、小区配套、健身房等场所。这款家庭泳池与之前的不太一样&#xff0c;不论是从池体材料还是装饰面层都有着很大的差异。 该家庭泳池规格尺寸比较固定&a…
阅读更多...
信号的分类

信号的分类

确定信号与随机信号 确定信号&#xff1a;用一个确定的时间函数表示的信号&#xff08;其他函数也可以&#xff0c;但在信号与系统中主要指时间函数&#xff09;。其中包括周期信号与非周期信号&#xff0c;连续时间信号与离散时间信号等。 随机信号&#xff1a;信号不能用一…
阅读更多...
Smart Link基本概念

Smart Link基本概念

Smart Link通过两个端口相互配合工作来实现功能。这样的一对端口组成了一个Smart Link组。为了区别一个Smart Link组中的两个端口&#xff0c;我们将其中的一个叫做主端口&#xff0c;另一个叫做从端口。同时我们利用Flush报文、Smart Link实例和控制VLAN等机制&#xff0c;以更…
阅读更多...
【软件设计师】多元化多方面了解多媒体技术的内容

【软件设计师】多元化多方面了解多媒体技术的内容

&#x1f413; 多媒体技术基本概念 多媒体主要是指文字、声音和图像等多种表达信息的形式和媒体&#xff0c;它强调多媒体信息的综合和集成处理。多媒体技术依赖于计算机的数字化和交互处理能力&#xff0c;它的关键是信息压缩技术和光盘存储技术。 亮度 亮度是光作用于人眼时所…
阅读更多...
2024年2月深度学习的论文推荐

2024年2月深度学习的论文推荐

我们这篇文章将推荐2月份发布的10篇深度学习的论文 Beyond A*: Better Planning with Transformers via Search Dynamics Bootstrapping. https://arxiv.org/abs/2402.14083 Searchformer是一个基于Transformer架构的人工智能模型&#xff0c;经过训练可以模拟A星寻路算法&a…
阅读更多...
【习题——菱形的打印】

【习题——菱形的打印】

一、打印下面的图形&#xff08;菱形&#xff09; 我们可以先来看一个简单点的菱形&#xff1a; 输入描述&#xff1a; 输入一个char类型字符 输出描述&#xff1a; 输出一个用这个字符填充的对角线长5个字符&#xff0c;倾斜放置的菱形&#xff1a; 1、思路&#xff1a; 我…
阅读更多...
微服务 人工智能AI 物联网智慧工地云平台源码

微服务 人工智能AI 物联网智慧工地云平台源码

目录 ​编辑 智慧工地架构 智慧工地系统 智慧工地云平台功能模块 1、基础数据管理 2、考勤管理 3、安全隐患管理 4、视频监控 5、塔吊监控 6、升降机监控 7、移动端数据推送 智慧工地管理平台子系统构成 智慧工地物联网解决方案&#xff0c;对工地施工安全人员、设…
阅读更多...
如何使用 Pandas 删除 DataFrame 中的非数字类型数据？

如何使用 Pandas 删除 DataFrame 中的非数字类型数据？

目录 前言 识别非数字类型数据 删除非数字类型数据 1. 使用 drop() 方法删除非数字类型的列 2. 使用布尔索引删除非数字类型的行 3. 使用 applymap() 方法转换非数字类型数据 4. 使用 to_numeric() 函数转换非数字类型数据 应用实例&#xff1a;处理销售数据 总结 前言 在…
阅读更多...
SemiDrive E3 MCAL 开发系列（2） – Port Dio 模块的使用

SemiDrive E3 MCAL 开发系列（2） – Port Dio 模块的使用

一、概述 本文将会介绍如何导入 SemiDrive E3 系列 MCU 的 MCAL 配置工程以及介绍 Port 和 Dio 模块的基本配置&#xff0c;并且会结合实际操作的介绍&#xff0c;帮助新手快速了解并掌握这两个模块的使用&#xff0c;文中的 MCAL 是基于 PTG3.0 的版本&#xff0c;开发板是官…
阅读更多...
android应用开发基础知识，安卓面试2020

android应用开发基础知识，安卓面试2020

第一章&#xff1a;设计思想与代码质量优化 1、设计思想六大原则 2、三大设计模式 3、数据结构 4、算法 第二章&#xff1a;程序性能优化 1、启动速度和执行效率优化 2、布局检测与优化 3、内存优化 4、耗电优化 5、网络传输与数据存储优化 6、APK大小优化 7、屏幕适配 8、…
阅读更多...
【教3妹学编程-算法题】标记所有下标的最早秒数 II

【教3妹学编程-算法题】标记所有下标的最早秒数 II

3妹&#xff1a;2哥2哥&#xff0c;你有没有看到上海女老师出轨男学生的瓜啊。 2哥 : 看到 了&#xff0c;真的是太毁三观了&#xff01; 3妹&#xff1a;是啊&#xff0c; 老师本是教书育人的职业&#xff0c;明确规定不能和学生谈恋爱啊&#xff0c;更何况是出轨。 2哥 : 是啊…
阅读更多...
【小沐学QT】QT学习之信号槽使用

【小沐学QT】QT学习之信号槽使用

文章目录 1、简介2、代码实现2.1 界面菜单“转到槽”方法2.2 界面信号槽编辑器方法2.3 QT4.0的绑定方法2.4 QT5.0之后的绑定方法2.5 C11的方法2.6 lamda表达式方法 结语 1、简介 在GUI编程中&#xff0c;当我们更改一个小部件时&#xff0c;我们通常希望通知另一个小程序。更普…
阅读更多...
【Unity】构建简单实用的年份选择器（简单原理示范）

【Unity】构建简单实用的年份选择器（简单原理示范）

在许多应用程序和游戏中&#xff0c;年份选择是一个常见的需求。无论是在日历应用程序中查看事件&#xff0c;还是在历史类游戏中选择时间段&#xff0c;年份选择器都是用户体验的重要组成部分&#xff0c;下面实现一个简易的年份选择器。 一、效果预览&#xff1a; 目录 一、…
阅读更多...
sylar高性能服务器-日志(P43-P48)内容记录

sylar高性能服务器-日志(P43-P48)内容记录

文章目录 P43&#xff1a;Hook01一、HOOK定义接口函数指针获取接口原始地址 二、测试 P44-P48&#xff1a;Hook02-06一、hook实现基础二、class FdCtx成员变量构造函数initsetTimeoutgetTimeout 三、class FdManager成员变量构造函数get&#xff08;获取/创建文件句柄类&#x…
阅读更多...
前端架构: 脚手架之包管理工具的案例对比及workspaces特性的使用与发布过程

前端架构: 脚手架之包管理工具的案例对比及workspaces特性的使用与发布过程

npm的workspaces 特性 1 &#xff09;使用或不使用包管理工具的对比 vue-cli 这个脚手架使用 Lerna 管理&#xff0c;它的项目显得非常清晰在 vue-cli 中包含很多 package 点开进去&#xff0c;每一个包都有package.json它里面有很多项目&#xff0c;再没有 Lerna 之前去维护和…
阅读更多...
【Spring】回顾反射机制

【Spring】回顾反射机制

一、分析方法四要素 package org.qiu.reflect;/*** author 秋玄* version 1.0* email qiu_2022aliyun.com* project Spring* package org.qiu.reflect* date 2022-11-11-17:26* since 1.0*/ public class SomeService {public void doSome(){System.out.println("public …
阅读更多...
【Unity】如何在Unity 中创建带有缩放效果的滚动视图（具有吸附效果的实现与优化）？

【Unity】如何在Unity 中创建带有缩放效果的滚动视图（具有吸附效果的实现与优化）？

效果预览&#xff1a; 目录 效果预览&#xff1a; 一、引言&#xff1a; 二、问题描述 三、解决方案&#xff1a; 三、优化&#xff1a; 四、结论 一、引言&#xff1a; 在Unity开发中&#xff0c;经常需要实现滚动视图&#xff08;ScrollView&#xff09;中的内容吸附到…
阅读更多...
个人博客系列-Django部署-nginx（3）

个人博客系列-Django部署-nginx（3）

使用Nginx uwsgi进行部署django项目 一. 检查项目是否可以运行 启动项目 python manage.py runserver 0.0.0.0:8099输入ip:8099 查看启动页面 出现上述页面表示运行成功 二. 安装uwsgi并配置 2.1 下载uwsgi pip install uwsgi新建文件test.py写入内容&#xff0c;测试一…
阅读更多...
面试笔记系列六之redis+kafka+zookeeper基础知识点整理及常见面试题

面试笔记系列六之redis+kafka+zookeeper基础知识点整理及常见面试题

目录 Redis redis持久化机制&#xff1a;RDB和AOF Redis 持久化 RDB的优点 RDB的缺点 AOF 优点 AOF 缺点 4.X版本的整合策略 Redis做分布式锁用什么命令&#xff1f; Redis做分布式锁死锁有哪些情况&#xff0c;如何解决&#xff1f; Redis如何做分布式锁&#xff1f…
阅读更多...
Logic Pro：专业音乐制作软件，为你的音乐插上翅膀

Logic Pro：专业音乐制作软件，为你的音乐插上翅膀

Logic Pro是一款功能强大的音乐制作软件&#xff0c;专为专业音乐人和音乐爱好者设计。它提供了全面的音乐创作工具&#xff0c;包括音频录音、编辑、混音、合成以及自动化等功能&#xff0c;让你能够轻松实现音乐梦想。 Logic Pro软件获取 首先&#xff0c;Logic Pro拥有卓越…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023