Java基础篇四_数组

最新推荐文章于 2023-11-05 17:34:36 发布
最新推荐文章于 2023-11-05 17:34:36 发布
阅读量172 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46601365/article/details/115471307
版权

Java数组

数组的定义

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

数组声明创建

  • 首先必须声明数组变量，才能在程序中使用，声明数组变量的语法如下

    dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[]; //效果相同，但不是首选的方法

  • Java语言使用new操作符来创建数组，语法如下：

    dataType[] arrayRefVar = new dataType[arraySize];

  • 数组元素是通过索引访问的，数组索引从0开始

  • 获取数组长度：

    arrays.length

package com.keke.array;

/**
 * @ClassName: Demo01
 * @Description:
 * @Author: keke
 * @Date: 2021/4/5
 */
public class Demo01Array {
    //定义变量通用公式：变量类型   变量名字   =   变量的值
    //数组的定义：      数组类型
    public static void main(String[] args) {
        int[] nums; //1.声明一个数组

        nums = new int[10]; //2.创建一个数组

        //3.给数组元素赋值，int类型数组若不赋值初始值就是0
        for (int i = 1; i <= 10; i++) {
            nums[i-1] = i;
        }

        System.out.println(nums[0]);

        System.out.println(nums[10]); //java.lang.ArrayIndexOutOfBoundsException，数组下标越界错误

        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }

        System.out.println("总和为：" + sum);
    }

}

Java内存分析

  1. 栈空间（stack），连续的存储空间，遵循后进先出的原则，用于存放基本类型的变量和引用变量。

  2. 堆空间（heap），不连续的空间，用于存放new出的对象，或者说是类的实例。

  3. 方法区（method），方法区在堆空间内，用于存放

    ①类的代码信息；

    ②静态变量和方法；

    ③常量池（字符串常量池[只有一个，被所有类共享]等）

上面代码简单的内存分析：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XCCAIldnimg.cn/2021040693998)(E:\5.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6LyuibG9nLmNzZG4ubmV0L3FxXzQ2NjAxMzY1,size_16,color_FFFFFF,t_70#pic_centeri
n\微信图片_20210405193835.jpg)]

数组三种初始化

  • 静态初始化
int[] a = {1,2,3};
Man[] mans = {new Man(1,1), new Man(2,2)};
  • 动态初始化
int[] a = new int[2];
a[0] = 1;
a[1] = 2;

  • 数组的默认初始化

    数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

  • 使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下：
    如果是整数类型（int,byte,short,long），默认为0；
    如果是浮点类型（float,double），默认为0.0；
    如果是字符类型（char），默认为’\u0000’；
    如果是布尔类型（boolean），默认为false；
    如果是引用类型（除了八大基本数据类型），默认为null；
    注：静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值

package com.keke.array;

/**
 * @ClassName: Demo01
 * @Description:
 * @Author: keke
 * @Date: 2021/4/5
 */
public class Demo02Array {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5,6,7,8};
        Man[] mans = {new Man(), new Man()};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        b[1] = 10;

        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]); //b[2]即被默认初始化
        System.out.println(b[3]);

    }

}

数组的四个基本特点

  • 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
  • 其元素必须是相同类型，不允许出现混合类型
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  • 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
  • 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组使用

  • 普通的for循环

  • For-Each循环

  • 数组作方法入参

  • 数组作返回值

package com.keke.array;

/**
 * @ClassName: Demo03Array
 * @Description:
 * @Author: keke
 * @Date: 2021/4/5
 */
public class Demo04Array {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};

        //JDK1.5 没有下标，仅适用于数组和集合
//        for (int array : arrays) {
//            System.out.println(array);
//        }

//        printArray(arrays);

//        printArray(reverseArray(arrays));

        printArray(reverseArray2(arrays));

    }

    //打印数组元素的方法
    public static void printArray(int[] arrays) {
        for (int array : arrays) {
            System.out.print(array + " ");
        }
    }

    //反转数组，不定义新的数组
    public static int[] reverseArray(int[] arrays) {
        int j = arrays.length - 1;
        for (int i = 0; i < arrays.length; i++) {
            if (i >= j) {
                break;
            }
            int tem = arrays[i];
            arrays[i] = arrays[j];
            arrays[j] = tem;
            j--;
        }
        return arrays;
    }

    //反转数组，定义新的数组
    public static int[] reverseArray2(int[] arrays) {
        int[] result = new int [arrays.length];

        //反转的操作
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }

        return result;
    }

}

