Java学习笔记-java数组基本操作及Arrays类

- 日理万妓 2022-05-16 01:50 208阅读 0赞

*  # Java学习笔记-数组基本操作及Arrays类 #

--------------------

*  ## 数组的基本操作： ##

### 一维数组的创建及初始化： ###

**a.先声明再分配内存**

**b.声明同时分配内存**

**c.分配内存同时初始化是不用向“ \[\] ”填数组大小的，系统取决“\{\}”中的数据进行内存分配**

**d.My Puzzle：数据类型\[\] 数组名  等价于 数据类型 数组名\[\]**

//1D Array
    		//先声明再分配内存
    		int[] Arr1;
    		int _Arr1[];
    		Arr1=new int[] {1,2,3};  //分配内存同时初始化
    		_Arr1=new int[4];       //先分配内存后初始化
    		
    		//声明同时分配内存
    		int Arr2[]=new int[4];   
    		int[] _Arr2=new int[] {1,2,1,1};   //同时初始化

### 二维数组的创建及初始化 ###

二维数组是一维数组的延申，只不过把***一维的每个元素看成一维数组***

声明分配内存同一维思路

**a.可逐行分配内存，先分配出行元素（一个一维），然后在一维基础上扩展成二维**

//2D Array
    		//先声明再分配内存
    		int [][] Arr3;
    		int _Arr3[][];
    		
    		Arr3=new int[2][4];
    		_Arr3=new int[][] {
       {1,2,3,4},{1,2,3,4}};   //分配内存同时初始化
    		
    		//逐行分配内存
    		int Arr4[][];
    		Arr4=new int[2][];
    		Arr4[0]=new int[4];
    		Arr4[1]=new int[4];
    		
    		//声明同时分配内存和初始化
    		int _Arr4[][]=new int[][] {
       {4,8,3,6},{0,9,2,6}};

### 数组遍历： ###

**a.for语句进行遍历：java较c++方便的一点是提供的功能强大的类，在数组大小方面内置length**

**length：对于二维，行数=Array.length,，每一列的长度=Array\[i\].length**

//遍历一维
    		for(int i=0;i<_Arr2.length;i++)
    			System.out.print(_Arr2[i]+" ");
    		System.out.println();
    //遍历二维
    		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();
    		}

**b.foreach语句进行遍历：foreach是对for的补充和部分功能加强，使得代码简介**

**上一篇博客有详细介绍：[Java学习笔记-foreach语句][Java_-foreach]**

--------------------

*  ## Arrays类 ##

### 所属文件：import java.util.Arrays ###

### 填充替换数组元素：fill() ###

**a.用法1：Arrays.fill(type\[\]a,type value)**   ***a:进行元素替换的数组 value：替换值 type：数据类型***

**作用：将数组a每一个元素都替换成value**

//fill(int[]a,int value)
    		int[] Array1=new int[10];
    		Arrays.fill(Array1,19980926);
    		System.out.println("After fill :");
    		for(int x:Array1) {
    			System.out.print(x+" ");
    		}
    		System.out.println();
    
    /*输出：
    After fill :
    19980926 19980926 19980926 19980926 19980926 19980926 19980926 19980926 19980926 19980926 
    */

**a.用法2：Arrays.fill(type\[\] a,int fromIndex,int toIndex,type value)**

***作用：将数组索引为 fromIndex~toIndex-1的元素替换成value***

**注意：索引位置范围要在数组长度内，否则会报错：ArrayIndexOutOf-BoundsException 数组越界**

//fill(int[]a,int fromIndex,int toIndex,int value)
    		int Array2[]=new int[10];
    		Arrays.fill(Array2,2,6,19980926);
    		for(int i=0;i<Array2.length;i++) {
    			System.out.println("第"+i+"个元素是："+Array2[i]);
    		}
    /*
    第0个元素是：0
    第1个元素是：0
    第2个元素是：19980926
    第3个元素是：19980926
    第4个元素是：19980926
    第5个元素是：19980926
    第6个元素是：0
    第7个元素是：0
    第8个元素是：0
    第9个元素是：0
    */

