Java数组，数组的应用

1.数组基本用法

1.1 什么是数组

数组就是相同数据类型的集合。
注意事项: 在 Java 中, 数组中包含的变量必须是 相同类型

1.2 创建数组

  public static void main2(String[] args) {
    
    
        int[] array = {
    
    1, 2, 3, 4, 5, 6, 7};//静态初始化
        int[] array2 = new int[3];//动态初始化，默认值0
        int[] array3 = new int[]{
    
    1, 2, 3, 4, 5};
    }

数组定义不能指明其大小。

1.3 数组的使用

 public static void main3(String[] args) {
    
    
        int[] array = {
    
    1, 2, 3, 4, 5, 6, 7};
        // System.out.println(array.length);//7
        System.out.println(array[3]);//4
        array[3] = 19;
        System.out.println(array[3]);//19

    }

注意事项

1. 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
2. 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
3. 使用 [ ] 操作既能读取数据, 也能修改数据.
4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常

遍历数组：for循环，for each，还有就是Arrays.toString(数组名)

 public static void main4(String[] args) {
    
    
        int[] array = {
    
    1, 2, 3, 4, 5, 6};
        for (int i = 0; i < array.length; i++) {
    
    
            System.out.print(array[i] + " ");
        }
        System.out.println();
        for (int x : array) {
    
    //增强for循环
            System.out.print(x + " ");
        }
        System.out.println();
        //借助Arrays的toString()方法，返回值是String
        String ret = Arrays.toString(array);
        System.out.println(ret);
        System.out.println(Arrays.toString(array));
    }

2. 数组作为方法的参数

2.1 基本用法

打印数组内容

public static void printf(int[] array) {
    
    
    for (int i = 0; i < array.length; i++) {
    
    
        System.out.print(array[i] + " ");
    }
    System.out.println();
}

public static void main6(String[] args) {
    
    
    int[] array = {
    
    1, 2, 3, 4, 5, 6};
    printf(array);//按引用传递，或者按值传递
}

2.2 理解引用类型(重点/难点)

 public static void func1(int[] array) {
    
    
        array = new int[]{
    
    11, 2, 13, 4, 51, 61};
    }

    public static void func2(int[] array) {
    
    
        array[0] = 899;
    }

    public static void main7(String[] args) {
    
    
        int[] array = {
    
    1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.toString(array));
        func1(array);
        System.out.println(Arrays.toString(array));//1,2,3,4,5,6
        func2(array);
        System.out.println(Arrays.toString(array));//899,2,3,4,5,6
    }

总结: 所谓的 “引用” 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).

2.3 认识 null

null 在 Java 中表示 “空引用” , 也就是一个无效的引用

int[] arr = null; 
System.out.println(arr[0]);
 // 执行结果 Exception in thread "main" java.lang.NullPointerException at Test.main(Test.java:6)

2.4 初识 JVM 内存区域划分(重点)

局部变量和引用保存在栈上, new 出的对象保存在堆上.
堆的空间非常大, 栈的空间比较小.
堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈)

3. 数组作为方法的返回值

将数组作为方法返回值，将数组元素扩大到原来的2倍

 public static int[] transform(int[] array) {
    
    
        int[] ret = new int[array.length];
        for (int i = 0; i < array.length; i++) {
    
    
            ret[i] = 2 * array[i];
        }
        return ret;
    }

    public static void main10(String[] args) {
    
    
        int[] array = {
    
    1, 2, 3, 4, 5};
        //func(array);
        int[] ret = transform(array);
        System.out.println(Arrays.toString(ret));
    }

4. 数组练习

4.1 数组转字符串

前面数组转为字符串可以用Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法。
下面我自己定义一个方法myToString

 public static String myToString(int[] arr) {
    
    
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
    
    
            if (i != arr.length - 1) {
    
    
                str = str + arr[i] + '，';
            } else {
    
    
                str = str + arr[i] + ']';
            }
        }
        return str;
    }//[1,2,3,4,5]

    public static void main11(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5};
        System.out.println(myToString(arr));
    }

4.2 找数组中的最大元素

将数组第一个元素初始化为最大值max，从第二个元素比较，如果有比max更大的，就将max更新。

 private static int maxNum(int[] array) {
    
    
        if (array == null)
            return -1;
        if (array.length == 0)
            return -1;
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
    
    
            if (array[i] > max)
                max = array[i];
        }
        return max;
    }


    public static void main12(String[] args) {
    
    
        int[] array = {
    
    12, 8, 1, 2, 10};
        System.out.println(maxNum(array));
    }

4.3查找数组中指定元素(顺序查找)

 public static void main13(String[] args) {
    
    
        int[] arr = {
    
    12, 3, 67, 88, 45};
        System.out.println(findNum(arr, 88));
    }

    private static int findNum(int[] arr, int key) {
    
    
        for (int i = 0; i < arr.length; i++) {
    
    
            if (arr[i] == key)
                return i;
        }
        return -1;
    }

