由浅到深认识Java语言（8）：数组&二维数组

已于 2024-03-31 18:33:40 修改
阅读量885 收藏 28
点赞数 27
分类专栏： Java语言基础 文章标签： java 开发语言 笔记
于 2024-03-21 09:10:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AntonyCheng/article/details/136895951
版权

该文章Github地址：https://github.com/AntonyCheng/java-notes【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】

在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】& CSDN文章地址：https://blog.csdn.net/AntonyCheng/article/details/136555245），该模板集成了最常见的开发组件，同时基于修改配置文件实现组件的装载，除了这些，模板中还有非常丰富的整合示例，同时单体架构也非常适合SpringBoot框架入门，如果觉得有意义或者有帮助，欢迎Star & Issues & PR！

上一章：由浅到深认识Java语言（7）：方法（函数）

15.数组

定义：数组 == 容器

  • 组就是指多个的意思，在之前我们的代码中使用的数据类型都是单个的，为了将多个相同类型的数据存储在一起，这时候就引出了组的概念；
  • 数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器；
  • 数组可以存储基本数据类型，也可以存储引用将数据类型；
  • 数组是 Java 中的唯一底层存储容器；

创建数组

基本格式一：

int[] arr = new int[10];
数据类型[] 数组名 = new 数据类型[容量值];

基本格式二：

int arr[] = new int[10];

容量值：

创建一个存放多个元素的容器（内存要开辟这样的空间来存放多个元素，关键在于内存开辟多大的空间给你？）

例如：

int a = 10;  				32位
int[] arr = new int[4];		32*4位

示例：创建一个存放五个 double 的数据；

double[] arr = new double[5];

数组底层的存储模样：

数组在底层是一个连续的空间；

内存中任何任何一个空间都会有自己的地址，那么将连续的第一位的地址称为首地址，在使用时通过首地址来找到这篇空间；

数组名中将会存放 jvm 开辟的这篇空间的首地址；

使用数组

Q : Q: Q: 如何指定数组连续空间中具体的某一个元素？

A : A: A: 通过数组的下标：是从 0 开始的一个数； arr[0] 指定的是数组的第一个元素；

下标的使用规范：

下标从 0 开始，最多到 数组长度 - 1

数组的长度：

任何一个数组，都有一个 length 属性，用于标识数组的长度： arr.length