### 对数组排序 ###

**a.Arrays.sort(Object)**   ***Obejct：进行排序的对象***

***sort默认升序！！！***

//Arrays.sort(Object)   默认升序
    		int Array3[]=new int[] {2,1,6,5,3};
    		Arrays.sort(Array3);
    		for(int x:Array3) {
    			System.out.print(x+" ");
    		}
    		System.out.println();
    
    //1 2 3 5 6

### 复制数组 ###

**a.Arrays.copyOf(arr,int newlength)**   ***arr：被复制的数组 newlength：新数组的长度***

**注意：若newlength对于原数组长度，新数组比原数组多出的部分元素为0**

**b.Arrays.copyOfRange(arr,int fromIndex,int toIndex)** ：***复制arr fromIndex~toIndex-1部分***

**注意：**fromIndex必须位于0~length-1之间，否则会越界，toIndex必须大于fromIndex（无上界，大于长度部分元素为0）

//copyOf()
    		
    		//copyOf(arr,int newlength),大于arr长度，多出部分元素补0
    		int Array4[]=new int[] {0,9,2,6};
    		int Temp_Array1[]=Arrays.copyOf(Array4,5);
    		for(int x:Temp_Array1) {
    			System.out.print(x+" ");
    		}
    		System.out.println();
    		
    		//copyOfRange(arr,int formIndex,int toIndex)    //多出部分补0，fromIndex必须在0-length之间
    		int Temp_Array2[]=Arrays.copyOfRange(Array4, 0, 3);
    		for(int x:Temp_Array2) {
    			System.out.print(x+" ");
    		}
    		System.out.println();
    		Temp_Array2=Arrays.copyOfRange(Array4, 2, 8);
    		for(int x:Temp_Array2) {
    			System.out.print(x+" ");
    		}
    		System.out.println();
    
    /*   
         0 9 2 6 0 
         0 9 2 
         2 6 0 0 0 0 
    */

### **查找数组元素：binarySearch()** ###

***注意：必须对数组进行排序后才能查找！***

**a.Arrays.binarySearch(Object\[\] a,Object key)** ***:查找a中值为key的元素，返回该元素索引***

***注意：①key比a中任何值都小，返回-1 ，key比a中任何值都大，返回 -length()-1***

***②key不是a中的元素，并且key值在大小不为arr中的最大或最小，返回 -1\*(第一个大于key的元素索引+1）***

//binarySearch(Object[] a,Object key)
    		int[] Array5=new int[] {4,8,3,6};
    		Arrays.sort(Array5);   //3 4 6 8
    		int index=Arrays.binarySearch(Array5, 1);
    		System.out.println("1的索引位置为："+index);	//-1
    		index=Arrays.binarySearch(Array5,15);
    		System.out.println("15的索引位置为："+index);		//-1*length()-1
    		index=Arrays.binarySearch(Array5, 5);
    		System.out.println("5的索引位置为："+index);
    
    /*
        1的索引位置为：-1
        15的索引位置为：-5
        5的索引位置为：-3
    */

**b.Arrays.binarySearch(Object\[\] a,int fromIndex,int toIndex,Object key)**：***在 fromIndex~toIndex-1 中查找key***

**注意：①key如果在范围内查找不到，返回** ***-1\*（第一个大于key的索引位置）-1***

//binarySearch(Object[] a,int fromIndex,int toIndex,Object key)
    		index=Arrays.binarySearch(Array5, 0,2,15);
    		System.out.println("15的索引位置为："+index);  //-1*toIndex-1
    		index=Arrays.binarySearch(Array5, 1,3,2);
    		System.out.println("2的索引位置为："+index);    //-1*fromIndex-1
    		index=Arrays.binarySearch(Array5, 2,4,7);   
    		System.out.println("7的索引位置为："+index);   
    
    /*
        15的索引位置为：-3
        2的索引位置为：-2
        7的索引位置为：-4
    */

[Java_-foreach]: https://blog.csdn.net/SZU_Crayon/article/details/81637876