Java 数组

菠萝味菠萝啤

已于 2022-10-13 19:49:35 修改

阅读量466

点赞数

分类专栏： java 文章标签：二维数组 java leetcode

于 2022-01-06 01:43:55 首次发布

本文链接：https://blog.csdn.net/dd_Mr/article/details/122335605

版权

java 专栏收录该内容

65 篇文章 2 订阅

订阅专栏

一维数组

静态初始化

int [] array1 = {1,2,3,4,5};
int [] array2 = int[]{1,2,3,4,5};

数组动态初始化：声明并开辟数组：
数据类型 [] 数组名称 = new 数据类型[长度];

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = new int[3]; /*开辟了一个长度为3的数组*/
		data[0] = 10; // 第一个元素
		data[1] = 20; // 第二个元素
		data[2] = 30; // 第三个元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通过循环控制索引
		}
	}
}

一维数组默认值

int[] s = new int[6];
System.out.println("数组默认值："+s[0]);
//运行结果：数组默认值：0

二维数组

关键点：二维数组是特殊的一维数组

格式1: 静态初始化

举例：

数据类型 [][]   数组名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};

int[][]  arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66}};
//3行5列的二维数组
//如果每个花括号中元素个数不同，按照最长的为二维数组列数

静态初始化可用于不规则二维数组的初始化

格式2: 动态初始化

数据类型 [ ][ ]  数组名 = new 数据类型[m][n]
数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ]   数组名 [ ] = new 数据类型[m][n]

举例：int [ ][ ]  arr=new  int [5][3];  也可以理解为“5行3例”
动态声明一个空数组
int[][] arr =  new int[][]{};//记得最后这个{}要带
如果动态生成要填数据的二维数组，要写上m和n
int[][] ans = new int[m][n];

二维数组获取行列长度