数组作参数或者返回值

数组作参数

package cn.itcast.day04.demo03;
/*
* 任何数据类型都可以当作参数
* 数组可以作为方法的参数
* 当调用方法的时候，向方法的小括号进行传参，传递进去的是地址值
* */
public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] array = {10,20,30,40,50};
        System.out.println(array);   //地址值

        printArray(array);     //传递进去的就是array当中保存的地址值
        System.out.println("===============");
        printArray(array);
        System.out.println("===============");
        printArray(array);
    }
    public static void printArray(int[] array){
        System.out.println("printArray方法收到的参数是：");
        System.out.println(array);   //地址值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

数组作返回值

package cn.itcast.day04.demo03;
/*
* 一个方法可以有0,1，多个参数；但是只能有0或者1个返回值，不能有多个返回值
* 如果希望一个方法当中产生了多个结果数据进行返回，怎么办？
* 解决方案：使用一个数组作为返回值类型即可
*
* 任何数据类型作为方法的参数类型，或者返回值类型
* 数组作为方法的参数，传递进去的其实是数组的地址值
* 数组作为方法的返回值，返回的其实也是数组的地址值
* */
public class Demo02ArrayReturn {
    public static void main(String[] args) {
        int [] result = calculate(10,20,30);
        System.out.println("main方法接收到的返回值数组是：");
        System.out.println(result);   //地址值
        System.out.println("总和:" + result[0]);
        System.out.println("平均数:" + result[1]);
    }
    public static int[] calculate(int a,int b,int c){
        int sum = a + b + c;  //总和
        int avg = sum/3;  //平均数

        //两个结果都希望进行返回
        //需要一个数组，保存多个结果
        /*int[] array = new int[2];
        array[0] = sum;
        array[1] = avg;*/
        int[] array = {sum,avg};
        System.out.println("calculate方法内部数组是：");
        System.out.println(array); //地址值
        return array;
    }
}

多维数组

  • 多维数组可以看成数组的数组，比如二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组

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

    图解plus：

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210406212041872.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjAxMzY1,size_16,color_FFFFFF,t_array;
}
}




## 多维数组

- 多维数组可以看成数组的数组，比如二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组

  图解：

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OW9hPCrM-1618577717505)(E:\tupian\微信图片_20210405205515.jpg)]

  图解plus：

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cdnrmshE-1618577717507)(E:\tupian\微信图片_20210405210234.jpg)]

