数组

数组

1.数组的基本用法

1.1什么是数组

数组本质上就是多个相同类型的变量。

1.2数组的创建

基本类型:

动态初始化：

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

静态初始化：

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

代码示例：

int arr = new int[];//动态初始化
int arr = {1,2,3};//静态初始化
int[] arr = {1,2,3,4,5};

1.3数组的使用

代码示例：

int[] arr = {1, 2, 3, 4, 5};

        //获取数组长度
        System.out.println(arr.length);

        System.out.println(arr[0]);//1
        System.out.println(arr[1]);//2
        System.out.println(arr[2]);//3
        System.out.println(arr[3]);//4
        arr[4] = 100;
        System.out.println(arr[4]);//100
        System.out.println(arr[5]);//ArrayIndexOutOfBoundsException数组越界异常

注意事项:

​ 1.使用arr.length能够获取到数组的长度，"."这个操作为成员访问操作符。

​ 2.使用[]按下标取数组元素，下标从0开始。

​ 3.使用[]操作既能读取数据，也能修改数据。

​ 4.下标访问不能超出有效范围[0,length-1],否则会越界异常。

代码示例：使用for循环遍历数组

for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

代码示例：增强For循环遍历数组

for (int i:arr) {
            System.out.print(i+" ");
        }

代码示例：Arrays.toString遍历数组

System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5]

注意问题：

		int[] arr1 = {};
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);//什么打印都没有
        }
        System.out.println(arr1[0]);//数组越界

2.数组作为方法参数

2.1基本用法

代码示例：

 public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        printArray(arr1);
    }

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

arr是形参，arr1是实参

2.2引用类型

代码示例：参数传内置参数

 public static void main(String[] args) {
        int num = 20;
        fun(num);
        System.out.println("num="+num);
    }
    public static void fun(int n) {
        n = 10;
        System.out.println("n="+n);
    }

形参的值不影响实参的改变。

代码示例：参数传数组类型

 public static void main(String[] args) {
        int[] array = {1, 2, 3};
        fun(array);
        System.out.println("array[0]=" + array[0]);
    }

    public static void fun(int[] arr) {
        arr[0] = 123;
        System.out.println("arr[0]=" + arr[0]);
    }
//打印结果
arr[0]=123
array[0]=123

在函数内部修改数组内容，函数外部也发生变化。array是一个“引用”，当传参的时候，是按照引用传参。

**总结：**所谓的“引用”本质上只是存了一个地址

2.3认识null

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

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

会抛出空指针异常。

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

代码示例：

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(print(array)));
    }
    public static int[] print(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i] * 2;
        }
        return ret;
    }

数组是引用类型，返回的时候是将这个数组的地址返回。

4.数组练习

练习1：数组转字符串

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(myToString(arr));
    }
    
    public static String myToString(int[] arr) {
        if (arr == null) {
            return "";
        }
        if (arr.length == 0) {
            return "[]";
        }
        String ret = "[";
        for (int i = 0; i < arr.length; i++) {
            ret = ret + arr[i];
            if (i != arr.length - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

4.数组练习

4.1数组转字符串

Java提供的Arrays包

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

    }
//执行结果
[1, 2, 3, 4, 5]

自己写的代码，字符串拼接

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

4.3拷贝数组

自己的方法

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

用工具类的方法拷贝

public class ArrayDemo09 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        //int[] copy = Arrays.copyOf(array, array.length);
        int[] copy = new int[array.length];
        System.arraycopy(array,0,copy,0,array.length);
    }
    public static int[] copy(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i];
        }
        return ret;
    }
}

4.4求数组的平均值

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

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

public static int toFind(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;
    }

4.7检查数组的有序性

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

4.8数组排序（冒泡排序）

public static void bubbly(int[] arr) {
        boolean flag = false;//默认没发生交换
        for (int i = 0; i < arr.length - 1; i++) {
            flag = false;//每一趟都有可能没有交换
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag = false) {
                break;
            }
        }
    }

4.9数组逆序

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

4.10数组数字排列

 public static void transform(int[] arr) {
        int l = 0;
        int r = arr.length - 1;
        while (l < r) {
            while (l < r && arr[l] % 2 == 0) {
                l++;
            }
            while (l < r && arr[r] % 2 != 0) {
                r--;
            }
            int temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
        }
    }