2025年12月06日-代码

javase/src/sf/j251206/Demo01.java

@@ -0,0 +1,86 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 定义数组
+ * @create 2025/12/6
+ */
+public class Demo01 {
+    /*
+        Java中有两种数据类型
+            |-基本数据类型：byte/short/int/long/float/double/char/boolean
+            |-引用数据类型：
+                类 / 数组 / 枚举 / 接口 / 注解
+                所有引用数据类型的默认值都是null
+     */
+    public static void main(String[] args) {
+        /*
+            定义数组的格式：
+                第一种：
+                    数据类型[] 数组名;
+                    int[] arr;
+                    char[] arr;
+                    String[] arr;
+                第二种：
+                    数据类型 数组名[];
+                    int arr[];
+                    char arr[];
+                    String arr[];
+         */
+        //int[] arr=null;
+        //System.out.println(arr);
+        /*
+            数组的初始化方式：
+                |-动态初始化
+                    在初始化的时候，需要我们手动指定数组的长度，java会为数组容器分配初始值。
+                |-静态初始化
+            动态初始化-格式：
+                数组类型[] 数组名=new 数组类型[长度];
+                int[] arr=new int[10];
+                int[] int类型的数组
+                arr 数组名
+                new 为数组开辟一块空间
+                int[] 表示这是一个数组
+                10  数组的长度
+         */
+        int[] arr=new int[10];
+        System.out.println(arr);    //[I@140e19d
+        /*
+            [I@140e19d
+            [   一维数组
+            I   当前数组容器中存储的数据类型
+            @   分隔符
+            140e19d 十六进制内存地址
+         */
+        byte[] arr2=new byte[3];
+        System.out.println(arr2);   //[B@17327b6
+        /*
+            数组中每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+            这个自动的编号称为数组索引(index)，也可以叫下标，我们可以通过数组的索引访问到数组的元素。
+            访问的格式：
+                数组名[索引];
+         */
+        System.out.println(arr2[0]);
+        System.out.println(arr2[1]);
+        System.out.println(arr2[2]);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

javase/src/sf/j251206/Demo02.java

@@ -0,0 +1,64 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2025/12/6
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        /*
+            内存
+            冯·诺依曼架构
+            运算器+控制器+存储器+输入设备+输出设备
+            存储器--内存
+            是计算机中非常重要的原件之一，属于临时存储区域，作用是用来运行程序。
+            我们编写的程序代码放在硬盘中，在硬盘中的程序是不能运行的。
+            必须要放到内存中才能运行，运行完毕之后会清空内存。
+            Java的虚拟机要运行程序，就必须要对内存进行空间的分配和管理。
+
+            寄存器     给CPU用的，和Java开发基本没关系
+            本地方法栈   JVM(Java虚拟机)在使用操作系统功能的时候使用的，和我们开发没关系
+            方法区 存储可以运行的class文件
+                |-java的源代码是Java文件(后缀名是.java)
+                |-Java程序想要运行起来，需要经过几步：
+                    1、由虚拟机把.java文件编译成.class文件(字节码文件)
+                    2、再由虚拟机把.class文件里的字节码解释成二进制机器码
+            堆内存 存储对象或数组，使用new创建的，都是存储到堆内存中
+                |-桶结构
+                |-不连续，进入内存的内容，必须要有地址，根据地址才能找到。
+            栈内存(方法栈) 方法在运行的时候使用的内存，比如main方法运行，就要进入到方法栈中运行。
+                |-属于线性表结构，连续存储
+                |-先进后出
+                |-进入栈中：压栈、入栈
+                |-从栈内存中出去：弹栈、出栈
+         */
+        //int[] arr=new int[3];
+        int[] arr;  //定义arr变量，变量是int数组类型
+        //初始化数组
+        System.out.println(arr=new int[3]);;
+        System.out.println(arr);
+        System.out.println(arr[0]);
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);
+
+        //为数组元素进行赋值
+        arr[0]=16;
+        arr[1]=25;
+        arr[2]=30;
+
+        System.out.println(arr[0]);
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);
+        //把数组arr的地址赋值给arr2
+        int[] arr2=arr;
+        System.out.println(arr2);
+        System.out.println(arr);
+        //下面的三个分别开辟不同的空间
+        System.out.println(new int[10]);
+        System.out.println(new int[10]);
+        System.out.println(new int[10]);
+    }
+}

