【java基础：4.一维数组、二维数组】 

作者：zhenyi

专栏：Java基础

简介：java基础专栏文章，适合java基础的学习和巩固

文章所用文件，可与作者联系获取！如果对您有帮助，点个关注吧，持续更新中，谢谢支持。如果有问题或错误，欢迎指出私信与我联系，谢谢。

目录

一、数组介绍

二、一维数组

1. 一维数组的声明和初始化

 2.数组元素的默认初始化值

3.例题

三、多维数组

1.二维数组

2.二维数组[][]:数组中的数组  

 3.二维数组的使用

4. 数组元素的默认初始化值 

四、数组中涉及到的常见算法

1. java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法

2.求数值型数组中元素的最大值、最小值、平均数、总和等 

3. 数组的复制、反转、查找(线性查找、二分法查找)

4.数组的冒泡排序的实现

5.数组的快速排序的实现

6.数组异常处理

---

一、数组介绍

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组的常见概念

（1）数组名

（2）下标(或索引)

（3）元素

（4）数组的长度

 数组的特点：
 1）数组是有序排列的
 2）数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
 3）创建数组对象会在内存中开辟一整块连续的空间
 4）数组的长度一旦确定，就不能修改。 
  

数组的分类：
 ① 按照维数：一维数组、二维数组、。。。
 ② 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

二、一维数组

1. 一维数组的声明和初始化

声明方式：

type var[] 或 type[] var；

例如：

int a[];

int[] a1;

double b[];

String[] c; //引用类型变量数组

•  Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

int arr=new int[3];
arr[0]=3;
arr[1]=9;
arr[2]=8;


String names[];
names =new String[3];
names[0]="张三";
names[1]="李四";
names[2]="王二";

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int arr[]=new int[]{3,9,8}
//或
int[] arr={3,9,8};

String naems[]={
"张三"，"李四"，"王二"
}

数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；

（1）数组元素的引用方式：数组名[数组元素下标]

（2）数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];

（3）数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new

int[3]; 可引用的数组元素为a[0]、a[1]、a[2]

（4）每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)

（5）数组一旦初始化，其长度是不可变的

public class ArrayTest {
	
	public static void main(String[] args) {
		
		//1. 一维数组的声明和初始化
		int num;//声明
		num = 10;//初始化
		int id = 1001;//声明 + 初始化
		
		int[] ids;//声明
		//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};
		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];
		
		//错误的写法：
//		int[] arr1 = new int[];
//		int[5] arr2 = new int[5];
//		int[] arr3 = new int[3]{1,2,3};
		
		//也是正确的写法：
		int[] arr4 = {1,2,3,4,5};//类型推断
		
		//总结：数组一旦初始化完成，其长度就确定了。
		
		//2.如何调用数组的指定位置的元素:通过角标的方式调用。
		//数组的角标（或索引）从0开始的，到数组的长度-1结束。
		names[0] = "王铭";
		names[1] = "王赫";
		names[2] = "张学良";
		names[3] = "孙居龙";
		names[4] = "王宏志";//charAt(0)
//		names[5] = "周扬";
		
		//3.如何获取数组的长度。
		//属性:length
		System.out.println(names.length);//5
		System.out.println(ids.length);
		
		//4.如何遍历数组
		/*System.out.println(names[0]);
		System.out.println(names[1]);
		System.out.println(names[2]);
		System.out.println(names[3]);
		System.out.println(names[4]);*/
		
		for(int i = 0;i < names.length;i++){
			System.out.println(names[i]);
		}
		
		
	}

}

 2.数组元素的默认初始化值

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

public class Test {

public static void main(String argv[]){

int a[]= new int[5];

System.out.println(a[3]); //a[3]的默认值为0

}

}

 （1）对于基本数据类型而言，默认初始化值各有不同

（2）对于引用数据类型而言，默认初始化值为null(注意与0不同！)  

 数组元素的默认初始化代码实现：

