Java二维数组

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量450 收藏 7
点赞数 9
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76764006/article/details/135609005
版权

 二维数组代码练习

package Learn5;

public class Demo01 {
    //二维数组的操作
    public static void main(String[] args) {
        //声明二维数组
        //数据类型[][] 数组名;  或者  数据类型 数组名[][];
        int[][] nums1;
        char[][] chars1;

        //分配空间
        //数组名 = new 数据类型[数组长度][数组长度];
        //数组名 = new 数据类型[数组长度][];
        nums1 = new int[3][4];
        chars1 = new char[2][4];

        //赋值
        //数组名[下标][下标] = 数据;
        nums1[0][0] = 10;
        nums1[0][1] = 20;
        nums1[0][2] = 20;
        nums1[0][3] = 20;

        nums1[1][0] = 30;
        nums1[1][1] = 40;
        nums1[1][2] = 50;
        nums1[1][3] = 60;

        nums1[2][0] = 70;
        nums1[2][1] = 80;
        nums1[2][2] = 90;
        nums1[2][3] = 100;

        chars1[0][0] ='q';
        chars1[0][1] ='w';
        chars1[0][2] ='e';

        chars1[1][0] ='r';
        chars1[1][1] ='t';
        chars1[1][2] ='y';
        chars1[1][3] ='o';

        //操作数据
        //数组名[下标][下标]

        //遍历二维数组
        for(int i =0;i<nums1.length;i++){

//            System.out.println(nums1[i]);
            for(int j=0;j<nums1[i].length;j++){
                System.out.print(nums1[i][j]+" ");
            }
            System.out.println();
        }




    }

}
package Learn5;
public class Demo02 {

    public static void main(String[] args) {
        //二维数组声明、分配空间合并写
        //数据类型[][] 数组名 = new 数据类型[长度][长度];
        //数据类型 数组名[][]  = new 数据类型[长度][长度];
        int[][] nums1 = new int[3][5];


        //二维数组声明、分配空间、赋值合并写
        //数据类型[][] 数组名 = new 数据类型[][]{{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},....,{数据1,数据2,...,数据n}};
        //数据类型 数组名[][] = new 数据类型[][]{{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},....,{数据1,数据2,...,数据n}};
        int[][] nums2 = new int[][]{{1,2,4},{6,8,9},{77,23,45}};
        int[][] nums3 = new int[][]{{1,2,4,55,9},{6,8,9},{77,23,45,55,77,44,49,33}};

        //二维数组的声明、分配空间、赋值简写
        //数据类型[][] 数组名= {{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},....,{数据1,数据2,...,数据n}};
        //数据类型 数组名[][]= {{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},....,{数据1,数据2,...,数据n}};
        int[][] nums4 = {{1,2,4},{6,8,9},{77,23,45}};
        int[][] nums5 = {{1,2,4,55,9},{6,8,9},{77,23,45,55,77,44,49,33}};

    }

}
package Learn5;

public class Demo03 {
    //遍历二维数组
    public static void main(String[] args) {
        int[][] nums = {{1,2,3},{4,5},{7,8,9,0},{22}};

        for(int i =0;i<nums.length;i++){

//            System.out.println(nums[i]);
            for(int j =0;j<nums[i].length;j++){
                System.out.print(nums[i][j]+" ");
            }
            //换行
            System.out.println();
        }

    }

}

package Learn5;
import java.util.Scanner;

public class Demo04 {
    //已知有3个班级各5名学员，请使用二维数组计算各个班级的总成绩
    public static void main(String[] args) {
        //创建Scanner类对象
        Scanner scanner = new Scanner(System.in);

        //准备一个长度为3的double类型的二维数组（这个二维数组的元素都是长度为5的double类型的数组）
        double[][] scores = new double[3][5];

        //赋值：通过键盘录入向数组中存储数据，使用循环实现
        for(int i =0;i<scores.length;i++){
            System.out.println("************************第"+(i+1)+"个班************************");
            for(int j=0;j<scores[i].length;j++){
                System.out.println("请输入第"+(j+1)+"个学生的成绩：");
                scores[i][j]=scanner.nextDouble();
            }

        }

        //求各个班级的成绩之和
        System.out.println("************************成绩统计************************");

        for(int i =0;i<scores.length;i++){
            //声明一个变量用来累加班级学生成绩之和
            double sum = 0;
            for(int j=0;j<scores[i].length;j++){
                sum+=scores[i][j];
            }
            System.out.println((i+1)+"班总成绩："+sum);
        }

    }

}

三维数组 

 

package Learn5;
public class Demo05 {