javase/src/sf/j251206/Demo03.java

@@ -0,0 +1,38 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description 静态初始化
+ * @create 2025/12/6
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        /*
+            数组的初始化方式：
+                |-静态初始化：创建数组的时候，直接将数组元素确定，有Java决定数组的长度
+                完整格式：
+                    数据类型[] 数组名=new 数组类型[]{元素1,元素2,...,元素n};
+                    int[] arr=new int[]{1,3,2,6,48,91,4};
+                简化格式：
+                    数据类型[] 数组名={元素1,元素2,...,元素n};
+                    int[] arr={1,3,2,6,48,91,4};
+         */
+        //数据类型[] 数组名=new 数组类型[]{元素1,元素2,...,元素n};
+        int[] arr=new int[]{1,3,2,6,48,91,4};
+        //数据类型[] 数组名={元素1,元素2,...,元素n};
+        int[] arr1={1,3,2,6,48,91,4};
+        System.out.println(arr);
+        System.out.println(arr1);
+
+        //如果数组长度为5，那么它的索引范围一定是0~4.
+        //数组的索引范围：0~数组长度-1，
+        //如果访问数组的时候超过了这个范围，就会触发异常：
+        //ArrayIndexOutOfBoundsException--数组越界异常
+        //在开发中，数组越界异常是不能出现的，一旦出现，就必须要修改代码。
+        int[] arr2=null;
+        System.out.println(arr2[0]);
+        //如果数组是null，还要访问数组的元素，就会触发NullPointerException 空指针异常
+    }
+}

javase/src/sf/j251206/Demo04.java

@@ -0,0 +1,23 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo04
+ * @description 遍历数组
+ * @create 2025/12/6
+ */
+public class Demo04 {
+    public static void main(String[] args) {
+        /*
+            遍历数组：就是把数组中的每个元素分别取出来，就是遍历。
+         */
+        int[] arr={15,3446,774,18,16,97,11};
+        // java为每个数组都提供了一个属性，数组名.length属性，用来获取数组的长度
+        System.out.printf("数组长度为：%d\n",arr.length);
+
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+    }
+}

javase/src/sf/j251206/Demo05.java

@@ -0,0 +1,30 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo05
+ * @description 练习：求数组中最大的元素
+ * @create 2025/12/6
+ */
+public class Demo05 {
+    public static void main(String[] args) {
+        /*
+            获取数组中最大的值
+            1、定义一个变量，存数组0索引上的元素
+            2、遍历数组，获取到数组的每个元素
+            3、把遍历的每个元素和保存的索引0上的值变量进行比较
+            4、如果元素值大于变量值，变量就记录新的值
+            5、直到数组循环遍历结束，变量保存的就是最大值
+         */
+        int[] arr={15,34,46,7,74,18,16,97,11};
+        int max=arr[0];
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i]>max){
+                max=arr[i];
+            }
+        }
+        System.out.println("数组中最大的值是："+max);
+
+    }
+}

javase/src/sf/j251206/Demo06.java

@@ -0,0 +1,41 @@
+package sf.j251206;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo06
+ * @description
+ * @create 2025/12/6
+ */
+public class Demo06 {
+    /*
+    数组元素求和
+    - 需求：键盘录入5个整数，存储到数组中，并对数组求和
+    - 思路：
+        1.创建键盘录入对象，准备键盘录入
+        2.定义一个求和变量，准备记录累加后的结果
+        3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
+        4.将键盘录入的数值存储到数组中
+        5.遍历数组，取出每一个元素，并求和
+        6.输出总和
+     */
+    public static void main(String[] args) {
+        //1.创建键盘录入对象，准备键盘录入
+        Scanner sc=new Scanner(System.in);
+        //2.定义一个求和变量，准备记录累加后的结果
+        int sum=0;
+        //3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
+        int[] arr=new int[5];
+        for (int i = 0; i < arr.length; i++) {
+            System.out.printf("请输入第%d个数:\n",i+1);
+            arr[i]=sc.nextInt();    //键盘输入一个数，存入到数组
+        }
+        //5.遍历数组，取出每一个元素，并求和
+        for (int i = 0; i < arr.length; i++) {
+            sum+=arr[i];
+        }
+        System.out.println("数组累加和为："+sum);
+    }
+}

javase/src/sf/j251206/Demo07.java

