java语言数组的定义及使用

逃离我推掉我的手 2022-03-22 04:44 210阅读 0赞

# 什么叫数组？ #

数组是存储同一种数据类型多个元素的集合。也可以看成一个容器。  
数组既可以存储基本数据类型，也可以存储引用数据类型，数组本身就是一个引用数据类型。

## 数组的使用 ##

使用数组的两个步骤：**声明数组，分配内存空间**【内存分为：堆内存，栈内存，方法区】  
1.声明数组（数据类型 数组名\[\]=null；/数据类型\[\] 数组名=null;）  
2.分配内存给数组（数组名=new 数据类型\[长度\]；）  
内存划分，数组名是数组数据的参考地址，存放在栈内存中，而数组的数据存放是在堆内存中。  
声明数组指的是在栈内存中开辟空间存放数组的参考地址，（这时的数组是不可以使用的，必须要有指向堆的内存才可以使用，）  
开辟堆内存：  
必须使用new关键字，（只是将堆的使用权交给了对应的栈空间，）一个堆的内存空间可以同时被多个栈内存空间所指向，  
数据类型 数组名=new 数据类型\[长度\]（声明数组的同时分配内存空间给数组使用）  
数组的初始化有两种方式：静态初始化和动态初始化  
以下属于动态初始化，（先声明数组后赋值）  
数据类型 数组名=new 数据类型\[长度\]  
静态初始化（声明数组时直接赋值）  
数据类型 数组名=\{初值0，初值1，初值2…初值n\};  
大括号中的值在内存中依次存放。

## 对数组的操作 ##

对数组的基本操作有：增，删，改，查；  
首先对数组中的数据进行遍历（利用for循环依次输出）例如：

class demo4{
    	public static void main(String[] args){
    	int score[]=null;
    	score=new int[10];
    	for(int i=0;i<10;i++){
    		//for(int i=0;i<11;i++){//当数组访问到score[10]时，发生异常。
    		score[i]=i;
    	System.out.println(score[i]+" "+score.length);
    	}
    	}
    }
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190125233008558.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MzI2NDU2,size_16,color_FFFFFF,t_70)

\*\*在遍历数组时，不能对不存在的数组下标进行遍历：否则出现错误，例如：

class demo4{
    	public static void main(String[] args){
    	int score[]=null;
    	score=new int[10];
    	//for(int i=0;i<10;i++){
    		for(int i=0;i<11;i++){//当数组访问到score[10]时，发生异常。
    		score[i]=i;
    	System.out.println(score[i]+" "+score.length);
    	}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MzI2NDU2_size_16_color_FFFFFF_t_70]  
这种异常称为数组下标越界异常，即访问的下标超出了数组现有的空间。

## 二维数组 ##

### 定义： ###

1.  数据类型\[\]\[\] 数组名=new 数据类型\[数组行的长度\]\[数组列的长度\];
2.  数据类型\[\]\[\] 数组名=\{ \{第一行数据\}，\{第二行数据\}…\{第n行数据\}\}  
    **以matrix\[i\]\[j\]为例，这个二维数组可以理解为有i个一维数组按照一定的顺序排列起来，也就是说matrix\[i\]可以看做一个数组的对象名，将这些对象名放在一起形成一个一维数组，并给定一个对象matrix，由此可以得出三维，四维等数组的定义**  
    二维数组也和一维数组操作类似，也可以按顺序进行遍历也可进行增，删，改，查  
    例如：将二维数组的每一列进行求和：

import java.util.*;
    /*
    二维数组本质是一维数组
    提示用户输入二维数组
    计算每列之和sumColumn
    输出每列之和
    */
    class demo1{
    	public static void main(String[] args){
    	Scanner scanner=new Scanner(System.in);
    	double[][] matrix=new double[4][4];
    	System.out.println("enter a 4-by-4 matrix row by row:");
    	for(int i=0;i<matrix.length;i++){
    		for(int j=0;j<matrix[i].length;j++){
    		matrix[i][j]=scanner.nextDouble();
    			}
    		}
    		System.out.println(sumMajorDiajonal(matrix));
    	}
    	public static double sumMajorDiajonal(double[][] m){
    	double a=0;
    	double sum=0;
    	for(int i=0;i<m.length;i++){
    		for(int j=0;j<m[i].length;j++){
    			if(i==j){
    				a=m[i][j];
    				break;
    				}
    			}
    			sum+=a;
    		}
    		return sum;
    	}
    }

![在这里插入图片描述][20190214222543945.png]  
在这里如果二维数组是一个排好序的二维数组，要进行查找数据，可利用二分法查找，不过，在这里要注意的是利用两次二分法，第一次查找数据可能存在的行，如果该行存在，那么继续查找该数据，否则直接输出不存在。

import java.util.Scanner;
    class demo2{
    	public static void main(String[] args){
    	int[][] matrix={
    		{1,2,3,4},
    		{4,5,5,6},
    		{6,7,8,9},
    		{9,10,18,20},
    		{20,21,22,24}
    	};
    	int minLine=0;
    	int maxLine=matrix.length-1;
    	int midLine=(minLine+maxLine)/2;
    	Scanner scanner=new Scanner(System.in);
    	int key=scanner.nextInt();
    	while(true){
    		if(matrix[midLine][0]>key){
    		maxLine=midLine-1;
    		}
    		if(matrix[midLine][matrix[0].length-1]<key){
    		minLine=midLine+1;
    		}
    		if(matrix[midLine][0]<=key&matrix[midLine][matrix[0].length-1]>=key){
    			int min=0;
    			int max=matrix[midLine].length-1;
    			int mid=(min+max)/2;
    			while(matrix[midLine][mid]!=key){
    				if(matrix[midLine][mid]<key){
    					min=mid+1;
    					}
    				if(matrix[midLine][mid]>key){
    					max=mid-1;
    					}
    				if(min>=max){
    					System.out.println("找不到");
    					return;
    					}
    				mid=(min+max)/2;
    					}
    				if(matrix[midLine][mid]==key){
    					System.out.println(midLine+" "+mid);
    					return;
    					}
    			}
    		midLine=(minLine+maxLine)/2;
    	
    	if(minLine>=maxLine){
    		System.out.println("行找不到！");
    		return;
    	}
    	}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MzI2NDU2_size_16_color_FFFFFF_t_70 1]  
**这种方法对于任何一种矩阵都适用，下面介绍一种只针对各行列数均相等的方法**  
对于二分法最主要的是数组有序，在一维数组时，很方便利用一次二分法进行查找，那么，在二维数组时有没有办法将二维数组的下标转换为一维数组的下标进行查找计算，显然是有的，例如：matrix\[i\]\[j\]当我们访问matrix\[k\]\[p\]时，我们可以看做我们访问了matrix\[k\*j+p\],这样我们就得到了一维数组的访问。由于这种方法有限制性，所以谨慎使用。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MzI2NDU2_size_16_color_FFFFFF_t_70]: /images/20220322/b6ed3efa2c4d40958102428f90526f40.png
[20190214222543945.png]: /images/20220322/4942df43b03b4d4c9aeb0fddd411b379.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MzI2NDU2_size_16_color_FFFFFF_t_70 1]: /images/20220322/4906cf8679f84ac8805741450b5a9c88.png