public class main {
    public static void main(String[] args) {
        //静态初始化二维数组
        String[][] array = {{"a","b","c"},{"d","e","f"},{"h","i","j","k"}};

        System.out.println("二维数组行数或者说二维数组的长度:"+array.length);
        System.out.println("二维数组中第1个一维数组的长度："+array[0].length);
        System.out.println("二维数组中第2个一维数组的长度："+array[1].length);
        System.out.println("二维数组中第3个一维数组的长度："+array[2].length);

        for (int i=0;i<array.length;i++){
//            array[1] 代表二维数组中的第一个一维数组
            for (int j=0;j<array[i].length;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

对于一个矩阵的二维数组

public class main {
    public static void main(String[] args) {
        //对于一个矩阵
        String[][] array = {{"a","b","c"},{"d","e","f"},{"h","i","j"},{"k","l","m"}};

        System.out.println("矩阵总行数:"+array.length);
        System.out.println("矩阵总列数："+array[0].length);

    }
}

在这里插入图片描述

二维数组可以省略行不能省略列

定义二维数组时，省略之后要让计算机能够确定你定义的几行几列才可以

假如你省略行数，但是确定了列数，计算机会根据你的列数的数值以及你初始化时给的数据，自动确定行数，因此行数可以省略。

但是如果给了行数但没有确定列数，对于你初始化的数据，计算机不知道怎么划分，是平均分呢？还是其他方式分呢？这是没有规定的，这样子会出现错误。

https://blog.csdn.net/weixin_39564036/article/details/115235756

增强for遍历二维数组

https://blog.csdn.net/dd_Mr/article/details/122305263
https://leetcode-cn.com/problems/richest-customer-wealth/

顺便再提一下一维数组的初始化

java数组默认初始化的值

int[] a = new int[5];
其默认初始化的值为{0，0，0，0，0}


public class Solution1 {
    public static void main(String[] args) {
        int[] a = new int[5];
        System.out.println(a[3]+"--");

        for (int i=0;i<6;i++){
            a[3]++;
            System.out.println(a[3]);
        }
    }
}

在这里插入图片描述

https://blog.csdn.net/laoyao199044/article/details/93166776
https://my.oschina.net/fatwowzb/blog/208742

练习

package demo0120.struct;

/**
 * @Author: 从南到北
 * @Date: 2022/02/04/14:12
 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] array1=new int[3];    //动态初始化，要给出长度
        //静态初始化
        int[] array2=new int[]{1,2,3};
        int[] array3 = {1,2,3};


        //二维数组初始化
        //静态初始化
        int[][] array4 = {{1,2,3},{4,5,6},{7,8,9}};
        int[][] arrya7 = new int[][]{{1,2},{3,32,5},{6,4,3}};
        //动态初始化
        int[][] array5 = new int[3][3];
        //动态声明一个空二维数组
        int [][] array6 = new int[][]{};
        int length4 = array4.length;    //二维数组的长度
        int length5 =array4[0].length;
        //二维数组中，第一个元素的长度
    }
}

package demo0120.struct;

/**
 * @Author: 从南到北
 * @Date: 2022/02/04/11:29
 *
 * java定义一维数组，二维数组
 * 并遍历一维和二维数组
    静态初始化和动态初始化
 */
public class ArrayDemo {

    public static void main(String[] args) {

        int[][] array ={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
        int[][] array1=new int[][]{{1,2,3,4},{5,6,7,8},{9,10,11,12}};

        int[][] array2 =new int[3][3];//声明二维数组

        int[][] array3=new int[][]{};   //声明一个空数组
        //二维数组的长度

        //给二维数组初始化赋值
        for (int i=0;i< array2.length;i++){
            for (int j=0;j<array2[i].length;j++)
            {
                array2[i][j]=j;
            }
        }

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


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

#include <stdio.h>
#include <stdlib.h>
void arrayprint(int datas[],int ele)
			/*重点2：1.形式参数中，写的数组是数组样子，但中括号中数组的大小是无效的
				   2.括号中无论写多少，都不能代表形参数组有多大！
                   3.中括号的作用仅仅用来表示该参数是一个地址（在windows啊哈C之类的软件编译器中，整型用四个字节表示地址；在Linux64位中用8个字节表示）*/

{	int i;
	printf("数组的大小：%d\n",sizeof(datas));
	printf("一个整型元素的大小为：%d\n",sizeof(datas[0]));
    printf("数组：");
    for(i=0;i<ele;i++)
    printf("%d ",datas[i]);
	putchar('\n');
}


void arrayprint1(char datas[],int ele)
{	int i;
	printf("数组的大小：%d\n",sizeof(datas));
					//重点3：sizeof()判断数据类型或者表达式长度//
	printf("一个整型元素的大小为：%d\n",sizeof(datas[0]));
    printf("数组：");
    for(i=0;i<ele;i++)
    printf("%c ",datas[i]);
	putchar('\n');//putchar输出一个字符;getchar()获取一个字符的输入。//
}


int main()
{
	int a[3]={714,297,215};
    
    char b[3]={'a','b','c'};
    
		printf("数组的大小：%d\n",sizeof(a));
		printf("一个元素的大小：%d\n",sizeof(a[0]));//一个整型数占用空间4个字节//
		printf("数组的个数：%d\n",sizeof(a)/sizeof(a[0]));
        
	//重点1：数组与函数相结合，数组名当作实际参数，如下//
    /*arrayprint(a,sizeof(a)/sizeof(a[0]));*/
    
    printf("*****************************\n");
    printf("*****************************\n");    
    printf("*****************************\n");    
    printf("*****************************\n");    
    printf("*****************************\n");    
    printf("******下面是字符型数组*******\n");
		printf("数组的大小：%d\n",sizeof(b));
		printf("一个元素的大小：%d\n",sizeof(b[0]));//一个char型占用空间1个字节//
		printf("数组的个数：%d\n",sizeof(b)/sizeof(b[0]));
        
		/*arrayprint1(b,sizeof(b)/sizeof(b[0]));*/
	
    system("pause");
    
	return 0;
}