@@ -0,0 +1,35 @@
+package sf.j251206;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo07
+ * @description 顺序查找
+ * @create 2025/12/6
+ */
+public class Demo07 {
+    public static void main(String[] args) {
+        /*
+            已知一个int类型数组，键盘录入一个整数，查找该数据在数组中的索引值，并在控制台输出
+            如果没有该数据，则输出-1
+            思路：
+                1、定义数组，并初始化
+                2、键盘录入要查找的数据，使用一个变量接收- num
+                3、定义索引变量，初始值为-1 index
+                4、遍历数组，获取数组的每一个元素
+                5、将键盘录入的数据num和每一个元素arr[i]进行比较，相同则把元素索引值赋值给索引变量index
+                6、输出索引值index
+         */
+        int[] arr={15,34,46,7,74,18,16,97,11};
+        Scanner sc=new Scanner(System.in);
+        int num=sc.nextInt();
+        int index=-1;
+        for (int i = 0; i < arr.length; i++) {
+            if (num==arr[i])
+                index=i;
+        }
+        System.out.println(index!=-1?"要查找的数据在数组索引位置为："+index:"要查找的数据在数组中不存在");
+    }
+}

javase/src/sf/j251206/Demo08.java

@@ -0,0 +1,47 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo08
+ * @description 二分查找--折半查找
+ * @create 2025/12/6
+ */
+public class Demo08 {
+    /*
+        1,2,4,5,7,9,....,51,52,73,74,85,86,97,98,99,100
+        二分查找有个前提，数组必须是有序的，从小到大  从大到小
+        步骤：
+            1、定义两个变量，表示要查找的范围，min=0,max=最大索引值
+            2、循环查找，但是min<=max
+            3、计算出mid的值
+            4、判断mid的位置的元素是否为要查找的元素，如果是，直接返回索引值
+            5、如果要查找的值在mid的左半边，那么min值不变，max=mid-1，继续下一轮循环
+            6、如果要查找的值在mid右半边，那么max值不变，min=mid+1，继续下轮循环
+            7、当min>max的时候，表示要查找的元素在数组中不存在，返回-1
+
+     */
+    public static void main(String[] args) {
+        int num=24;
+        int[] arr={3,14,16,24,36,37,39,40,47,48,56,78,83};
+        int min=0,max=arr.length-1,mid=-1;
+        boolean flag=false;
+        while (min<=max){
+            mid=(min+max)/2;
+            //如果mid指向元素大于num
+            if(arr[mid]>num){
+                max=mid-1;
+            }else if(arr[mid]<num){
+                min=mid+1;
+            }else {
+                flag=true;
+                break;
+            }
+        }
+        if(flag){
+            System.out.println("num在数组的索引值为："+mid);
+        }else {
+            System.out.println(-1);
+        }
+    }
+}

javase/src/sf/j251206/Demo09.java

@@ -0,0 +1,35 @@
+package sf.j251206;
+
+import java.util.Arrays;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo09
+ * @description 冒泡排序
+ * @create 2025/12/6
+ */
+public class Demo09 {
+    public static void main(String[] args) {
+        /*
+            对相邻的两个数据进行比较，将较大的数据放在后面，依次对所有的数据进行操作，
+            直到所有的数据按要求排序。
+         */
+        int[] arr = {1, 67, 26, 5, 87, 16, 98, 41, 37, 8, 16, 87, 68, 79, 55, 77};
+        //外层循环，控制的是比较的次数，比数组的长度少1次
+        for (int i = 0; i < arr.length; i++) {
+            //内层循环，就是实际循环比较的代码
+            // -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;
+                }
+            }
+        }
+        //在控制台中输出数组的简便方式：利用Arrays工具类的toString()方法
+        System.out.println(Arrays.toString(arr));
+    }
+}

javase/src/sf/j251206/Demo10.java