import java.util.*;
class demo{
    public static void main(String[] args){
        int arr[] = new int[100];
        System.out.println(arr.length);
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

数组的遍历：

import java.util.*;
class demo{
    public static void main(String[] args){
        int arr[] = new int[10]; //数组的创立
        for(int i=1; i<11; i++){
            arr[i-1] = i;
        }  //数组的赋值
        for(int j=0; j<arr.length; j++){
            System.out.print(arr[j] + " ");
        }  //数组的遍历
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实例演示

实例一：

键盘输入15个学生的年龄，查找固定年龄的学生的位置；

import java.util.*;
class demo{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入十五个学生的年龄：");
        int age[] = new int[15];
        for (int i = 0; i < age.length; i++){
            age[i] = scanner.nextInt();
        }
        System.out.println("请指定要查询的年龄：");
        int staticAge = scanner.nextInt();
        for (int j = 1; j < age.length+1; j++){
            if(age[j-1] == staticAge){
                System.out.println("第"+j+"位");
            }
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实例二：

键盘输入 10 个数，并且求出最大值；

import java.util.*;
class demo{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int arr[] = Arr();
        System.out.println("你输入的数组是：");
        for (int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        System.out.println("请问你要比较的是这个数组么？（是/否 = 1/0）");
        int agree = scanner.nextInt();
        if (agree == 1){
            int max = arr[0];
            for(int j=0; j<arr.length; j++){
                if (max <= arr[j]){
                    max = arr[j];
                }
            }
            System.out.println(max);
        }else if (agree == 0){
            System.out.println("请重新运行程序！");
        }else{
            System.out.println("输入错误，请重新运行程序！");
        }
    }
    public static int[] Arr(){
        Scanner scanner = new Scanner(System.in);
        int arr[] = new int[10];
        System.out.println("请输入十个整数(用空格隔开)：");
        for(int i=0; i<arr.length; i++){
            arr[i] = scanner.nextInt(); 
        }
        return arr;
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实例三：

用空方法的方式实现两值互换，要求方法中不能有打印动作；

该实例解释在 数组的参数传递 一节；

错误示范：

import java.util.*;
class demo{
    public static void main(String[] args){
        int a = 1;
        int b = 2;
        changeNumb(a,b);
        System.out.println(a+" "+b);
    }
    public static void changeNumb(int a,int b){
        int t = a;
        a = b;
        b = t;
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

正确示范：

import java.util.*;
class demo{
    public static void main(String[] args){
        int a = 1;
        int b = 2;
        int arr[] = new int[] {a,b};
        changeNumb(arr);
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static void changeNumb(int[] a){
        int t = a[0];
        a[0] = a[1];
        a[1] = t;
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实例四：

用空方法的方式实现求最大值，要求方法中不能有打印动作；

import java.util.*;
class demo{
    public static void main(String[] args){
        int[] arr = new int[10];
        setNum(arr);
        maxNum(arr);
    }
    public static void setNum(int[] arr){
        Random rand = new Random(); //随机获得一个随机对象
        for(int i=0; i<arr.length; i++){
            arr[i]= rand.nextInt(1000); //rand.nextInt(1000)会产生0-999随机数
        }
    }
    public static void maxNum(int[] arr){
        int t = arr[0];
        for(int i=0; i<arr.length; i++){
            if(t<=arr[i]){
                t = arr[i];
            }
        }
        System.out.println(t);
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实例五：

数组内容反转；

import java.util.*;
class demo{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您要操作的数字个数：");
        int num = scanner.nextInt();
        int arr[] = new int[num];
        System.out.println("请输入所要操作的"+num+"位整数：");
        for (int i = 0; i < arr.length; i++){
            arr[i] = scanner.nextInt();
        }
        System.out.println("你的数组是：");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        System.out.println("反转后：");
        for (int i = 0; i< arr.length; i++){
            if(arr.length%2==0){
                if(i<(arr.length/2)){
                    int t = arr[i];
                    arr[i] = arr[arr.length - 1 - i];
                    arr[arr.length - 1 - i] = t; 
                }else{
                    break;
                }
            }else if(arr.length%2!=0){
                if(i<((arr.length-1)/2)){
                    int t = arr[i];
                    arr[i] = arr[arr.length - 1 - i];
                    arr[arr.length - 1 - i] = t; 
                }else{
                    break;
                }
            }
        }
        for (int i = 0; i< arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实例六：

求俩数的最大公约数和最小公倍数；

import java.util.*;

public class demo {
	public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入两个数，求他们的最大公约数和最小公倍数！");
        System.out.println("输入两数中第一个数：");
        int m = scanner.nextInt();
        System.out.println("输入两数中第二个数：");
        int n = scanner.nextInt();
        if(m>n){
            int arr[] = new int[m]; 
            for(int i=1;i<(m+1);i++){
                if(m%i==0&&n%i==0){
                    arr[i] = i;
                }
            }
            Arrays.sort(arr);
            int max = arr[m-1];
            System.out.println("最大公约数是"+max);
            int min = (m*n)/max;
            System.out.println("最小公倍数是"+min);
        }else if(m<n){
            int arr[] = new int[n]; 
            for(int i=1;i<(n+1);i++){
                if(m%i==0&&n%i==0){
                    arr[i] = i;
                }
            }
            Arrays.sort(arr);
            int max = arr[n-1];
            System.out.println("最大公约数是"+max);
            int min = (m*n)/max;
            System.out.println("最小公倍数是"+min);
        }else{
            System.out.println("最大公约数是"+n);
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

总结

  • 数组是一片连续的内存空间，用来存放多个元素；
  • 数组的创建需要考虑两个方面：数据类型，长度；
  • 数组通过下标（索引）来定位到这个连续空间中的某一个具体的空间；
  • 下标从 0 开始，最多到 数组的长度 - 1；
  • 任何数组都有一个 length 属性，方便我们在循环中使用；

其他细节

数组的初始化

  1. 动态初始化

    先开辟好空间，里面元素是默认值，并没有填入我们要填的值，等使用时再填入，这是一个动态的过程；

    int arr[] = new int[10];

  2. 静态初始化

    在创建数组时，直接给数组里的每一个空间的赋值；

    //方法一
int arr[] = new int[]{1,2,3,4,5};
//注意中括号里面没有数字（长度）;

//方法二
int arr[] = {1,2,3,4,5};

//方法三
int arr[];
arr = new int[]{1,2,3,4,5}
//注意以下这样不行：
int[] arr;
arr = {1,2,3,4,5};

数组中数据类型的默认值

byte short int long 的默认值都为 0；

float double 的默认值都为 0.0；

char 的默认值为 ' '（空格字符）；

boolean 的默认值为 false；

String 的默认值为 null；

数组的参数传递

当方法中的参数是传递数组时，传递的是地址值，就是数组指向的那一块内存空间的首地址；

基本数据类型在方法中进行参数传递时，传的是具体的值；

Arrays工具类

Arrays.toString();

打印数组；

此处的Arrays.toString()方法是Arrays类的静态方法；

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = { 1, 2 };
        System.out.println(a); // 打印数组引用的值；
        System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Arrays.equals(int[] a, int[] a2);

比较两个数组是否相同；

import java.util.*;
class demo{
    public static void main(String[] args){
        int [] arrA={23,34,345,234};
        int [] arrB={23,34,345,234};
        //两个数组以相同的顺序包含相同的元素
        System.out.println(Arrays.equals(arrA, arrB));//true
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Arrays.copyOf(int[] original, int newLength);

复制指定的数组—效率低，会重新开辟新的数组空间original - 要复制的数组;newLength - 要返回的副本的长度；

import java.util.*;
class demo{
    public static void main(String[] args){
        int [] arrA={23,34,345,234};
        int [] arrB=new int[5];//默认值0
        System.out.println("拷贝前："+arrB);
        System.out.println(Arrays.toString(arrA));
        arrB=Arrays.copyOf(arrA, 5);  //重新开辟空间
        System.out.println("拷贝后："+arrB);
        System.out.println(Arrays.toString(arrB));
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Arrays.fill(int[] a, int val)/Arrays.fill(int[] a, int fromIndex, int toIndex, int val);

填充数组；

import java.util.*;
class demo{
    public static void main(String[] args){
        int[] a= {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 100);  //将2到4索引的元素替换为100;前闭后开
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 55);
        System.out.println(Arrays.toString(a));
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Arrays.sort(int[] a);

对数组进行升序排序；

import java.util.*;
class demo{
    public static void main(String[] args){
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Arrays.binarySearch(int[] a, int key);

二分法查找；

import java.util.*;
class demo{
    public static void main(String[] args){
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);   //使用二分法查找，必须先对数组进行排序;
        System.out.println(Arrays.toString(a));
        //返回排序后新的索引位置,若未找到返回负数。
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 12)); 
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

可变参数

在定义方法时，允许实参的个数是任意的，但是数据类型是固定的，那么这时就可以使用可变参数；

基本格式：

public static void m1(int...args){

}

在调用方法时，无论多少个参数，都会传给 args 数组，也就是说， args 数组里存放了所有的实参；

注意：在定义方法时，可变参数要写在所有方法之后；

示例如下：

import java.util.*;
class demo{
    public static void main(String[] args){
        m1(1,2,3,4,5,6,7,8,9);
    }
    public static void m1(int a,int b,int c,int... args){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(args);
        System.out.println(Arrays.toString(args));
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

16.二维数组

创建数组

基本格式：

//方法一：
int[][] arr = new int[4][3];

//方法二：
int arr[][] = new int[4][3];

//方法三：
int arr[][] = new int[4][];
arr[0] = new int[3]
arr[1] = new int[3]    
arr[2] = new int[3]    
arr[3] = new int[3]

使用数组

调用二维数组中的某一空间：使用双下标确定数据位置arr[3][1]；

下标是从 0 开始，最多是 数组的长度 - 1；

数组的长度：

  1. 一维数组是 arr.length；
  2. 二维数组是 arr[1].length；

二维数组的遍历：

多用双层循环进行遍历，外层循环行数，内层循环列数；

示例如下：

全班一共有4个小组，每个小组有3个人；

import java.util.*;
class demo{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String[][] students = new String[4][3];
        // 元素的堆放
        System.out.println("请输入每一组学生的具体名称：");
        for(int i = 0; i < students.length; i++){
            System.out.println("第"+(i+1)+"组：");
            for(int j = 0; j < students[1].length; j++){
                students[i][j] = scanner.next();
            }
        }
        // 元素的遍历
        System.out.println("您的班级成员如下：");
        for(int k = 0; k < students.length; k++){
            for (int l = 0; l < students[k].length; l++){
                System.out.print(students[k][l]+"   ");
            }
            System.out.println();
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

动态初始化

//方法一
int[][] arr = new int[3][5];

//方法二
int[][] arr = new int[3][]; 
//此时内存只开辟了一维数组，这个一维数组里面的每个元素是用来存放另一个数组的地址;
//目前第二维数组还没创建，因此里面存放的是 null;

//方法三
int arr[][] = new int[3][5];

//方法四
int arr[][] = new int[3][];

“方法二”实例：

import java.util.*;
class demo{
    public static void main(String[] args){
        int[][] arr = new int[3][];
        arr[0] = new int[3];
        arr[1] = new int[5];
        arr[2] = new int[7];
        for(int i=0; i<arr.length; i++){
            System.out.println(Arrays.toString(arr[i]));
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实例：

一个班级有35名同学，
第一组有5名，位置分别为 A1 , A2 , A3 , A4 , A5；
第二组有6名，位置分别为 B1 , B2 , B3 , B4 , B5 , B6；
第三组有7名，位置分别是 C1 , C2 , C3 , C4 , C5 , C6 , C7;
第四组有8名，位置分别是 D1 , D2 , D3 , D4 , D5 , D6 , D7 , D8；
第五组有9名，位置分别是 E1 , E2 , E3 , E4 , E5 , E6 , E7 , E8 , E9 ；
设计一个随机点名程序，学号均为 20010+组数+位置 的形式；

import java.util.*;
class demo{
    public static void main(String[] args){
        String[][] arr = new String[5][];
        arr[0] = new String[]{"A1" , "A2" , "A3" , "A4" , "A5"};
        arr[1] = new String[]{"B1" , "B2" , "B3" , "B4" , "B5" , "B6"};
        arr[2] = new String[]{"C1" , "C2" , "C3" , "C4" , "C5" , "C6" , "C7"};
        arr[3] = new String[]{"D1" , "D2" , "D3" , "D4" , "D5" , "D6" , "D7" , "D8"};
        arr[4] = new String[]{"E1" , "E2" , "E3" , "E4" , "E5" , "E6" , "E7" , "E8" , "E9"};
        System.out.println("您现在的班级成员如下：");
        for (int i = 0; i < arr.length; i++){
            System.out.print("第" +(i+1)+ "组：");
            for (int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j]+"  ");
            }
            System.out.println();
        }
        System.out.println("下面开始随机点名！学号是：");
        Random rand = new Random();
        int Arr = rand.nextInt(4);
        int a = rand.nextInt(4);
        int b = rand.nextInt(5);
        int c = rand.nextInt(6);
        int d = rand.nextInt(7);
        int e = rand.nextInt(8);
        if (Arr == 0){
            System.out.println("20010"+(Arr+1)+arr[Arr][a]);
        }else if(Arr == 1){
            System.out.println("20010"+(Arr+1)+arr[Arr][b]);
        }else if(Arr == 2){
            System.out.println("20010"+(Arr+1)+arr[Arr][c]);
        }else if(Arr == 3){
            System.out.println("20010"+(Arr+1)+arr[Arr][d]);
        }else{
            System.out.println("20010"+(Arr+1)+arr[Arr][e]);
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

静态初始化

基本格式：

//方法一：
int[][] arr = new int[][]{{1,2,3,4},{5,6,7},{8,9}};
//方法二：
int[][] arr = {{1,2,3,4},{5,6,7},{8,9}};

实例：

以点名程序为例，更改代码，再次执行；

import java.util.*;
class demo{
    public static void main(String[] args){
        String arr[][] = {{"A1" , "A2" , "A3" , "A4" , "A5"},{"B1" , "B2" , "B3" , "B4" , "B5" , "B6"},{"C1" , "C2" , "C3" , "C4" , "C5" , "C6" , "C7"},{"D1" , "D2" , "D3" , "D4" , "D5" , "D6" , "D7" , "D8"},{"E1" , "E2" , "E3" , "E4" , "E5" , "E6" , "E7" , "E8" , "E9"}};
        System.out.println("您现在的班级成员如下：");
        for (int i = 0; i < arr.length; i++){
            System.out.print("第" +(i+1)+ "组：");
            for (int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j]+"  ");
            }
            System.out.println();
        }
        System.out.println("下面开始随机点名！学号是：");
        Random rand = new Random();
        int Arr = rand.nextInt(4);
        int a = rand.nextInt(4);
        int b = rand.nextInt(5);
        int c = rand.nextInt(6);
        int d = rand.nextInt(7);
        int e = rand.nextInt(8);
        if (Arr == 0){
            System.out.println("20010"+(Arr+1)+arr[Arr][a]);
        }else if(Arr == 1){
            System.out.println("20010"+(Arr+1)+arr[Arr][b]);
        }else if(Arr == 2){
            System.out.println("20010"+(Arr+1)+arr[Arr][c]);
        }else if(Arr == 3){
            System.out.println("20010"+(Arr+1)+arr[Arr][d]);
        }else{
            System.out.println("20010"+(Arr+1)+arr[Arr][e]);
        }
    }
}

打印效果如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

下一章：由浅到深认识Java语言（9）：Eclipse IDE简介

AntonyCheng
关注
  • 27
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 二维数组去重_一位数组&二维数组&去重
weixin_32771907的博客
02-16 1734
1.二维数组的定义：int[][] counts=new int[10][];但是后面赋值的时候会报错，解决方法:counts[i]=new int[10];int[,] counts=new int[2,3];int[,] counts=new int[2,3]{{1,2,3},{3,2,1}}int[][] array2 = { };array2[0][0] = 1;//array2无值，所以...
java一维数组转二维数组_Java一维数组二维数组详解API
weixin_39951773的博客
02-15 2446
所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合，数组有一维数组，二维数组，...
Java: 一维数组&二维数组 foreach循环
e.g.:
03-30 2281
数组 1. 声明数组 // 格式：dataType[] arrayRefVar; double [] myArray; 2. 创建数组 //声明创建数组 dataType[] arrayRefVar = new dataType[arraySize]; dataType[] arrayRefVar = {value0, value1, ..., valuek}; 📍注意事项： 当数组采用动态初始化开辟空间后，数组里面的每一个元素都是该数组对应数据类型的默认值； Java 中提供有一种动态取得数
java byte 二维数组_Java基础之数组、二维数组
weixin_27645199的博客
02-13 1361
数组的概念：JAVA语言中提供的数组是用来存储类型相同的一组元素，数组分为一维数组和多维数组一维数组声明数组数组的声明和变量的声明是相同的，必须要先声明才能使用，声明之后jvm不会分配内存空间，只有实例化之后才会为数组分配内存空间。数组的声明有两种方式：数据类型[] 变量名；//这是Java声明数组首选的方法数据类型 变量名[]；//这是c语言声明数组的方式创建数组：一：1.声明数组2.实例...
Java中一维数组和二维数组的详解
路宇的博客
05-16 3534
一、数组的概述： 数组的理解：数组(Array),是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一的管理。 数组的相关概念。 2.1.数组名 2.2.元素 2.3.角标，下标，索引 2.4.数组的长度，元素的个数 数组的特点： 3.1.数组是有序排列的 3.2.数组属于引用数据类型的变量，数组的元素即可以是基本数据类型的变量，也可以是引用数据类型的变量。 3.3.创建数组对象会在内存中开辟一整块连续的空间 3.4.数组的长度一旦确定，就不能修改
Java编程一维数组转换成二维数组实例代码
08-28
Java编程一维数组转换成二维数组实例代码 Java编程语言中，数组是一种基本的数据结构，常用于存储和操作大量数据。在实际编程中，我们经常需要将一维数组转换成二维数组，以便于进行矩阵运算或其他数据处理。下面，...
java实现二维数组转json的方法示例
10-19
在Java编程中，将二维数组转换为JSON格式的数据是常见的数据处理需求，特别是在处理Web服务或数据交换时。本文将详细讲解如何使用Java实现这一功能，以及涉及的相关操作技巧。 首先，我们需要理解二维数组和JSON的...
Java数组的定义、初始化、及二维数组用法分析
08-26
Java数组的定义、初始化、及二维数组用法分析 Java数组是Java编程语言中的一种基本数据结构，用于存储同类型的多个元素。以下是Java数组的定义、初始化、及二维数组用法分析。 一、Java数组的定义 Java数组是一种...
java String 转成Double二维数组的方法
09-01
当涉及到二维数组时，这个过程可能会稍微复杂一些。本文将详细介绍如何将一个包含浮点数字符串的二维数组表示的字符串转换为Double类型的二维数组。 首先，我们来看一下问题的背景。假设我们有一个字符串，它表示了...
java旋转二维数组实例
09-04
Java中的二维数组是一种数据结构，它由多个一维数组组成，可以用来表示表格或矩阵。在本实例中，我们讨论的是如何在Java中旋转二维数组，即改变数组元素的排列顺序，使其按照螺旋方式进行填充。这在处理图像旋转、...
golang 接口
m0_70982551的博客
07-24 966
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 521
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 659
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 597
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 368
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 430
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 864
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 130
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 189
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
Java编程：数组与二维数组的应用解析
此外，还强调了二维数组的运用，如处理表格数据、矩阵相乘和选择题评分程序。示例代码演示了如何处理100个整数的平均值计算和计数任务，进一步解释了数组在实际编程中的作用。" 在Java语言中，数组是一种非常基础且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值