常用的Arrays类和二维数组以及二分法的介绍

---恢复内容开始---

1.Array类

Array中包含了许多数组的常用操作，较为常见的有：

（1）快速输出 

import java.util.Arrays;
public class Test{
	public static void main(String[] args){
		
		int[] arr = {1,2,3,4};
		// 数组以字符串形式输出
                //（1）写法1
		String str = Arrays.toString(arr);
		System.out.println(str);
                //（2）写法2 
               System.out.println(Arrays.toString(arr));
　　　　}
}

（2）填充数组（将指定的某个值分配给该数组的每个元素）

import java.util.Arrays;
public class Test{
	public static void main(String[] args){
        int[] arr = {1,2,3,4};
　　　　　//将0分配给arr数组的每一个元素
        Arrays.fill(arr,0);
	System.out.println(Arrays.toString(arr));
        }
}

（3）升序排序（对数组进行快速排序）

import java.util.Arrays;
public class Test{
	public static void main(String[] args){
        int[] arr = {6,5,3,2};
        //快速排列
        Arrays.sort(arr);
	System.out.println(arr);
        }
}

（4）对两个数组进行等值判断（数组相等的条件为：1.长度相等 2.两个数组内的元素对应相等）

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        //对两个数组进行比较，若相等，则返回true。
        int[] arr = {1,2,3,4};
        int[] arr1 = {1,2,3,4};
        System.out.println(Arrays.equals(arr,arr1));
        }
}

 （5）复制数组（1.copyofRange(arr,len) 2.copyofRange(arr,from,to) ）

import java.util.Arrays;
public class Test{
	public static void main(String[] args){
		int[] arr = {1,2,3,5,6};
                //（1）copyOf(arr,len) 
                // 把arr中len个长度的元素复制到新数组。如果len>arr.length,新数组的长度末尾用0填充。
		int[] arr1= Arrays.copyOf(arr,6);
		System.out.println(Arrays.toString(arr1));
		
		//（2） copyOfRange(arr,from,to)
                //   把arr[from,to)范围长度内的元素复制到新数组中。
		int[] arr2 = Arrays.copyOfRange(arr,1,3);
		System.out.println(Arrays.toString(arr2));
	}
}    

   （6）System的复制数组的方法（arraycopy(srcArr,srcPos,destArr,destPos,len)）

      srcArr:要复制的源数组

      srcPos:从srcArr的srcPos位置开始复制

      destArr:复制到的目标数组

      destPos:目标数组从destPos开始存放

      len:从源数组中复制len个长度

int[] arr2 = new int[arr.length];
System.arraycopy(arr,1,arr2,0,3);
System.out.println(Arrays.toString(arr2));

 2.二分法

     二分法查找必须是有序的数组，如果找到返回索引；如果没有找到，返回-插入点-1。插入点就是key应该放到数组的位置。

private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                     long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            long midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

 3.二维数组

3.1.二维数组介绍

二维数组中数组的元素也是数组。

其中外部的数组的元素存的是内部数组的地址。

 

3.2.二维数组的声明

import java.util.Arrays;
public class Test05{
    public static void main(String[] args){
        
        // 二维数组
        //int[]
        // (int[]) []
        
        
        // 【1】声明
        int[][] arr;
        // 【2】初始化一个能存3个一维数组的二维数组
        arr = new int[3][];
        
        // 【3】赋值
        int[] arr1 = {1,3,4,5};
        int[] arr2 = {1,3,4};
        int[] arr3 = {2,1,6,4};
        
        arr[0] = arr1;
        arr[1] = arr2;
        arr[2] = arr3;
        
        System.out.println(arr);
        System.out.println(Arrays.toString(arr));
    }
}
此时arr = new int[3][];只分配了二维数组的空间，一维数组没有分配空间。

声明一个规则的二维数组
import java.util.Arrays;
public class Test06{
    public static void main(String[] args){
        
        // 声明一个规则的二维数组，3行4列
        int[][] arr;
        arr = new int[3][4];
        
        arr[0][0] = 10;
        arr[0][1] = 20;
        arr[0][2] = 30;
        arr[0][3] = 40;
        
        arr[1][0] = 100;
        arr[1][1] = 200;
        arr[1][2] = 300;
        arr[1][3] = 400;
        
        arr[2][0] = 1000;
        arr[2][1] = 2000;
        arr[2][2] = 3000;
        arr[2][3] = 4000;
        
        System.out.println(Arrays.toString(arr));
    }
}

当二维数组为已知数值，可使用字面量声明

import java.util.Arrays;
public class Test07{
	public static void main(String[] args){
		
		// 声明字面量二维数组
		int[][] arr = {
			{10,20,30,40},
			{100,200,300},
			{1000,2000,3000,4000}
		};
		System.out.println(Arrays.toString(arr));
	}
}

3.3.二维数组的遍历

二维数组是行列结构，使用双层for循环，外层for用于控制行，内层for用于控制列

import java.util.Arrays;
public class Test08{
	public static void main(String[] args){
		
		// 声明字面量二维数组
		int[][] arr = {
			{10,20,30,40},
			{100,200,300},
			{1000,2000,3000,4000}
		};
		// System.out.println(Arrays.toString(arr));
		
		/*
		for(int i=0;i<arr.length;i++){
			int[] t = arr[i];
			for(int j=0;j<t.length;j++){
				System.out.print(t[j]+"\t");
			}
			System.out.println();
		}
		*/
		
		
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr[i].length;j++){
				System.out.print(arr[i][j]+"\t");
			}
			System.out.println();
		}
	}
}