数组---完

数组拷贝

int [] Newarray2 = Arrays. copyOf (array1,4);

（拷贝的数组，拷贝长度）

int [] Newarray3 = Arrays. copyOfRange (array1,2,5);

（拷贝的数组，【拷贝起始下标，结束下标））

左开右闭

import java.util.Arrays;

public class test2026613 {
    public static void main(String[] args) {
       int [] array1 = {1,2,3,4,5,6};
       int [] Newarray2 = Arrays.copyOf(array1,4);
       int [] Newarray3 = Arrays.copyOfRange(array1,2,5);
        System.out.print("原数组：");
        func(array1);
        System.out.print("Arrays.copyOf（）：拷贝的新数组:");
       func(Newarray2);
        System.out.println("Arrays.copyOfRange（）：拷贝的新数组:");
        func(Newarray3);
    }
    public static void func(int [] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        System.out.println("");
    }
}

原数组：123456 Arrays.copyOf（）：拷贝的新数组:1234 Arrays.copyOfRange（）：拷贝的新数组: 345

二分查找

import java.util.Arrays;

public class test2026613 {
    public static void main(String[] args) {
       int [] array = {1,2,3,4,5,6,7,8,9,10};
       int res = binarySearch(array,7);
        System.out.println(res);
    }
        public static int binarySearch(int[] arr, int target) {
            int left = 0;
            int right = arr.length - 1;
            while (left <= right) {
                int mid = (left + right)/ 2; // 避免溢出
                if (arr[mid] == target) {
                    return mid;
                } else if (arr[mid] < target) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            return -1; // 未找到
        }
    }

冒泡排序

import java.util.Arrays;

public class test2026613 {
        public static void main(String[] args) {
            int[] arr = {5, 2, 9, 1, 5, 6};
            System.out.println("排序前：" + Arrays.toString(arr));
            bubbleSort(arr);
            System.out.println("排序后：" + Arrays.toString(arr));
        }
        public static void bubbleSort(int[] arr) {
            int n = arr.length;
            // 外层循环：控制排序趟数，共需 n-1 趟
            for (int i = 0; i < n - 1; i++) {
                boolean swapped = false; // 优化标记：记录本趟是否发生交换
                // 内层循环：每趟将当前未排序部分的最大值"冒泡"到最后
                for (int j = 0; j < n - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        // 交换相邻元素
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        swapped = true;
                    }
                }
                // 如果本趟没有发生任何交换，说明数组已经有序，提前退出
                if (!swapped) {
                    break;
                }
            }
        }
    }

 排序前：[5, 2, 9, 1, 5, 6]
 排序后：[1, 2, 5, 5, 6, 9] 

二维数组

定义

• 每一个 { } 内代表一行，{ } 内元素个数代表列数。

• 不赋值列可以省略，行不可以省略。

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

二维数组画图理解

• 二维数组本质上也是个一维数组，每一个元素又是一个数组。

1. array指向了一维数组a

2. ++a数组中有几个元素就有几行++

3. ++a数组中存储了数组b和c的地址++

4. ++array.length :代表有多少行++

5. ++array【 i 】.length:代表第 i 行有多少列 ++

public static void main(String[] args) {
    int[][] arr = {{1, 2, 3},{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]);
        }
    }
}

不规则的二维数组

public class test2026613 {
        public static void main(String[] args) {
            int[][] arr = new int [2][];
            arr[0] = new int[3];
            arr[1] = new int[5];
        }
}

练一：将数组中的数据✖️2，放回原位置。

public class test2026613 {
    public static void main() {
        int[] arr = new int[]{1,2,3,4};
        System.out.println(Arrays.toString(transform(arr)));
    }
    public static int[] transform(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i]*=2;
        }
        return arr;
    }
}

练二：将数组的奇数放到偶数起那面

import java.util.Arrays;

public class test2026613 {
    public static void main() {
        int[] arr = new int[]{1,2,3,4,5,6};
        String  string= Arrays.toString(transform(arr));
        System.out.println(string);
    }
    public static int[] transform(int[] arr) {
        int [] arr2= new int[arr.length];
        int k = 0;
        for (int i = 0, j = arr.length-1;i < arr.length; i++) {
            if (arr[i] % 2 == 0){
                arr2[j] = arr[i];
                j--;
            }
            else if(arr[i] % 2 != 0){
                arr2[k] = arr[i];
                k++;
            }
        }
       return arr2;
    }
}