Java数组之Arrays类

Arrays类

• 数组自带的工具类：java.util.Arrays，可以对数组进行一些基本的操作，比如输出，排序等。
• Arrays类里面的方法均为static修饰的静态方法，因此可以直接使用类名调用，而不必使用对象来调用。

实例：

package com.ilzy.blog.array;
import java.util.Arrays;
public class ArrayTest6 {
    public static void main(String[] args) {
        int[] array1 = {1,2,3,4,7878,353,324568,6234};
        System.out.println(array1);   // 直接打印是数组对象的hash值。
        Arrays.sort(array1);  //Arrays类自带的排序方法
       System.out.println(Arrays.toString(array1));  //Arrays类自带的打印数组方法。
       // printArray(array1);   //自己写的打印方法
        //Arrays.fill(array1,0);   //用0填充数组，即将指定的值赋给数组内每个元素。
        Arrays.fill(array1,1,4,0);  //用0填充数组中下标1到下标4之间的元素。  原则是左闭右开区间，即包含左不包含右。
        System.out.println(Arrays.toString(array1));
    }
    // 打印数组元素方法
    public static void printArray(int[] array1){
        System.out.print("[");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i]);
            if (i<array1.length-1){
                System.out.print(", ");
            }
        }
        System.out.print("]");
    }
}

冒泡排序

实例：

package com.ilzy.blog.array;
import java.util.Arrays;
public class ArrayTest7 {
    public static void main(String[] args) {
        int[] array2 ={1,2,6,435,45,768,768,2,5,5,9};
        sort(array2);  //调用写好的排序方法，返回一个排序后的数组。
        System.out.println(Arrays.toString(array2));
    }
    //冒泡排序：比较两个相邻元素大小，产生一大一小，决定是否交换位置，下一轮可以少一次排序，依次循环，直至结束。
    public static void sort(int[] array1){
        //临时变量
        int tem = 0;
        //外层循环，判断要走多少次。
        for (int i = 0; i < array1.length-1; i++) {
            //内层循环，如果第一个数大于第二个数，交换位置。
            for (int j = 0; j <array1.length-1-i; j++) {
                if (array1[j+1]>array1[j]){
                   tem= array1[j];
                   array1[j]=array1[j+1];
                   array1[j+1]=tem;
                   /*
                   该循环的意思为：内层循环中，只需要数组长度-1次，
                   便可以在一轮循环中将一个最小的数置换到最后。
                   跳出内循环后外循环次数+1，然后再次进入内循环，
                   将一个次小的数排到倒数第二的位置，完成这一轮循环。
                   因为每一轮循环中所排出的数已经是本轮循环中最小的数，
                   因此每次内循环次数可以减去已经进行的外循环次数，避免无用排序。
                   而外循环也仅需进行数组长度-1次即可，因为最后一次便可排出最大值。
                    */
                }
            }
        }
    }
}

略微优化后的实例，若数组已经有序则跳出排序：

package com.ilzy.blog.array;
import java.util.Arrays;
public class ArrayTest7 {
    public static void main(String[] args) {
        int[] array2 ={1,2,6,435,45,768,768,2,5,5,9};
        sort(array2);  //调用写好的排序方法，返回一个排序后的数组。
        System.out.println(Arrays.toString(array2));
    }
    //冒泡排序：比较两个相邻元素大小，产生一大一小，决定是否交换位置，下一轮可以少一次排序，依次循环，直至结束。
    public static void sort(int[] array1){
        //临时变量
        int tem = 0;
        //外层循环，判断要走多少次。
        for (int i = 0; i < array1.length-1; i++) {
            boolean flag = false;  //通过flag标志位减少无意义的比较。
            //内层循环，如果第一个数大于第二个数，交换位置。
            for (int j = 0; j <array1.length-1-i; j++) {
                if (array1[j+1]>array1[j]){
                   tem= array1[j];
                   array1[j]=array1[j+1];
                   array1[j+1]=tem;
                   flag = true;
                   /*
                   该循环的意思为：内层循环中，只需要数组长度-1次，
                   便可以在一轮循环中将一个最小的数置换到最后。
                   跳出内循环后外循环次数+1，然后再次进入内循环，
                   将一个次小的数排到倒数第二的位置，完成这一轮循环。
                   因为每一轮循环中所排出的数已经是本轮循环中最小的数，
                   因此每次内循环次数可以减去已经进行的外循环次数，避免无用排序。
                   而外循环也仅需进行数组长度-1次即可，因为最后一次便可排出最大值。
                    */
                }
            }
            if (flag==false){
                break;
            }   // 此处进行的优化意为，如果一轮内循环之后没有进行排序，那么表明已经是有序数组，那么就退出外循环。
        }
    }
}

使用嵌套循环的冒泡排序算法时间复杂度为O，即n的2次方。