五、数组——Java基础篇

已于 2024-02-26 22:36:14 修改
阅读量995 收藏 16
点赞数 21
分类专栏： java 文章标签： java 算法 数据结构
于 2024-02-25 20:33:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wkt1105436760/article/details/136286864
版权

五、数组

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();
    }
}
木头科技
关注
  • 21
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java基础之——数组应用篇
weixin_51346919的博客
07-31 368
/退出循环以后，即找到比要插入的数字小的数的下标了，此时应为index+1，因为index不符合才退出循环，所以应该将要插入的数字放到他后边，若没有比他小的数字时，此时index应为-1，所以将要插入的数字放到第一位即index+1=0的位置上。//拿a[i]与a[i-1]的前面数组比较，当前面的数字下标大于等于0并且该数字大于要插入的数时，将该数字向后移动，并将下标往前移动一位，继续比较，知道有数字比要插入的数字小或者当下标为-1时（即没有比该数字小的数）退出循环。...
java基础题数组_Java基础题——二维数组
weixin_28785681的博客
02-24 300
问题描述随机产生一个5x5的二维数组(输出的数字必须大于零，小于十)问题： 输出该随机数组1.求出对角线上的数字总和(注意交点上的数字不能重复计算)2.将数组对角线上的数字换成【*】样列：// 1 6 6 6 6// 1 2 3 4 5// 1 6 5 4 3// 1 2 2 2 2// ...
一维数组 ——Java
weixin_66598341的博客
07-24 2986
数组是一种数据结构，是存放一组相同数据类型的数据的容器，可以通过操作数组对数据进行增删改查。数组是引用数据类型，初始化后开辟的空间在内存中是连续的，并且数组一旦初始化后，长度是不可改变的（数组不可直接扩容或者删除），不过可以改变数组中的元素。元素是存入数组的数据，元素在数组中的下标从0开始。本文仅仅简单介绍了一维数组，更多操作数组的方法可以通过查询API文档进行学习探索。......
Java基础篇——数组
Flychuer的专栏
08-28 371
1、什么是数组 2、一维数组 2.1、声明和创建 2.2、初始化 2.3、遍历 2.4、内存分析 3、二维数组 3.1、声明和创建 3.2、初始化 3.3、遍历 3.4、内存分析 4、多维数组
java数组基本要素_Java基础篇——数组详解
weixin_39708854的博客
02-16 1069
项目开发中，如果需要存储大量的数据，例如如果需要读取100个数，那么就需要定义100个变量，显然重复写100次代码，是没有太大意义的。Java语言提供了数组(array)的数据结构，可以解决这个问题。数组的概念一个数组是相同数据类型的元素按一定顺序排列的集合。使用数组可以将同一类型的数据存储在连续的内存位置。数组中各元素的类型相同，通过下标的方式来访问数组中的元素，下标从0开始。由此得出，数组具有...
Java基础——数组
explorer363的博客
04-18 6903
本篇文章介绍了什么是数组，数组的使用，数组与方法之间的关系，以及通过几个数组联系加深对数组的理解
JAVA基础——数组、面向对象
weixin_56451428的博客
02-15 888
JAVA基础包含数组+面向对象。视频学习参考狂神说java
JAVA基础篇——6.2 数组
m0_54587903的博客
03-11 82
JAVA基础——数组 数组的定义，声明，数组作为参数传入方法
Java基础篇4——数组
qq_43842093的博客
09-01 149
Java基础篇4——数组 1、数组的概念 当需要在Java程序中记录单个数据内容时，则声明一个变量即可 当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数 组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元 数组是相同数据类型的多个元素的容器，元素按线性顺序排列，在Java语 言中体现为一种引用数据类型 2、一维数组的声明 2.1、一维数组的声明 数据类型[] 数组名称 = new 数据类型[数组的长度]; 数据类型[] 数组名称 = {初始值1, 初始值2, ...};
Java语言程序设计——基础篇
10-17
根据提供的信息，“Java语言程序设计——基础篇”这本书主要针对初学者介绍了Java编程的基础知识。虽然部分内容并未给出具体章节或细节信息，但基于书名、描述及常见的Java基础教程内容，我们可以推测书中涵盖的主要...
java数组排序
09-04
在Java编程语言中，数组排序是一项基础且重要的任务。它涉及到不同的算法，这些算法通过比较和交换元素来达到数组元素的有序状态。本篇将详细探讨几种常见的排序算法及其在Java中的实现。 首先，让我们从最简单的...
大数据开发成长之路——Java基础（一）
12-22
在大数据开发中，理解和掌握这些Java基础知识是必要的，因为它们构成了编写高效、可靠的分布式程序的基础。随着学习的深入，还会接触到更多高级概念，如集合框架、多线程、网络编程以及大数据相关的API和框架。不断...
大数据开发成长之路——Java基础（四）
12-21
本篇文章将深入探讨Java集合框架，这是Java编程中极为重要的一个部分，对于大数据开发者来说，掌握这部分知识至关重要。 Java集合是用来存储对象的容器，它允许存放不同类型的元素，并且不限制数量。集合框架主要...
Java工程师成神之路（基础篇）.zip
08-15
《Java工程师成神之路（基础篇）》是阿里云开发者社区历经五年精心打造的一部Java学习宝典，旨在为Java初学者提供一个全面且深入的知识框架。这本书详细讲解了Java编程语言的基础概念、语法和核心特性，是每一位志在...
枚举工具类
qq_43049583的博客
08-04 269
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 315
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
深入理解Java注解
weixin_55745942的博客
08-01 659
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 644
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 596
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木头科技

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值