JAVA数组

什么是数组数组

数组本质上就是让我们能 “批量” 创建相同类型的变量.
注意事项: 在 Java 中, 数组中包含的变量必须是 相同类型.

创建数组

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };

 public class Yyyfh {
    public static void main(String[] args) {

       
            int[] array = {9};//[]里面不能写数字；
            int[] array2 = new int[3];
            int[] arr = new int[]{1, 2, 3};
        }
    }

注意事项: 静态初始化的时候, 数组元素个数和初始化数据的格式是一致的
其实数组也可以写成
int arr[] = {1, 2, 3};
这样就和 C 语言更相似了. 但是我们还是更推荐写成 int[] arr 的形式. int和 [] 是一个整体.

数组的使用

在JAVA中怎么怎么计算数组的长度

public class Yyyfh {
    public static void main(String[] args) {

            int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
            System.out.println(array.length);//计算数组的长度
            System.out.println(array[3]);
            System.out.println(array[7]);
            //array[3]=16;//写一些数据
            System.out.println(array[3]);
        }
        
        }

增强for循环

 public static void main9(String[] args) {
        int[] array = {1, 2, 3, 4};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i] + "");
        }
        System.out.println();
        for (int x : array) {//增强for循环forch;
            System.out.println(x + "");
        }
        System.out.println();

    }

for循环可以拿到下标
for each 拿不到下标

数组赋值机制

1基本数据类型赋值，这个值就是具体的数据，而且相互不影响。 int n1 = 2; int n2 = n1;
2数组在默认情况下是引用传递，赋的值是地址。

在JAVA中一个引用只能指向一个对象，不能同时指向多个对象

数组作为方法的参数

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    printArray(arr);
}
 
public static void printArray(int[] a) {
    for (int x : a) {
        System.out.println(x)

理解引用类型

认识null

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

public class Yyyfh {
    public static void main(String[] args) {
        int[] arr = null;
        System.out.println(arr[0]);


    }
}

初识 JVM 内存区域划分

数组

数组转字符串

import java.util.Arrays;
public class Yyyfh {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,6};

        String newArr = Arrays.toString(arr);
        System.out.println(newArr);


    }
}

我们可以得到{1,2，3,4，5，6,}

数组拷贝

import java.util.Arrays;
public class Yyyfh {
    public static void main(String[] args) {
        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));


    }
}

找数组中的最大元素

mport java.util.Arrays;
public class Yyyfh {
    public static void main(String[] args) {

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

        public static int max(int[] arr) {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;


    }
}

求数组中元素的平均值

import java.util.Arrays;
public class Yyyfh {
    public static void main(String[] args) {
            int[] arr = {1,2,3,4,5,6};
            System.out.println(avg(arr));
        }

        public static double avg(int[] arr) {
            int sum = 0;
            for (int x : arr) {
                sum += x;
            }
            return (double)sum / (double)arr.length;
        }

    }

顺序查找

import java.util.Arrays;
public class Yyyfh {


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

    public static int find(int[] arr, int toFind) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == toFind) {
                return i;
            }
        }
        return -1;  // 表示没有找到
    }
        }

二分查找

import java.util.Arrays;
public class Yyyfh {
    static int count = 0;
    public static void main(String[] args) {

                int[] arr = makeBigArray();
                int ret = binarySearch(arr, 9999);
                System.out.println("ret = " + ret + " count = " + count);
            }

            public static int[] makeBigArray() {
                int[] arr = new int[10000];
                for (int i = 0; i < 10000; i++) {
                    arr[i] = i;
                }
                return arr;
            }

            public static int binarySearch(int[] arr, int toFind) {
                int left = 0;
                int right = arr.length - 1;
                while (left <= right) {

                    count++;    // 使用一个变量记录循环执行次数

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

检查数组的有序性

import java.util.Arrays;
public class Yyyfh {
    public static void main(String[] args) {

            int[] arr = {1,2,3,10,5,6};
            System.out.println(isSorted(arr));
        }

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

二维数组

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

数组的基本语法

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

数组的表示

public class Yyyfh {
    public static void main(String[] args) {
        int[][] arr = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}
        };

        for (int row = 0; row < arr.length; row++) {
            for (int col = 0; col < arr[row].length; col++) {
                System.out.printf("%d\t", arr[row][col]);
            }
            System.out.println("");
        }
    }
        }