public class Projectsix {
    public static void main(String[] args) {
        //5.数组元素的默认初始化值
        int[] arr = new int[4];
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("**********");

        short[] arr1 = new short[4];
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
        System.out.println("**********");
        float[] arr2 = new float[5];
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }

        System.out.println("**********");
        char[] arr3 = new char[4];
        for (int i = 0; i < arr3.length; i++) {
            System.out.println("----" + arr3[i] + "****");
        }

        if (arr3[0] == 0) {
            System.out.println("你好！");
        }

        System.out.println("**********");
        boolean[] arr4 = new boolean[5];
        System.out.println(arr4[0]);

        System.out.println("**********");
        String[] arr5 = new String[5];
        System.out.println(arr5[0]);
        if (arr5[0] == null) {
            System.out.println("北京天气不错！");
        }
    }
}

3.例题

        升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。 屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。

public class Projectsix {
    public static void main(String[] args) {
        int[] arr=new int[]{8,2,1,0,3};
        int[] index=new int[]{2,0,3,2,4,0,1,3,2,3,3};
        String tel="";
        for (int i=0;i< index.length;i++){
            tel += arr[index[i]];
        }
        System.out.println("联系方式"+tel);
    }
}

三、多维数组

1.二维数组

理解：
 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
 其实，从数组底层的运行机制来看，其实没有多维数组。

2.二维数组[][]:数组中的数组
  

格式1（动态初始化）：int[][] arr = new int[3][2];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每一个一维数组中有2个元素

一维数组的名称分别为arr[0], arr[1], arr[2]

给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2（动态初始化）：int[][] arr = new int[3][];

二维数组中有3个一维数组。

每个一维数组都是默认初始化值null (注意：区别于格式1）

可以对这个三个一维数组分别进行初始化

arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];

注：

int[][]arr = new int[][3]; //非法

 3.二维数组的使用

 ① 二维数组的声明和初始化
 ② 如何调用数组的指定位置的元素
 ③ 如何获取数组的长度
 ④ 如何遍历数组

public class Textone {
    public static void main(String[] args) {
        //1.二维数组的声明和初始化
        int[] arr = new int[]{1,2,3};//一维数组
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];
        //错误的情况 
//		String[][] arr4 = new String[][4];
//		String[4][3] arr5 = new String[][];
//		int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

        //也是正确的写法：
        int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
        int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

        //2.如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);//2
        System.out.println(arr2[1][1]);//null

        arr3[1] = new String[4];
        System.out.println(arr3[1][0]);

        //3.获取数组的长度
        System.out.println(arr4.length);//3
        System.out.println(arr4[0].length);//3
        System.out.println(arr4[1].length);//4

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

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

二维数组的使用：
 规定：二维数组分为外层数组的元素，内层数组的元素
          int[][] arr = new int[4][3];
          外层元素：arr[0],arr[1]等
          内层元素：arr[0][0],arr[1][2]等

4. 数组元素的默认初始化值 

    针对于初始化方式一：比如：int[][] arr = new int[4][3];
       外层元素的初始化值为：地址值
       内层元素的初始化值为：与一维数组初始化情况相同
       
    针对于初始化方式二：比如：int[][] arr = new int[4][];
        外层元素的初始化值为：null
       内层元素的初始化值为：不能调用，否则报错。
    

public class Textone {
    public static void main(String[] args) {

        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//[I@15db9742
        System.out.println(arr[0][0]);//0

//		System.out.println(arr);//[[I@6d06d69c

        System.out.println("*****************");
        float[][] arr1 = new float[4][3];
        System.out.println(arr1[0]);//地址值
        System.out.println(arr1[0][0]);//0.0

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

        String[][] arr2 = new String[4][2];
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);//null

        System.out.println("*****************");
        double[][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
//		System.out.println(arr3[1][0]);//报错

    }
}

四、数组中涉及到的常见算法

1. java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法

public class ArraysTest {
	public static void main(String[] args) {
		
		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}
		
		
	}
}