    public static void main(String[] args) {

        //声明一个三维数组并赋值
        int[][][] nums = {{{11,22},{33,44,55}},{{56},{77,99},{99,77,66,44,55,33}}};

        //遍历三维数组
        for(int i =0;i<nums.length;i++){
            for(int j=0;j<nums[i].length;j++){
                for(int k =0;k<nums[i][j].length;k++){
                    System.out.print(nums[i][j][k]+" ");
                }
                System.out.println();
            }

        }



    }

}

Arrays类的使用 

Arrays.sort

package Learn4;
import java.util.Arrays;
public class ArraysDemo01 {
    public static void main(String[] args) {
            int[] nums1 = {25, 64, 11, 89, 32, 40, 77, 55};
            System.out.println("数组排序前：");
            for (int a : nums1) {
                System.out.print(a + " ");
            }
            System.out.println();

            //对数组进行升序排序，使用Arrays.sort()方法实现
            Arrays.sort(nums1);

            System.out.println("数组排序后：");
            for (int a : nums1) {
                System.out.print(a + " ");
            }
            System.out.println();

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

            int[] nums2 = {25, 64, 11, 89, 99, 88, 32, 40, 77, 55};

            System.out.println("数组排序前：");
            for (int a : nums2) {
                System.out.print(a + " ");
            }
            System.out.println();

            Arrays.sort(nums2, 1, 6);

            System.out.println("数组排序后：");
            for (int a : nums2) {
                System.out.print(a + " ");
            }
            System.out.println();
    }
}

Arrays.equals

package Learn4;

import java.util.Arrays;

public class ArraysDemo02 {

    public static void main(String[] args) {

        int[] nums1 = {11,33,44,55,99};
        int[] nums2 = {11,33,44,99,55};

        System.out.println(nums1);
        System.out.println(nums2);

        //比较两个数组中的元素是否完全一样，使用Arrays类中的equals()方法可以实现
        boolean result1 =Arrays.equals(nums1,nums2);
        System.out.println("nums1数组和nums2数组完全相同："+result1);

    }

}

Arrays.toString

package Learn4;

import java.util.Arrays;

public class ArraysDemo04 {

    public static void main(String[] args) {

        int[] nums1 = {11,22,55,66,77};

        System.out.println(Arrays.toString(nums1));

        //fill(数组名,数据)：将数组中所有元素值替换为指定的数据
        Arrays.fill(nums1,99);
        System.out.println(Arrays.toString(nums1));

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

        int[] nums2 = {11,22,33,44,55,66,77,88,99};
        System.out.println(Arrays.toString(nums2));

        //fill(int[] a, int fromIndex, int toIndex, int val)将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
        Arrays.fill(nums2,3,6,100);
        System.out.println(Arrays.toString(nums2));


    }

}

Arrays.copyOf

 

package Learn4;

import java.util.Arrays;

public class ArraysDemo05 {

    public static void main(String[] args) {

        int[] nums = {11,22,33,44,55,66,77,88,99};

        int[] newNums1 =Arrays.copyOf(nums,3);
        System.out.println(Arrays.toString(newNums1));

        int[] newNums2 =Arrays.copyOf(nums,9);
        System.out.println(Arrays.toString(newNums2));

        int[] newNums3=Arrays.copyOf(nums,11);
        System.out.println(Arrays.toString(newNums3));

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

        int[] newNums4 = Arrays.copyOfRange(nums,3,6);//赋值元素是，结束索引的元素不包括
        System.out.println(Arrays.toString(newNums4));




    }

}

Arrays.binarySearch

package Learn4;
import java.lang.reflect.Array;
import java.util.Arrays;

public class ArraysDemo06 {

    public static void main(String[] args) {

        int[] nums = {11,55,33,22,77,44,11,56,22,88,66};

        //查找数据22
        //int binarySearch(int[] a,int key)使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

//        int index1 =Arrays.binarySearch(nums,22);
//        System.out.println(index1);

        //对数组进行排序
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));
        int index1 =Arrays.binarySearch(nums,22);
        System.out.println(index1);

        //查找一个不存在的数据，会返回一个负值
        int index2 =Arrays.binarySearch(nums,29);
        System.out.println(index2);

        int index3 =Arrays.binarySearch(nums,3,7,22);
        System.out.println(index3);


    }

}

冒泡排序 

package Learn3;

