数组

1 数组: 本质上就是让我们能 “批量” 创建相同类型的变量.

2 创建数组:

定义 加赋值, [] 里面不能写数组大小.
(1) 动态初始化: int[] arr1 = new int[]{1, 2, 3};
(2) 静态初始化: int[] arr2 = {1, 2, 3};

定义 但不赋值, [] 里面可以写数组大小.
int[] arr1 = new int[3]; 初始默认里面的元素 都为0.

3 数组的使用
(1) arr.length能够获取到数组的长度.
(2) 数组下标从0开始,下标的访问不能超出有效范围[0,length-1],如果超出有效范围就会出现下标越界异常. 使用数组一定要下标谨防越界.

4 for-each 遍历数组(更方便,推荐使用)

int[] arr = {1, 2, 3};
for (int x : arr) {
    System.out.println(x);
}

5 数组是引用类型,也属于一个new出来的对象.
6 null在 java中表示 “空引用” , 也就是一个无效的引用.一旦尝试读写, 就会抛出 NullPointerException异常.

7 JVM与数组的关系.

8 (1) 打印数组: Arrays.toString(). 也就是把数组转字符串输出, 输出格式为 [1,2,3,4,5,6].

int[] arr = {1,2,3,4,5,6};
String str = Arrays.toString(arr);
System.out.println(str);        [1, 2, 3, 4, 5, 6]

实现自己版本的数组转字符串(就是拼接字符串)

public static String toString(int[] arr) {
    String ret = "[";
    for (int i = 0; i < arr.length; i++) {
        ret += arr[i];
        if (i != arr.length - 1) {
            ret += ", ";
       }
   }
    ret += "]";
    return ret;

(2) toArray(). 集合转为数组.

Collection<String> collection=new ArrayList<>();
collection.add("我");
collection.add("爱");
collection.add("计算机");
Object[] array=collection.toArray();

9 Arrays.copyOf(). 数组拷贝. copyOfRange(), 自定义拷贝范围.
相比于 arr2= arr 这样的 赋值, copyOf 是将数组进行了 深拷贝. 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组,不会影响到新数组.

int[] arr = {1,2,3,4,5,6};
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
// 拷贝某个范围. 
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));

实现自己版本的数组拷贝

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; }

10 二分查找的效率很高, 但前提是数组必须是 有序数组.

 public static int binarySearch(int[] arr, int toFind) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (toFind < arr[mid]) {
                // 去左侧区间找
                right = mid - 1;
            } else if (toFind > arr[mid]) {
                // 去右侧区间找
                left = mid + 1;
            } else {
                // 相等, 说明找到了
                return mid;
            }
        }
        // 循环结束, 说明没找到
        return -1;
    }

11 Arrays.sort(). 默认是 升序排序的. 是Java内置的 高效的数组排序算法,

public static void main(String[] args) { 
 int[] arr = {9, 5, 2, 7}; 
 Arrays.sort(arr); 
 System.out.println(Arrays.toString(arr)); 
}

12 数组逆序.
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素. 然后让前一个下标自增,后一个下标自减,循环执行.

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

13 练习: 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变.

public class Solution {
    public void reOrderArray(int [] array) {
        int k=0;
        for(int i=0;i<array.length;i++){
            if(array[i]%2==1){
                int tmp=array[i];
                int j=i;
                while (j>k){     // 注意循环条件
                    array[j]=array[j-1];  //将该奇数之前的内容(偶数序列), 整体后移一个位置
                    j--;
                }
                array[k++]=tmp;
            }
        }
    }
}

14 二维数组. 定义及相关长度.

	int[][] arr = new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
	int[][] arr = new int[3][5];
    int[][] arr1 = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    System.out.println(arr.length); // 3
    System.out.println(arr[0].length); // 4
    System.out.println(arr[2][3]); // 12