@@ -0,0 +1,41 @@
+package sf.j251206;
+
+import java.util.Arrays;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo10
+ * @description
+ * @create 2025/12/6
+ */
+public class Demo10 {
+    /*
+        Java中，官方给我们提供了很多的工具类
+        类，是Java中的一个基本单元，一种引用数据类型，
+        类中，包含两部分：
+            类中的属性(变量)
+            类中的方法(类似c语言中的函数)
+        比如有一个数组的工具类：Arrays
+        Java中所有的工具类名后面都带s，比如数组工具类就是Array+s
+        Arrays里面包含几个我们常用的方法：
+            toString(int[] arr) 把数组中的元素，以字符串的形式返回
+            sort(int[] arr)  把数组进行排序，按照数字的顺序排序指定的数组
+            binarySearch(int[] arr,int key) 利用二分查找，找到指定的元素的索引
+     */
+    public static void main(String[] args) {
+        int[] arr = {1, 67, 26, 5, 87, 16, 98, 41, 37, 8, 16, 87, 68, 79, 55, 77};
+        //s = "[1, 67, 26, 5, 87, 16, 98, 41, 37, 8, 16, 87, 68, 79, 55, 77]";
+
+        //toString(int[] arr) 把数组中的元素，以字符串的形式返回
+        System.out.println(Arrays.toString(arr));
+
+        //sort(int[] arr)  把数组进行排序，按照数字的顺序排序指定的数组
+        Arrays.sort(arr);   //把数组排序--这个方法是采用【快速排序】
+        System.out.println(Arrays.toString(arr));
+
+        //binarySearch(int[] arr,int key) 利用二分查找，找到指定的元素的索引
+        int index = Arrays.binarySearch(arr, 41);   //二分查找
+        System.out.println(index);
+    }
+}

javase/src/sf/j251206/Demo11.java

@@ -0,0 +1,65 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo11
+ * @description
+ * @create 2025/12/6
+ */
+public class Demo11 {
+    /*
+        二维数组：也是一种容器，
+        一维数组里面的元素是变量或常量
+        二维数组里面的元素是一维数组
+        动态初始化格式：
+            数组类型[][] 变量名=new 数组类型[m][n];
+            m 表示这个二维数组中可以存放多少个一维数组
+            n 表示每个一维数组可以存放多少个元素
+     */
+    public static void main(String[] args) {
+        int[][] arr=new int[3][3];
+        int[][][] arr2=new int[3][3][3];
+        int[][][][] arr3=new int[3][3][3][3];
+        /*
+            [[I@140e19d
+            [[[I@17327b6
+            [[[[I@14ae5a5
+            [[ :有几个[就代表是几维数组
+            I 表示类型
+            @ 分隔符
+            140e19d 十六进制地址
+         */
+        System.out.println(arr);    //[[I@140e19d
+        System.out.println(arr2);   //[[[I@17327b6
+        System.out.println(arr3);   //[[[[I@14ae5a5
+
+        //向二维数组中存元素
+        arr[0][0]=1;
+        arr[0][1]=2;
+        arr[0][2]=3;
+        arr[1][0]=4;
+        arr[1][1]=5;
+        arr[1][2]=6;
+        arr[2][0]=7;
+        arr[2][1]=8;
+        arr[2][2]=9;
+        System.out.println(arr[0][0]);
+        System.out.println(arr[0][1]);
+        System.out.println(arr[0][2]);
+        System.out.println(arr[1][0]);
+        System.out.println(arr[1][1]);
+        System.out.println(arr[1][2]);
+        System.out.println(arr[2][0]);
+        System.out.println(arr[2][1]);
+        System.out.println(arr[2][2]);
+        // 能不能向二维数组中存入提前创建好的一维数组？   --可以的
+        int[] a1={10,20,30};
+        int[] a2={40,50,60};
+        int[] a3={70,80,90};
+        arr[0]=a1;
+        arr[1]=a2;
+        arr[2]=a3;
+
+    }
+}

javase/src/sf/j251206/Demo12.java

@@ -0,0 +1,25 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo12
+ * @description
+ * @create 2025/12/6
+ */
+public class Demo12 {
+    public static void main(String[] args) {
+        /*
+            二维数组--静态初始化方式：
+            完整格式：
+                    数据类型[][] 数组名=new 数组类型[][]{{元素1,元素2},...,{元素n}};
+                    int[][] arr=new int[][]{{1,3,2},{6,48,91,4}};
+                简化格式：
+                    数据类型[][] 数组名={{元素1,元素2,...,}{元素n}};
+                    int[][] arr={{1,3,2},{6,48,91,4}};
+         */
+        int[][] arr=new int[][]{{1,3,2},{6,48,91,4}};
+
+        int[][] arr2={{1,3,2},{6,48,91,4}};
+    }
+}

javase/src/sf/j251206/Demo13.java