public class Demo01 {
    //冒泡排序
    public static void main(String[] args) {
        //准备一个数组
        int[] nums = {56,42,11,78,93,44,20,63,81,5};
        //遍历数组
        System.out.println("排序前数组：");
        for(int i =0;i< nums.length;i++){
            System.out.print(nums[i]+" ");
        }

        System.out.println();

        //使用冒泡排序对数组进行升序排序
        //外层循环变量控制比较的轮数
        for(int i =0;i< nums.length-1;i++){
            //内层循环变量控制每一轮的比较次数
            for(int j =0;j< nums.length-1-i;j++){
                //比较相邻的两个元素，如果前面的元素比后面的元素大，交换位置
                if(nums[j]>nums[j+1]){
                    //交换
                    int temp = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }

        //遍历数组
        System.out.println("排序后数组：");
        for(int i =0;i< nums.length;i++){
            System.out.print(nums[i]+" ");
        }

    }

}
package Learn3;

import java.util.Scanner;

public class Demo02 {
    //使用冒泡排序对输入的5名学员成绩进行降序排列

    public static void main(String[] args) {
        //创建Scanner对象
        Scanner scanner=new Scanner(System.in);

        //准备数组存储5名学生的成绩
        double[] scores = new double[5];

        //通过循环获取5名学生成绩存储在数组中
        for(int i =0;i<scores.length;i++){
            System.out.println("请输入第"+(i+1)+"位学生的成绩：");
            scores[i]=scanner.nextDouble();
        }

        //遍历数组
        System.out.println("排序前数组中的成绩：");
        for(double score :scores){
            System.out.print(score+" ");
        }
        System.out.println();

        //使用冒泡排序对数组进行降序排序
        //外层循环变量控制比较轮数
        for(int i =0;i< scores.length-1;i++){
            //内层循环变量控制每一轮的比较次数
            for(int j =0;j< scores.length-1-i;j++){
                //比较
                if(scores[j]<scores[j+1]){
                    //交换位置
                    double temp = scores[j];
                    scores[j]=scores[j+1];
                    scores[j+1]=temp;
                }
            }
        }

        //遍历数组
        System.out.println("排序后数组中的成绩：");
        for(double score :scores){
            System.out.print(score+" ");
        }

    }

}

选择排序 

package Learn3;

public class Demo03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 给定一个数组a[]
		int[] a = new int[] { 23, 2, 11, 32, 43, 28 };
		// 遍历一遍数组
		System.out.println("遍历数组a[]");
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}