4.6 查找数组中指定元素(二分查找)

针对有序数组, 可以使用更高效的二分查找.

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


    public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 15, 17};
        System.out.println(binarySearch(arr, 15));
    }

4.7 检查数组的有序性（升序）

是有序返回true,否则返回false

public static boolean isUp(int[] arr) {
    
    
    for (int i = 0; i < arr.length - 1; i++) {
    
    
        if (arr[i] > arr[i + 1]) {
    
    
            return false;
        }
    }
    return true;
}

public static void main(String[] args) {
    
    
    int[] arr={
    
    34,56,78,23,90,76};
    System.out.println(isUp(arr));
}

4.8 数组排序(冒泡排序)

 public static void bubbleSort(int[] arr) {
    
    
        for (int i = 1; i <arr.length ; i++) {
    
    
            boolean flg=false;
            for (int j = 0; j < arr.length-i; j++) {
    
    
                if(arr[j]>arr[j+1]){
    
    
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                    flg=true;
                }
            }
            if(flg==false){
    
    
                break;
                //return;
            }
        }
    }
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    11, 34,78, 15};
        /*boolean flg = isUp(arr);
        System.out.println(flg);*/
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

冒泡排序性能较低. Java 中内置了更高效的排序算法Arrays.sort(arr);
**Arrays.sort(arr)**将数据从小到大排列

public static void main(String[] args) {
    
    
        int[] arr = {
    
    11, 34,78, 15};
        /*boolean flg = isUp(arr);
        System.out.println(flg);*/
        //bubbleSort(arr);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

4.9 数组逆序

设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可.

private 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--;
        }
    }
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

4.10 数组数字排列

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分

思路：设定两个下标分别指向第一个元素和最后一个元素.用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素.依次循环即可。

public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5, 6};
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void transform(int[] arr) {
    
    
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
    
    
            // 该循环结束, left 就指向了一个奇数
            while (left < right && arr[left] % 2 == 0) {
    
    
                left++;
            }// 该循环结束, right 就指向了一个偶数
            while (left < right && arr[right] % 2 != 0) {
    
    
                right--;
            }// 交换两个位置的元素
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
        }
    }

4.10 数组的拷贝

1.

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

    public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5, 6};
        int[] ret = copyArr(arr);
        System.out.println(Arrays.toString(ret));

    }

****2.Arrays.copyOf(,)方法

 public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5, 6};
        int[] ret = Arrays.copyOf(arr, arr.length);
        System.out.println(Arrays.toString(ret));
    }

局部拷贝：

 public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5, 6};
        // int[] ret = Arrays.copyOf(arr, arr.length);
        int[] ret = Arrays.copyOfRange(arr, 0, 4);
        System.out.println(Arrays.toString(ret));
    }

3.System.arraycopy()方法

 public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5, 6};
        int[] copy = new int[arr.length];
        System.arraycopy(arr, 0, copy, 0, arr.length);
        // int[] ret = Arrays.copyOf(arr, arr.length);
        // int[] ret = Arrays.copyOfRange(arr, 0, 4);
        System.out.println(Arrays.toString(copy));
    }

4.产生对象副本clone()

 public static void main(String[] args) {
    
    
        int[] arr = {
    
    1, 2, 3, 4, 5, 6};
        int[] copy=arr.clone();
        System.out.println(Arrays.toString(copy));
    }

深拷贝是拷贝对象，不对对象做拷贝，只是拷贝地址，前面都是浅拷贝
需要看拷贝的是什么，才能决定是深拷贝还是浅拷贝

5. 二维数组

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

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

二维数组的3种打印方式：

 public static void main(String[] args) {
    
    
        int[][] arr = {
    
    {
    
    1, 2, 3, 4}, {
    
    5, 6, 7, 8}, {
    
    9, 10, 11, 12}};//[][]中不能加数字
        //int[][] arr2 = new int[][]{
    
    {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        for (int i = 0; i < arr.length; i++) {
    
    
            for (int j = 0; j < arr[i].length; j++) {
    
    
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();

        }
        System.out.println("==================");
        for (int[] ret : arr) {
    
    
            for (int x : ret) {
    
    
                System.out.print(x + " ");
            }
            System.out.println();
        }
        System.out.println("===================");
        System.out.println(Arrays.deepToString(arr));
    }

数组的应用：

public static void main2(String[] args) {
    
    
        int[][] arr = {
    
    {
    
    1, 2}, {
    
    4, 5, 6}};//[][]中不能加数字
        /*for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();

        }*/
       /* System.out.println("==================");
        int[][] arr2=new int[2][];
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j] + " ");
            }
            System.out.println();

        }*/
        int[][] arr2 = new int[2][];
        arr2[0]=new int[3];
        arr2[1]=new int[2];
        for (int i = 0; i < arr2.length; i++) {
    
    
            for (int j = 0; j < arr2[i].length; j++) {
    
    
                System.out.print(arr2[i][j] + " ");
            }
            System.out.println();

        }
    }