@@ -0,0 +1,23 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo13
+ * @description 遍历二维数组
+ * @create 2025/12/6
+ */
+public class Demo13 {
+    public static void main(String[] args) {
+
+        int[][] arr={{1,3,2},{6,48,91,4}};
+        //因为是遍历二维数组，所以需要两层循环
+        for (int i = 0; i < arr.length; i++) {
+            // arr[i]就是二维数组中的一维数组
+            for (int j = 0; j < arr[i].length; j++) {
+                System.out.print(arr[i][j]+"\t");
+            }
+            System.out.println();
+        }
+    }
+}

javase/src/sf/j251206/Demo14.java

@@ -0,0 +1,28 @@
+package sf.j251206;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo14
+ * @description
+ * @create 2025/12/6
+ */
+public class Demo14 {
+    /*
+    二维数组求和
+        需求 :
+            某公司季度和月份统计的数据如下：单位(万元)
+            第一季度：22,66,44
+            第二季度：77,33,88
+            第三季度：25,45,65
+            第四季度：11,66,99
+        步骤 :
+            1. 定义求和变量，准备记录最终累加结果
+            2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
+            3. 遍历二维数组，获取所有元素，累加求和
+            4. 输出最终结果
+     */
+    public static void main(String[] args) {
+
+    }
+}

javase/src/sf/j251206/HomeWork01.java

@@ -0,0 +1,31 @@
+package sf.j251206;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork01
+ * @description 5.模拟用户登录，使用Scanner模拟用户登录，输入用户名和密码。如果用户名和密码正确，则输出“登录成功”，如果错误则输出“登录失败”
+ * @create 2025/12/6
+ */
+public class HomeWork01 {
+    public static void main(String[] args) {
+        String username="zhangsan";
+        String password="123456";
+        //Scanner 扫描键盘输入
+        Scanner sc=new Scanner(System.in);
+        System.out.println("请输入用户名");
+        String InUsername = sc.nextLine();
+        System.out.println("请输入密码");
+        String InPassword = sc.nextLine();
+        if (username.equals(InUsername)&&password.equals(InPassword)){
+            System.out.println("登录成功");
+        }else {
+            System.out.println("登录失败");
+        }
+
+    }
+
+
+}

javase/src/sf/j251206/HomeWork02.java

@@ -0,0 +1,85 @@
+package sf.j251206;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title HomeWork02
+ * @description 8、输入某年某月某日，判断这一天是这一年的第几天？
+ * @create 2025/12/6
+ */
+public class HomeWork02 {
+    /*
+    public static void main(String[] args) {
+        //键盘输入
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入年、月、日");
+        int year = sc.nextInt();
+        int mouth = sc.nextInt();
+        int day = sc.nextInt();
+        int t = 0;
+        //判断今年是平年还是闰年
+        boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
+        switch (mouth) {
+            case 12:
+                t += 30;
+            case 11:
+                t += 31;
+            case 10:
+                t += 30;
+            case 9:
+                t += 31;
+            case 8:
+                t += 31;
+            case 7:
+                t += 30;
+            case 6:
+                t += 31;
+            case 5:
+                t += 30;
+            case 4:
+                t += 31;
+            case 3:
+                if (isLeapYear) {
+                    //闰年
+                    t += 29;
+                } else {
+                    t += 28;
+                }
+            case 2:
+                t += 31;
+            case 1:
+                break;
+        }
+        int totalDay = t + day;
+        System.out.println(totalDay);
+    }
+     */
+    public static void main(String[] args) {
+        //键盘输入
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入年、月、日");
+        int year = sc.nextInt();
+        int mouth = sc.nextInt();
+        int day = sc.nextInt();
+        int totalDay = day;
+        //判断今年是平年还是闰年
+        boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
+        for (int i = 1; i < mouth; i++) {
+            switch (i){
+                case 1: case 3: case 5:case 7: case 8:case 10: case 12:
+                    totalDay+=31;
+                    break;
+                case 4: case 6: case 9: case 11:
+                    totalDay+=30;
+                    break;
+                case 2:
+                    totalDay+=isLeapYear?29:28;
+                    break;
+            }
+        }
+        System.out.println(year+"年"+mouth+"月"+day+"日是这一年的第"+totalDay+"天");
+        System.out.printf("%d年%d月%d日是这一年的第%d天",year,mouth,day,totalDay);
+    }
+}