java基础回顾_04(自用）-CSDN博客

本文链接：https://blog.csdn.net/m0_63577901/article/details/133160441

数组继续

二维数组

public static void main(String[] args) {
     int[][] scores={
             {89,67,98,72},
             {99,56,82,91},
             {77,79,90,80}
     };
     System.out.println("数组的长度:"+scores.length);
     System.out.println("第一组数组长度:"+scores[0].length);

    }

内存解析

来自尚硅谷java基础的讲义

一个例题

输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为 O(n)。例如：输入的数组为 1, -2, 3, -10, -4, 7, 2, -5，和最大的子数组为 3, 10, -4, 7, 2，因此输出为该子数组的和 18

public class Main {
    public static void main(String[] args) {
        int[] arr={1,-2,3,10,-4,7,2,-5};
        int i=getGreatestSum(arr);
        System.out.println(i);
    }
    public static int getGreatestSum(int[] arr){
        int greatestSum=0;
        if(arr==null||arr.length==0){
            return 0;
        }
        int temp=greatestSum;
        //temp直接挨个加数组元素，如果小于0,重新开始，如果比最大总和大，最大总和更新
        for(int i=0;i<arr.length;i++) {
            temp += arr[i];
            if (temp < 0) {
                temp = 0;
            }
            if (temp > greatestSum) {
                greatestSum = temp;
            }
        }
        //如果单个元素比几个相加还要大，单个元素即为最大总和
        if(greatestSum==0){
            greatestSum=arr[0];
            for(int i=1;i<arr.length;i++){
                if(greatestSum<arr[i])
                    greatestSum=arr[i];
                }
        }

        return greatestSum;

    }
}

数组元素的反转

public static void main(String[] args) {
       int[] arr={1,2,3,4,5};
       System.out.println("反转之前");
       for(int i=0;i<arr.length;i++){
           System.out.println(arr[i]);
       }

       for(int i=0;i<arr.length/2;i++){
           int temp=arr[i];
           arr[i]=arr[arr.length-1-i];
           arr[arr.length-1-i]=temp;
       }
       System.out.println("反转之后");
       for(int i=0;i<arr.length;i++){
           System.out.println(arr[i]);
       }
    }

冒泡排序

 public static void main(String[] args){
        int[] arr = {6,9,2,9,1};
// 目标：从小到大
// 冒泡排序的轮数 = 元素的总个数 - 1
// 轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套
// 外循环控制 轮数，内循环控制每一轮的比较次数和过程
        for(int i=1; i<arr.length; i++){ // 循环次数是 arr.length-1 次 / 轮
/*
假设 arr.length=5
i=1, 第 1 轮，比较 4 次
arr[0] 与 arr[1]
arr[1] 与 arr[2]
arr[2] 与 arr[3]
arr[3] 与 arr[4]
arr[j] 与 arr[j+1] ， int j=0;j<4; j++
i=2, 第 2 轮，比较 3 次
arr[0] 与 arr[1]
arr[1] 与 arr[2]
arr[2] 与 arr[3]
arr[j] 与 arr[j+1] ， int j=0;j<3; j++
i=3, 第 3 轮，比较 2 次
arr[0] 与 arr[1]
arr[1] 与 arr[2]
arr[j] 与 arr[j+1] ， int j=0;j<2; j++
i=4, 第 4 轮，比较 1 次
arr[0] 与 arr[1]
arr[j] 与 arr[j+1] ， int j=0;j<1; j++
int j=0; j<arr.length-i; j++
*/
            for(int j=0; j<arr.length-i; j++){
// 希望的是 arr[j] < arr[j+1]
                if(arr[j] > arr[j+1]){
// 交换 arr[j] 与 arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
// 完成排序，遍历结果
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }

快速排序

从数列中挑出一个元素，称为"基准"（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去

Arrays工具类的使用

java.util.Arrays 类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。比如：
数组元素拼接：
– static String toString(int[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。相邻元素用字符 ", "（逗号加空格）分隔。形式为：[元素 1，元素 2，元素 3。。。]
– static String toString(Object[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。相邻元素用字符 ", "（逗号加空格）分隔。元素将自动调用自己从 Object 继承的 toString 方法将对象转为字符串进行拼接，如果没有重写，则返回类型@hash 值，如果重写则按重写返回的字符串进行拼接。
数组排序：
– static void sort(int[] a) ：将 a 数组按照从小到大进行排序
– static void sort(int[] a, int fromIndex, int toIndex) ：将 a 数组的[fromIndex,to Index)部分按照升序排列
– static void sort(Object[] a) ：根据元素的自然顺序对指定对象数组按升序进
行排序。
– static void sort(T[] a, Comparator<? super T> c) ：根据指定比较器产生顺序对指定对象数组进行排序。
数组元素的二分查找：
– static int binarySearch(int[] a, int key) 、static int binarySearch(Object[] a,Object key) ：要求数组有序，在数组中查找 key 是否存在，如果存在返回第一次找到的下标，不存在返回负数。
数组的复制：
– static int[] copyOf(int[] original, int newLength) ：根据 original 原数组复制一个长度为newLength 的新数组，并返回新数组
– static T[] copyOf(T[] original,int newLength)：根据 original 原数组复制一个长度为 newLength 的新数组，并返回新数组
– static int[] copyOfRange(int[] original, int from, int to) ：复制 original 原数组的[from,to)构成新数组，并返回新数组
– static T[] copyOfRange(T[] original,int from,int to)：复制 original 原数组的
[from,to)构成新数组，并返回新数组
比较两个数组是否相等：
– static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
– static boolean equals(Object[] a,Object[] a2)：比较两个数组的长度、元素是否完全相同
填充数组：
– static void fill(int[] a, int val) ：用 val 值填充整个 a 数组
– static void fill(Object[] a,Object val)：用 val 对象填充整个 a 数组
– static void fill(int[] a, int fromIndex, int toIndex, int val)：将 a 数组(fromIndex,toIndex)部分填充为 val 值
– static void fill(Object[] a, int fromIndex, int toIndex, Object val) ：将 a 数组
[fromIndex,toIndex)部分填充为 val 对象

应用

public static void main(String[] args){
        int[] arr = {6,9,2,9,1};
        System.out.println("排序前："+Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后："+Arrays.toString(arr));
    }