		// 选择排序从大到小
		System.out.println("下面进行从大到小的选择排序");
		for (int i = 0; i <= a.length - 2; i++) {
			for (int j = i + 1; j <= a.length - 1; j++) {
				if (a[i] < a[j]) {
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}

		// 遍历一遍排序后的数组
		System.out.println("遍历经过选择排序从大到小排序后的数组a[]");
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
}

 

 

沐夏
关注
java 二维数组 排序_二维数组排序
weixin_39738115的博客
02-20 2003
参考：https://www.cnblogs.com/rujianming/p/11779922.htmlhttps://blog.csdn.net/westwewe/article/details/103515556https://blog.csdn.net/chao_ji_cai/article/details/100072293int [][]a = new int [5][2];//定义一...
java传递二维数组_java二维数组
weixin_39562089的博客
02-12 946
数组--是用来存储一组相同数据类型的数据的容器；数组本身是一个引用数据类型[]数组内部存储的元素？可以是基本数据类型;int[]也可以是引用数据类型;String[]引用数据类型；StringMathScanner想要创建一个数组--里面存储好多个小数组int[]，如何做？二维数组1.数组的定义/声明；int[][] x;2.数组的初始化；静态初始化；--有长度 有元素int[][] x={{3,...
Java 二维数组
SpitBubble的博客
07-30 3456
二维数组简单概述：Java中的二维数组一般应用在矩阵的一些运算、棋盘游戏中棋盘的实现、二维数据的处理、图表的绘制、数据库的存储等方面。特别是在和等情况下非常有用，可以方便的存储和操作数据。
java二维数组
qq_44625745的博客
04-16 1300
目录Java 用sort对二维数组进行排序二维数组简单概述：Java中的二维数组一般应用在矩阵的一些运算、棋盘游戏中棋盘的实现、二维数据的处理、图表的绘制、数据库的存储等方面。特别是在处理数据和表示矩阵等情况下非常有用，可以方便的存储和操作数据。
java 二维数组
Dtoooo的博客
04-08 5410
语法： 数据类型 [ ][ ] 数组名 ；或者 数据类型 数组名[ ][ ] int [ ] [ ] scores;//定义二维数组 scores = new int[5][3]//分配内存空间 或者： int [ ][ ] scores = new int[5][3]; 或者直接赋值： int [ ][ ] scores = {{元素，……},{元素，……},{元素，……},{元素，……},{元素，……}} 说明： 二维数组实际是以一维数组为元素的一维数组。 import java.
java二维数组坐标_Java 二维数组
weixin_39589644的博客
02-13 3017
二维数组的定义二维数组本质上是以数组作为数组元素的数组，即“数组的数组”。因为数组只能保存一行数据。在生活中，比如坐标等等，我们需要用二维数组来表示。通过行号和列好来定位数据。定义：类型 数组[][]　　类型[][] 数组名例如：float a[3][4];　　//定义a为3行4列的数组二维数组的声明和初始化二维数组的声明、初始化和引用与一维数组相似。当使用new来创建二维数组时，不必指定每一维的...
Java二维数组赋值
千锋教育
03-13 7477
可以使用myArray [i] [j]访问数组中的任何元素，其中i表示行数，j表示列数。总的来说，二维数组在处理多维数据时具有优秀的表现，但是在处理大规模数据时需要考虑其内存占用和性能问题。需要注意的是，使用静态初始化时，可以省略第一个维度的长度，但不能省略第二个维度的长度。在内存中，二维数组是连续存储的，当二维数组的大小比较大时，可能会出现内存不足的情况。与一维数组一样，二维数组的元素只能是同一类型的数据，不支持异构数据结构。与一维数组一样，二维数组是固定长度的，这有助于提高代码的效率和可读性。
超详细 java二维数组解析
从零开始的博客
04-26 6510
咳咳，有小伙伴公众号私信说需要出一期二维数组 的知识点，我翻了翻公众号的历史文章，果然没有，这边自罚一杯 1. 二维数组基本概念 之前我们已经知道什么是 数组（一维数组）javaj基础—数组，数组的存取 这里补充一点： 数组本身是引用数据类型 ，数组的元素 可以是 基本数据类型 跟 引用数据类型 那么？什么是二维数组 ？ 官方定义：以一维数组作为一维数组元素的数组 要是有点绕，不好理解，没关系，简单来说，就是一维数组里面存一维数组 ，这就是二维数组 到这，是不是已经基本明白了二维数组的概念了 现在我们
java二维数组的创建,java二维数组创建方法
weixin_33489687的博客
03-21 2453
java动态创建二维数组,从零学java笔录-第31篇 图解二位数组在内存中存储,java二维数组动态赋值,java二维数组创建方法二维数组的定义 type arrayName[ ][ ]; type [ ][ ]arrayName Java 二维数组的声明、初始化和引用 二维数组的声明、初始化和引用与一维数组相似,这里不再详......java定义二维数组的几种写法_计算机软件及应用_IT/计算...
Java二维数组查找功能代码实现
08-19
"Java二维数组查找功能代码实现" Java二维数组查找功能代码实现是Java编程语言中的一种常见功能，主要用于在二维数组中查找指定的整数。这种功能的实现可以通过对二维数组的遍历和比较来实现。 首先，我们需要了解...
Java二维数组实现简单Map
07-31
在Java编程语言中，二维数组可以被用来模拟简单的Map数据结构。Map是一种键值对的集合，其中每个键（Key）都是唯一的，并且与一个值（Value）相关联。尽管Java提供了内置的Map接口（如HashMap、TreeMap等），但有时...
java 二维数组矩阵乘法的实现方法
09-05
本篇文章将详细探讨如何使用Java二维数组来实现矩阵乘法。 矩阵乘法的定义是，对于两个矩阵A（m×n）和B（n×p），它们的乘积C（m×p）的每个元素c[i][j]是通过计算A的第i行与B的第j列对应元素的乘积之和得到的。...
java二维数组遍历的2种代码
08-25
Java二维数组遍历的两种代码实现 在Java编程中，二维数组是一种常见的数据结构，遍历二维数组是数组操作的基本步骤。今天，我们将详细介绍Java二维数组遍历的两种代码实现。 第一种方法：双重for循环 在Java中，...
Java二维数组简单定义与使用方法示例
08-29
Java二维数组简单定义与使用方法示例 Java二维数组是一种复杂的数据结构，它可以存储大量的数据，并且可以根据需要动态扩展。下面是Java二维数组的简单定义与使用方法示例。 Java二维数组的定义 Java二维数组是由...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 219
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 461
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 562
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 809
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java二维数组创建与操作实践
Java二维数组是Java编程中常用的数据结构，它允许我们在程序中存储和操作多维数据。在这个文件中，作者分享了二维数组的基础知识，包括创建方法、打印输出以及查找最大值的操作。 首先，关于二维数组的创建，有三种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值