美文网首页
Java 基础 30 数组冒泡排序和Arrays工具类

Java 基础 30 数组冒泡排序和Arrays工具类

作者: 小熊先生很不开心 | 来源:发表于2018-02-02 20:26 被阅读25次

    1.1 数组的冒泡排序

      冒泡排序:就是相邻的两个元素进行两两比较,把元素值大的元素依次向后排.

    相关链接
    维基百科

    1.1.1 数组排序之冒泡排序原理图解

    BubbleSort.png

    1.1.2 数组排序之冒泡排序代码实现

    1.1.2.1案例代码

    
      package com.itheima;
    /*
     * 数组排序:(冒泡排序)
     */
    public class ArrayDemo {
        public static void main(String[] args) {
            //定义一个int类型的数组
            int[] arr = {24,69,80,57,13};
            
            /*
            //第一次比较
            //arr.length-1是为了防止索引越界
            //arr.length-1-0是为了减少比较的次数
            for(int x=0; x<arr.length-1-0; x++) {
                //ArrayIndexOutOfBoundsException
                if(arr[x] > arr[x+1]) {
                    //交换数据
                    int temp = arr[x];
                    arr[x] = arr[x+1];
                    arr[x+1] = temp;
                }
            }
            //调用遍历方法
            System.out.println("第一次比较完毕:");
            printArray(arr);
            
            //第二次比较
            //arr.length-1是为了防止索引越界
            //arr.length-1-1是为了减少比较的次数
            for(int x=0; x<arr.length-1-1; x++) {
                //ArrayIndexOutOfBoundsException
                if(arr[x] > arr[x+1]) {
                    //交换数据
                    int temp = arr[x];
                    arr[x] = arr[x+1];
                    arr[x+1] = temp;
                }
            }
            //调用遍历方法
            System.out.println("第二次比较完毕:");
            printArray(arr);
            
            //第三次比较
            //arr.length-1是为了防止索引越界
            //arr.length-1-2是为了减少比较的次数
            for(int x=0; x<arr.length-1-2; x++) {
                //ArrayIndexOutOfBoundsException
                if(arr[x] > arr[x+1]) {
                    //交换数据
                    int temp = arr[x];
                    arr[x] = arr[x+1];
                    arr[x+1] = temp;
                }
            }
            //调用遍历方法
            System.out.println("第三次比较完毕:");
            printArray(arr);
            
            //第四次比较
            //arr.length-1是为了防止索引越界
            //arr.length-1-3是为了减少比较的次数
            for(int x=0; x<arr.length-1-3; x++) {
                //ArrayIndexOutOfBoundsException
                if(arr[x] > arr[x+1]) {
                    //交换数据
                    int temp = arr[x];
                    arr[x] = arr[x+1];
                    arr[x+1] = temp;
                }
            }
            //调用遍历方法
            System.out.println("第四次比较完毕:");
            printArray(arr);
            */
            
            //用循环改进
            /*
            for(int y=0; y<4; y++) {
                for(int x=0; x<arr.length-1-y; x++) {
                    if(arr[x] > arr[x+1]) {
                        //交换数据
                        int temp = arr[x];
                        arr[x] = arr[x+1];
                        arr[x+1] = temp;
                    }
                }
            }
            */
            
            /*
            //循环做的次数不能写固定的值,用arr.length-1改进即可
            for(int y=0; y<arr.length-1; y++) {
                for(int x=0; x<arr.length-1-y; x++) {
                    if(arr[x] > arr[x+1]) {
                        //交换数据
                        int temp = arr[x];
                        arr[x] = arr[x+1];
                        arr[x+1] = temp;
                    }
                }
            }
            printArray(arr);
            */
            
            //如果我有多个数组要排序,每个数组写这样的一段代码,太麻烦,怎么办呢
            //用方法改进
            sort(arr);
            System.out.println("排序后:");
            printArray(arr);
        }
        
        /*
         * 两个明确:
         *      返回值类型:void
         *      参数列表:int[] arr
         */
        public static void sort(int[] arr) {
            for(int x=0; x<arr.length-1; x++) {
                for(int y=0; y<arr.length-1-x; y++) {
                    if(arr[y] > arr[y+1]) {
                        int temp = arr[y];
                        arr[y] = arr[y+1];
                        arr[y+1] = temp;
                    }
                }
            }
        }
        
        /*
         * 数组遍历
         */
        public static void printArray(int[] arr) {
            System.out.print("[");
            for(int x=0; x<arr.length; x++) {
                if(x==arr.length-1) {
                    System.out.print(arr[x]);
                }else {
                    System.out.print(arr[x]+", ");
                }
            }
            System.out.println("]");
        }
    }
    
    

    1.2 Arrays工具类

    1.2.1 Arrays类的概述和使用

    • Arrays:提供了对数组操作的各种方法。
      • public static String toString(int[] a):把数组转成字符串
      • public static void sort(int[] a):对数组进行升序排序

    1.2.1.1 案例代码

    package com.itheima;
    
    import java.util.Arrays;
    
    /*
     * Arrays:提供了对数组操作的各种方法。
     * public static String toString(int[] a):把数组转成字符串
     * public static void sort(int[] a):对数组进行升序排序
     */
    public class ArraysDemo {
        public static void main(String[] args) {
            //定义一个数组
            int[] arr = {24,69,80,57,13};
            
            //public static String toString(int[] a):把数组转成字符串
            System.out.println("排序前:"+Arrays.toString(arr));
            
            //public static void sort(int[] a):对数组进行升序排序
            Arrays.sort(arr);
            
            System.out.println("排序后:"+Arrays.toString(arr));
        }
    }
    

    1.2.2 Arrays类中构造方法的问题

    Arrays类中真的没有构造方法吗?

    • 一个类中没有构造方法,系统将提供一个无参构造方法。
      而我们在帮助文档中没有看到Arrays类的构造方法,这是为什么呢?

      Arrays类中有构造方法,只不过构造方法被private修饰,外界是无法使用的。因为外界无法使用,所以帮助文档中就看不到。

    通过查看源码,我们找到了如下的内容:

    private Arrays() {}
    
    • Arrays类的这种设计是常用的工具类的设计思想:
      • 构造方法私有。
      • 成员都用static修饰。
      • Math,Collections等

    相关文章

      网友评论

          本文标题:Java 基础 30 数组冒泡排序和Arrays工具类

          本文链接:https://www.haomeiwen.com/subject/uetyzxtx.html