【Java学习笔记】（七）Java里的数组

以你之姓@ 2023-02-14 02:44 6阅读 0赞

### Java数组 ###

*  一、一维数组
 *   *  1.计算机语言中的数组具有三大特性
     *  2.Java数组声明
     *  3.一维数组的初始化
     *  4.一维数组合并
 *  二、多维数组
 *   *  1.二维数组声明
     *  2.二维数组的初始化
 *  三、不规则数组

# 一、一维数组 #

## 1.计算机语言中的数组具有三大特性 ##

①一致性：数组只能保存相同的数据类型，元素的数据类型可以是任何相同的数据类型。  
②有序性：数组中的元素是有序的，通过下标访问。  
③不可变性：数组一旦初始化，长度不可变。

## 2.Java数组声明 ##

元素数据类型\[ \] 数组变量名；  
元素数据类型 数组变量名\[ \]；

int array[];
    float[] array;
    String array[];
    Date[] dateArray;

## 3.一维数组的初始化 ##

（1）静态初始化  
静态初始化就是将数组的元素放到大括号中。

int[] array;
    //静态初始化数组
    array={ 1,2,3,4,5,6,7};
    String[] arr;
    //静态初始化数组
    arr={ "张三","李四","王五"};
    //声明的同时并静态初始化
    int Array[]={ 1,2,3,4,5,6,7,8};
    String Arr[]={ "张三","李四","王五"};

（2）动态初始化  
动态初始化使用new运算符分配指定长度的内存空间。

int array[];
    //动态初始化数组
    array=new int[4];
    array[]={ 0,1,2,3};
    //声明并动态初始化数组
    int Array[]=new int[4];
    Array[]={ 1,2,4,5};

## 4.一维数组合并 ##

数组的长度是不变的，想要合并两个不同的数组，就要创建一个新的数组，新数组的长度是两个数组的长度之和。

public class HelloJava{ 
    	public static void main(String args[]){ 
    		int array1[]={ 1,2,3,4,5};
    		int array2[]={ 6,7,8,9};
    		int array[]=new int[array1.length+array2.length]
    		for(int i=0;i<array.length;i++){ 
    			if(i<array.length) 
    				array[i]=array1[i];
    			else 
    				array[i]=array2[i-array1.length];
    		}
    		System.out.println("合并后的数组为:");
    		for(int element:array)
    		System.out.println("%d",element);
    	}
    }

# 二、多维数组 #

## 1.二维数组声明 ##

语法如下：  
元素数据类型\[ \]\[ \] 数组变量名；  
元素数据类型 数组变量名\[ \]\[ \]；  
元素数据类型\[ \] 数组变量名\[ \]；

int array[][];
    int[][] array;
    int[] array[];

## 2.二维数组的初始化 ##

（1）静态初始化

int array[][]={ 
    	{ 1,2,3},
    	{ 4,5,6},
    	{ 7,8,9},
    	{ 10,11,12}
    }//创建4X3二维数组并静态初始化

（2）动态初始化

int[][] array=new int[4][3];
    array[][]={ 
    	{ 1,2,3},
    	{ 4,5,6},
    	{ 7,8,9},
    	{ 10,11,12}
    }
    实例：计算二维数组每个元素的平方根
    
    ```c
    public class Sakura{ 
    	public static void main(String args[]){ 
    			int[][] array=new int[4][3];
    			array[][]={ 
    				{ 1,2,3},
    				{ 4,5,6},
    				{ 7,8,9},
    				{ 10,11,12}
    				};
    			double Array[][]=new double[4][3];
    			for(int i=0;i<intArray.length;i++){ 
    				doubleArray[i][j]=Math.sqrt(array[i][j]);
    			}
    			//打印数组
    			for(int i=0;i<Array.length;i++)
    				for(int j=0;j<Array[i].length;j++)
    					System.out.printf(Array[i][j]);
    				System.out.print("\n");
    		}
    	}
    }

# 三、不规则数组 #

例如：在一个二维数组中，每一个一维数组的长度不同  
（1）静态初始化不规则数组

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

（2）动态初始化不规则数组

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

（3）不规则数组实例

public class HelloWorld{ 
    	public static void main(String args[]){ 
    		int intArray[][]=new int[4][];
    		intArray[0]=new int[2];
    		intArray[1]=new int[1];
    		intArray[2]=new int[3];
    		intArray[3]=new int[3];
    		for(int i=0;i<intArray.length;i++)
    			for(int j=0;j<intArray[i].length;j++)
    				intArray[i][j]= i+j;
    		for(int[] row:intArray){ 
    			for(int element:row){ 
    				System.out.print(element);
    				System.out.print('\t);
    			}
    			System.out.println();
    		}
    	}
    }

（4）不规则数组越界  
在不规则数组初始化后，访问不存在的元素会产生下标越界异常。

如果觉得文章不错的话，记得三连哦！