数组的使用

字符串

数组转字符串

Arrays.toString

import java.util.Arrays 
int[] arr = {1,2,3,4,5,6}; 
String newArr = Arrays.toString(arr); 
System.out.println(newArr); 
// 执行结果 [1, 2, 3, 4, 5, 6]

java提供了java.util.Arrays包，其中含了一些操作数组的使用方法

模拟实现toString

public static String myToString(int[] array) {
        //Java 里面也有assert
        if(array == null) return "null";
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret += array[i];
            if(i != array.length-1) {
                ret += ", ";
            }
        }
        ret+="]";
        return ret;
   }

数组拷贝

Arrays.copyOf（可以扩容）扩容部分值为0

修改拷贝之后的数组不影响原来的数组就说这个拷贝是深拷贝，反之就是浅拷贝。

一般来说拷贝基本数据类型（值）就是深拷贝，拷贝引用类型（地址）如数组就是浅拷贝。

深拷贝

 浅拷贝

public static void func(){ 
int[] arr = {1,2,3,4,5,6}; 
int[] newArr = arr; 
newArr[0] = 10; 
System.out.println("newArr: " + Arrays.toString(arr))

// newArr和arr引用的是同一个数组 
// 因此newArr修改空间中内容之后，arr也可以看到修改的结果 

newArr引用只是指向了arr的对象并没有发生拷贝 

arr[0] = 1; 
newArr = Arrays.copyOf(arr, arr.length); 
System.out.println("newArr: " + Arrays.toString(newArr));

// 使用Arrays中copyOf方法完成数组的拷贝： 
// copyOf方法在进行数组拷贝时，创建了一个新的数组 
// arr和newArr引用的不是同一个数组

copyOf方法内部

在使用copyOf方法时重新创建了一个新的数组。

Object可以接收任何类型，是祖先类。

copyOfRange

当只需要拷贝部分内容时，使用copyOfRange

int[] newArr2 = Arrays.copyOfRange(arr, 2, 4); 
System.out.println("newArr2: " + Arrays.toString(newArr2)); }

表示拷贝arr的[2,4）下标的数组，一般都是左闭右开区间

模拟实现拷贝数组

public static int[] copyOf(int[] arr) { 
int[] ret = new int[arr.length]; 
for (int i = 0; i < arr.length; i++) 
{ 
ret[i] = arr[i]; 
}
return ret; 
}

顺序查找某个元素

Arrays.binarySearch(数组，元素）

前提是升序

二分查找

public static int binarySearch(int[] array,int key) {
        int left = 0;
        int right = array.length-1;
        while (left <= right) {
            int mid = (left+right)/2;
            if(array[mid] == key) {
                return mid;
            }else if(array[mid] < key) {
                left = mid+1;
            }else{
                right = mid-1;
            }
        }
        return -1;
    }

冒泡排序

冒泡排序的性能较低，java内置一个高效排序法Arrays.sort（数组）

冒泡排序

 public static void bubbleSort(int[] array) {
        //boolean flg = false;
        //i代表的是趟数
        for (int i = 0; i < array.length-1; i++) {
            //j每一趟都从0开始
            boolean flg = false;
            for(int j = 0;j < array.length-1-i;j++) {
                if(array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if(flg == false) {
                return;
            }
        }
    }

数组逆序

public static void reverse(int[] array) {
        int left = 0;
        int right = array.length-1;
        while (left < right) {
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
            left++;
            right--;
        }
    }

二维数组 

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

 引用变量二维数组存放了两个引用变量

foreach指的是将一个变量里面的东西存放在前面的变量中

将二维数组转换成字符串 

Arrays.deepToString

Arrays.fill可以对数组初始化特定元素