2.求数值型数组中元素的最大值、最小值、平均数、总和等
 

         定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。    

要求：所有随机数都是两位数。

public class Textone {
    public static void main(String[] args) {

        int[] arr = new int[10];

        for(int i = 0;i < arr.length;i++){
            arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
        }

        //遍历
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //求数组元素的最大值
        int maxValue = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(maxValue < arr[i]){
                maxValue = arr[i];
            }
        }
        System.out.println("最大值为：" + maxValue);

        //求数组元素的最小值
        int minValue = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(minValue > arr[i]){
                minValue = arr[i];
            }
        }
        System.out.println("最小值为：" + minValue);
        //求数组元素的总和
        int sum = 0;
        for(int i = 0;i < arr.length;i++){
            sum += arr[i];
        }
        System.out.println("总和为：" + sum);
        //求数组元素的平均数
        int avgValue = sum / arr.length;
        System.out.println("平均数为：" + avgValue);

    }
}

3. 数组的复制、反转、查找(线性查找、二分法查找)

public class ArrayTest2 {
	
	public static void main(String[] args) {
		
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
		
		//数组的复制(区别于数组变量的赋值：arr1 = arr)
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++){
			arr1[i] = arr[i];
		}
		
		//数组的反转
		//方法一：
//		for(int i = 0;i < arr.length / 2;i++){
//			String temp = arr[i];
//			arr[i] = arr[arr.length - i -1];
//			arr[arr.length - i -1] = temp;
//		}
		
		//方法二：
//		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
//			String temp = arr[i];
//			arr[i] = arr[j];
//			arr[j] = temp;
//		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		
		System.out.println();
		//查找（或搜索）
		//线性查找：
		String dest = "BB";
		dest = "CC";
		
		boolean isFlag = true;
		
		for(int i = 0;i < arr.length;i++){
			
			if(dest.equals(arr[i])){
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}
			
		}
		if(isFlag){
			System.out.println("很遗憾，没有找到的啦！");
			
		}
		//二分法查找：(熟悉)
		//前提：所要查找的数组必须有序。
		int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		
		int dest1 = -34;
		dest1 = 35;
		int head = 0;//初始的首索引
		int end = arr2.length - 1;//初始的末索引
		boolean isFlag1 = true;
		while(head <= end){
			
			int middle = (head + end)/2;
			
			if(dest1 == arr2[middle]){
				System.out.println("找到了指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1){
				end = middle - 1;
			}else{//arr2[middle] < dest1
				head = middle + 1;
			}

			
		}
		
		if(isFlag1){
			System.out.println("很遗憾，没有找到的啦！");
		}
		
		
	}
}

4.数组的冒泡排序的实现

public class Textone {
    public static void main(String[] args) {

        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};

        //冒泡排序
        for(int i = 0;i < arr.length - 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;
                }

            }

        }




        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }
}

5，数组的快速排序的实现

public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

6.数组异常处理

 数组中的常见异常：
 1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
 2. 空指针异常：NullPointerException

public class ArrayExceptionTest {
	public static void main(String[] args) {
		
		//1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
		int[] arr = new int[]{1,2,3,4,5};
		
//		for(int i = 0;i <= arr.length;i++){
//			System.out.println(arr[i]);
//		}
		
//		System.out.println(arr[-2]);
		
//		System.out.println("hello");
		
		//2.2. 空指针异常：NullPointerException
		//情况一：
//		int[] arr1 = new int[]{1,2,3};
//		arr1 = null;
//		System.out.println(arr1[0]);
		
		//情况二：
//		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0][0]);
		
		//情况三：
		String[] arr3 = new String[]{"AA","BB","CC"};
		arr3[0] = null;
		System.out.println(arr3[0].toString());
	}
}

如果对您有帮助，点个关注吧，持续更新中，谢谢支持。如果有问题或错误，欢迎指出与我联系，谢谢。