- 二维数组

  ```java
  int a[][] = new int[2][5];

  • 解析：以上二维数组a可以看成一个两行五列的数组

  • 思考：多维数组的使用？

package com.keke.array;

/**
 * @ClassName: Demo03Array
 * @Description:
 * @Author: keke
 * @Date: 2021/4/5
 */
public class Demo05Array {
    public static void main(String[] args) {
        //定义了一个4行2列的数组 [4][2]
        /*
        * 数组存入的数据
        * 1,2   array[0]
        * 2,3   array[1]
        * 3,4   array[2]
        * 4,5   array[3]
        * */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

//        System.out.println(array[0]); //[I@7a7b0070 输出了一个对象

//        printArray(array[0]);

//        System.out.println(array[0][0]); //1
//        System.out.println(array[0][1]); //2
//
//        System.out.println(array.length); //4
//        System.out.println(array[0].length); //2

        //输出多维数组的全部元素
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
        
    }

    //打印数组元素的方法
    public static void printArray(int[] arrays) {
        for (int array : arrays) {
            System.out.print(array + " ");
        }
    }

}

Arrays类

  • 数组的工具类java.util.Arrays

  • 由于数组对象本身并没有什么方法可以调用，但API中提供了一个工具类Arrays供使用，从而可以对数据对象进行一些基本的操作

  • Arrays类中的方法都是static修饰的静态方法，在使用时可以直接用类名进行调用，不用创建对象调用（注意是不用不是不能）

  • 具有以下常用功能：

    给数组赋值：fill方法

    对数组排序：sort方法，按升序

    ​ 备注：

    ​ 1.如果是数值，sort默认按照升序从小到大

    ​ 2.如果是字符串，sort默认按照字母升序

    ​ 3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator的支持 （今后学习）

    比较数组：equals方法，比较数组中元素值是否相等

    查找数组元素：binarySearch方法，能对排序好的数组进行二分查找法操作

    打印数组元素：toString将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3…]）

    注：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。简单例子：就是比如一个升序排列的数据类型为int的数组，查找某个元素，先将该元素与数组中间位置数据进行比较，如果相等即找到，不相等判断大于还是等于数组中间位置数据，若大于即向后继续用二分查找，若小于即向前继续用二分查找。

package com.keke.array;

import java.util.Arrays;

/**
 * @ClassName: Demo06Arrays
 * @Description:
 * @Author: keke
 * @Date: 2021/4/5
 */
public class Demo06Arrays {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9090,32131,543,21,3,23};
        System.out.println(a); //[I@1b6d3586

        //打印数组元素 Arrays.toString
//        System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 9090, 32131, 543, 21, 3, 23]

//        printArray(a);

//        Arrays.sort(a); //数组进行排序，升序
//        System.out.println(Arrays.toString(a));

//        Arrays.fill(a, 1); // 数组填充：把数组中所有元素全部改为1
//        Arrays.fill(a, 2, 4, 1); //只有第2个和第4个元素会被1填充
//        System.out.println(Arrays.toString(a));

        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        int i = Arrays.binarySearch(a, 23); //返回数字所在数组的索引值
        System.out.println(i);

    }

    //自定义打印数组元素的方法
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i==0) {
                System.out.print("[");
            }
            if (i==a.length - 1) {
                System.out.print(a[i] + "]");
            } else {
                System.out.print(a[i] + ", ");
            }
        }
    }

}

冒泡排序

  • 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序
  • 冒泡排序：它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
  • 冒泡排序代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖人尽皆知
  • 看到嵌套循环，立马可以得出这个算法的时间复杂度为O(n2)
  • 思考：如何优化？
package com.keke.array;

import java.util.Arrays;

/**
 * @ClassName: Demo07Array
 * @Description:
 * @Author: keke
 * @Date: 2021/4/5
 */
public class Demo07Array {
    public static void main(String[] args) {
        int[] a = {1,3,4,6,7,483,19,90,13,6};
//        int[] sort = sort(a);
        int[] sort = sortPlus(a);
        System.out.println(Arrays.toString(sort));
    }

    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
    //2.每一次比较，都会产生一个最大，或者最小的数字
    //3.下一轮则可以少一次排序
    //4.依次循环，直到结束

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;

        //外层循环，判断我们这个要排序多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，比较两个数，如果第一个数比第二个数大，则交换位置
            //-i表示下一次排序会比上一次排序少一次，因为经过一轮排序后最大的值一定就放在最后面
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j+1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }

        return array;
    }

    //冒泡排序优化
    public static int[] sortPlus(int[] array) {
        //临时变量
        int temp = 0;

        //外层循环，判断我们这个要排序多少次
        for (int i = 0; i < array.length - 1; i++) {

            boolean flag = false; //通过flag标识位减少没有意义的比较

            //内层循环，比较两个数，如果第一个数比第二个数大，则交换位置
            //-i表示下一次排序会比上一次排序少一次，因为经过一轮排序后最大的值一定就放在最后面
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j+1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }

            //说明已经排序成功了，故无需在排序
            if (!flag) {
                break;
            }
        }

        return array;
    }


}

扩展：稀疏数组(一种数据结构)

引入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gRn36OGV10,text_aHR0cHMLy9ibG9nLmNzZG4ubmV0L3FxXzQ2NjAxMzY618577717,size_E6,color_FFFFFF,t_:0#pic_centerp
an\20210125165852520.png)]

介绍

  • 当一个数组中大部分元素都为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
  • 稀疏数组的处理方式：

​ 记录数组一共有几行几列，有多少个不同值

​ 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

  • 如下图：左边是原始数组，右边是稀疏数组

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uFGXdJ2Q-1618577717518)(E:\tupian\src=http___img2020.cnblogs.com_blog_1714745_202003_1714745-20200304231826867-1062206901.jpg&refer=http___img2020.cnblogs.jpg)]

练习

将引入中的数组转换为稀疏数组和将稀疏数组还原为原始数组

package com.keke.array;

import javax.sound.midi.Soundbank;

/**
 * @ClassName: Demo08Array
 * @Description: 将引入中的数组转换为稀疏数组和将稀疏数组还原为原始数组
 * @Author: keke
 * @Date: 2021/4/6
 */
public class Demo08Array {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11     0：没有棋子，1：黑棋，2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        //输出原始的数组
        System.out.println("原始的数组");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        System.out.println("=======================================");

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }

//        System.out.println("有效值的个数:" + sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值，存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");

        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
        }

        System.out.println("=======================================");

        //还原为原始的数组
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //3.打印
        System.out.println("输出还原的数组");

        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

    }
}
Query*
关注
专栏目录
java android 数组_Android开发基础之Java 数组
weixin_30240263的博客
02-16 534
Java 数组数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。Java 语言中提供的数组是用来存储固定大小的同类型元素。你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。本教程将为大家介绍 Java 数组的声明、创建和初始化，并给出其对应的代码。声明数组变...
float数组 java,写一个float数组在Java中的文件
weixin_35411487的博客
02-12 474
I'm reading in a NetCDF file and I want to read in each array as a float array and then write the float array to a new file. I can make it work if I read in the float array and then iterate over each...
Java基础篇_数组
最新发布
m0_73620971的博客
11-05 1180
数组可以看成是相同类型元素的一个集合，在内存中是一段连续的空间，每个空间都有自己的编号，起始位置的编号是0，即数组的下标。
java 数组成员_java数组基础
weixin_42310670的博客
02-12 776
java中的数组是引用数据类型。//在栈空间声明数组引用对象int[] NAME;int NAME[]; //中括号放哪边都是等价的className[] NAME;//在堆空间划分数组空间并初始化数组对象NAME = new int[3];NAME = new className[3]//赋值,在堆空间中填充每个数组成员NAME[0]=0;NAME[1]=1;...className[0]...
java数组基本要素_Java基础篇——数组详解
weixin_39708854的博客
02-16 1080
项目开发中，如果需要存储大量的数据，例如如果需要读取100个数，那么就需要定义100个变量，显然重复写100次代码，是没有太大意义的。Java语言提供了数组(array)的数据结构，可以解决这个问题。数组的概念一个数组是相同数据类型的元素按一定顺序排列的集合。使用数组可以将同一类型的数据存储在连续的内存位置。数组中各元素的类型相同，通过下标的方式来访问数组中的元素，下标从0开始。由此得出，数组具有...
Java基础篇：数组
热门推荐
张维鹏的博客
10-10 3万+
数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。 在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长
【Java基础篇】Java 数组
输入技术、输出想法
05-22 7368
Java 数组Java 数组声明数组变量创建数组处理数组For-Each 循环数组作为函数的参数数组作为函数的返回值多维数组多维数组的动态初始化（以二维数组为例）多维数组的引用（以二维数组为例）Arrays 类 Java 数组 数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。 Java 语言中提供的数组是用来存储固定大小的同类型元素。 声明数组变量 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar
java的数组的扩展_数组在java中的扩容的实例方法
weixin_34861192的博客
02-24 896
在使用数组的时候，因为大小的限制，难免会出现不够用的现象。直接给数据对象扩容是不可行的，这时候就需要我们找寻一些其他的方法。本篇先为大家简单分析扩容的原理，然后创建一个数组供大家使用，最后提供两种数组扩容方法：for循环和Arrays，下面一起来看具体的操作。1.扩容的原理(1)Java数组对象的大小是固定不变的，数组对象是不可扩容的。(2)利用数组复制方法可以变通的实现数组扩容。(3)Syste...
【Java基础篇】函数,数组
输入技术、输出想法
05-22 1068
函数,数组1. 函数的定义1.1 什么是函数？1.2 函数的格式2. 函数的特点3. 函数的应用4. 函数的重载(overload)5. 数组5.1 数组的定义5.2 数组的内存结构5.3 内存结构5.4 数组常见问题5.5 数组常见操作5.6 数组中的数组(二维数组[][]) 1. 函数的定义 1.1 什么是函数？ 函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。 1.2 函数的格式 修饰符 返回值类型 函数名(参数类型形式参数1，参数类型形式参数2，) { 执行语句; return 返
Java入门篇--数组（一）
luoyuhhh的博客
11-11 531
Java数组基础知识
Leecode初级算法_数组篇_实例
03-14
本资料“LeetCode初级算法_数组篇_实例”是针对LeetCode平台上的初级算法，通过Java语言来实现的数组相关问题的解题代码集合。LeetCode是一个流行的在线编程挑战平台，它提供了一系列的算法题目，旨在帮助程序员提升...
java基础教程.zip_Java编程_Java__Java编程_Java_
08-09
这篇"Java基础教程"针对初学者，旨在提供全面的Java入门知识。以下是对教程内容的详细概述： 1. **Java简介**：Java是由Sun Microsystems（现为Oracle Corporation）于1995年发布的，它的设计目标是“一次编写，...
Java中高效的判断数组中某个元素是否存在详解
09-01
这篇文章主要探讨了四种不同的方法来实现这个功能，并分析了它们的时间复杂度。以下是这四种方法的详细解释： 1. 使用`List.contains()`： 这种方法是通过将数组转换为`List`，然后调用`contains()`方法来检查目标...
JAVA基础篇——6.2 数组
m0_54587903的博客
03-11 93
JAVA基础——数组 数组的定义，声明，数组作为参数传入方法
spingboot默认日志系统LogBack、Log4j和slf4j使用详解
qq_46601365的博客
04-02 1万+
spingboot默认日志系统LogBack、Log4j和slf4j使用详解 spingboot默认日志系统LogBack 依赖引入 Spring Boot默认使用LogBack日志系统，如果不需要更改为其他日志系统如Log4j2等，则无需多余的配置，LogBack默认将日志打印到控制台上。 如果要使用LogBack，原则上是需要添加dependency依赖的 <groupId>org.springframework.boot</groupId> <artifactId>
MybatisPlus的UpdateWrapper和QueryWrapper的区别
qq_46601365的博客
03-21 6907
MybatisPlus的UpdateWrapper和QueryWrapper的区别 查询 测试代码 @Test public void testWrapper(){ LambdaQueryWrapper<Picture> lambdaQueryWrapper = new LambdaQueryWrapper<>(); lambdaQueryWrapper.eq(Picture::getEnterpriseCode, "FASTECH_DEV"); lambda
从prometheus生态系统组件到集成Java开发
qq_46601365的博客
08-15 2597
Prometheus是最初在SoundCloud上构建的开源系统监视和警报工具包。于2016年加入了 Cloud Native Computing Foundation，这是继Kubernetes之后的第二个托管项目。Prometheus 其实就是一个数据监控解决方案，它能帮你简单快速地搭建起一套可视化的监控系统。...
Vmware vSphere最实用的入门级教程
qq_46601365的博客
09-29 2538
vSphere 是在数据中心产品下的一套软件，vSphere 类似微软的 Office 办公套件，Office 办公套件包含了许多软件如 Word, Excel, Access 等，和Office 一样，vSphere 也是一个软件的集合，他包括了 vCenter, ESXi 和vSphere client 等。ESXi 是 vSphere 中最重要的一个组件。ESXi 是虚拟化服务，所有的虚拟机都是运行在 ESXi 服务上面。
neo4j整合springboot实现基础的增删改查
qq_46601365的博客
06-15 1520
neo4j整合springboot实现基础的增删改查 项目搭建 pom.xml 注意：这里使用的springboot2.3.2.RELEASE，jdk1.8，Neo4j Server version：3.5.28 (community)，不同版本可能存在冲突问题，需要注意。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://w
Java基础：深入理解数组参数
"这篇资料是关于Java基础知识的课程，特别是关于数组的讲解。内容涵盖了数组的概念、声明、创建、初始化、作为参数使用以及多维数组的介绍。" 在Java编程中，数组是一种非常重要的数据结构，它允许我们存储一组相同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值