数组用来表示一组数据的集合。使用数组，可以方便地定义一个名字（数组名）来表示大批量数据，并能够通过循环批处理大量数据。

一、定义

数组就是一组相同类型数据的集合。

一维数组的定义形式为：

元素类型  数组名  [常量表达式（数组包含的元素个数）]; 

int A[10];
int B[10], C[15]; //多个数组定义
int E[10], m, n, F[15]; //数组和变量混合在一起定义

（1）一维数组是由元素类型、数组名和长度（数组包含的元素个数）组成的构造类型。

int A[10], B[20]; // 元素是整型
double F1[8], F2[10]; //元素是双精度浮点型
char S1[80], S2[80]; //元素是字符型

（2）数组名必须符合C++标识符规则。

（3）常量表达式表示数组中元素的个数，称为数组长度。常量表达式的值必须为正整数且大于等于1。

（4）数组一经定义，数组长度就始终不变。

   如：

int n;
cin>>n;
int a[n];  //错误！

二、内存形式

C++规定数组元素是连续存放的，即在内存中一个元素紧跟着一个元素线性排列。

 三、一维数组的初始化

可以在一维数组定义时对它进行初始化，初始化的语法形式如下：

元素类型  数组名 [常量表达式]={初值列表};

int A[5]={1,2,3,4,5} , B[3]={7,8,9};
//一维数组初始化

（1）初值列表提供的元素个数不能超过数组长度，但可以小于数组长度。如果初值个数小于数组长度，则只初始化前面的数组元素， 剩余元素初始化为0。例如：

int A[5]={1,8,9};

（2）在提供了初值列表的前提下，数组定义时可以不用指定数组长度，编译器会根据初值个数自动确定数组的长度。例如：

int A[]={1,8,9};

可以用下面的表达式计算出数组A的长度：

 

（3）若数组未进行初始化，静态数组的元素均初始化为0；在函数体内定义的动态数组，其元素没有初始化，为一个随机值。 

static int A[10]; //静态数组，默认各元素的值为0
int A[10]; //动态数组，各元素的值为随机数

四、一维数组的引用 

数组必须先定义后使用，且只能逐个引用数组元素的值而不能一次引用整个数组全部元素的值。

数组元素引用是通过下标得到的，一般形式为：

数组名 [下标表达式]

 （1）注意下标的表示形式

►下标表达式可以是常量、变量、表达式，但必须是正整数，不允许为负。

►数组元素下标总是从0开始。

int A[5]={1,2,3,4,5}, x,i=3;
x = A[2] ;  //常量
A[i]++;     //变量
A[1+2]=10;  //表达式

（2）下标值不能超过数组长度，否则导致数组下标越界的严重错误。例如： 

int A[5]={1,2,3,4,5};
A[5]=10; //错误，没有A[5]元素

 

 （3）整个数组不允许进行赋值运算、算术运算等操作，只有元素才可以，例如：

int A[10], B[10], C[10];
A = B; //错误
A = B + C; //错误
A[0] = B[0]; //正确，数组元素赋值
A[2] = B[2]+C[2]; //正确，数组元素赋值

从数组的内存形式来看，数组元素的下标是有序递增的，这个特点使得可以利用循环来批量处理数组元素。

如：

对数组中的所有元素进行输入输出。 

 #include <iostream>
 using namespace std;
 int main() //一维数组的输入输出
 {
 int i, A[100]; 
 for(i=0;i<100;i++) cin>>A[i];
 for(i=100-1;i>=0;i--) cout<<A[i]<<" ";
 return 0;
 } 

将一个一维数组的元素赋给另一个等长的一维数组。

 #include <iostream>
 int main()
 {
 int A[5]={1,2,3,4,5} , B[5] , i;
 for (i=0; i<5; i++)
 B[i] = A[i]; //元素一一复制
 return 0;
 }