Java数组排序和方法

数组排序

1、冒泡排序

• 对比次数是n*（n-1）/2
• 时间复杂度是O（n^2）

2、选择排序

• 对比次数是n*（n-1）/2
• 时间复杂度是O（n^2）

3、插入排序

• 时间复杂度O（n）
• 性能相对比冒泡排序和选择排序好

4、JDK 可以直接调用的排序方法

• Arrays.sort(array); 升序排列，数据量小速度快

  降序排列倒序排序Arrays.sort(array, Comparator.reverseOrder());
  降序排列只能是引用类型数据，如Integer

• Arrays.parallelSort(array)； 升序排列，数据量大速度快

• Java.lang包是sun 公司默认导入的包，该包下的类，在使用的时候不需要导包）

        Integer[] array = new Integer[]{65, 24, 5, 7, 40, 28};
        Integer[] array2 = {65, 5, 24, 7, 40, 28};
        //升序排列两个数组
        Arrays.sort(array);
        Arrays.sort(array2);
        //比较两个数组的地址是否相等
        System.out.println(array == array2);
        //以数组的形式显示数组
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(array2));
        //比较数组的内容是否相等
        System.out.println(Arrays.equals(array,array2));

Arrays 工具类

• Arrays.equals(array, array) ：判断两个数组内容是否相同
• Arrays.toString(array) ：以数值的形式显示数组
• Arrays.stream(array) ：以 stream 流的形式表示数组

ArrayUtils工具类（第三方）

• ArrayUtils.addAll(array, ...T) ：向数组中添加多个元素
• ArrayUtils.clone(array) ：克隆数组
• ArrayUtils.contains(array, ele) ：数组中是否包含指定的元素
• ArrayUtils.get(array, index , default) ：获取指定索引位置的数据、如果超出索引、取默认值（该方法只适合与 数组元素是 引用类型的数组）
• ArrayUtils.insert(index, array, ...eles) ：向指定位置添加 多个元素、返回新数组
• ArrayUtils.isEmpty(array) ：数组是否为空
• ArrayUtils.remove(array, index) ：删除指定索引位置的 元素
• ArrayUtils.removeAll(array, ...indexs) ：删除多个指定索引位置的元素
• ArrayUtils.shuffle(array) ：随机打乱数组
• ArrayUtils.subarray(array, start , end) ：对数组进行切片
• ArrayUtils.toObject(int[] array) ：将 int[] 数组 转成 Integer[] 数组
• ArrayUtils.toObject(int[] array) ：将 int[] 数组 转成 Integer[] 数组
• ArrayUtils.toString(array) ：以数值的形式显示数组

        int[] array = {65, 24, 5, 7, 40, 28};

        //向数组中添加元素
        array = ArrayUtils.add(array,100);
        System.out.println(Arrays.toString(array));

        //删除数组中指定位置的元素
        array = ArrayUtils.remove(array,2);
        System.out.println(Arrays.toString(array));

        //向数组中添加多个元素
        array = ArrayUtils.addAll(array,100,200);
        System.out.println(Arrays.toString(array));

        //克隆数组
        int[]newarray = ArrayUtils.clone(array);
        System.out.println(Arrays.toString(newarray));

        //查询数组中是否包含指定元素
        System.out.println(ArrayUtils.contains(array,100));

        //向数组中的指定位置插入元素
        array = ArrayUtils.insert(1,array,52);
        System.out.println(Arrays.toString(array));

        //查询数组元素是否为空
        System.out.println(ArrayUtils.isEmpty(array));

        //删除数组中指定位置的元素
        array = ArrayUtils.remove(array,1);
        System.out.println(Arrays.toString(array));

        //打乱数组的排列顺序
		//ArrayUtils.shuffle(array);
		//System.out.println(Arrays.toString(array));

        //截取指定起始位置到终止位置长度的数组
        newarray = ArrayUtils.subarray(array,1,5);
        System.out.println(Arrays.toString(newarray));

        //将基本类型int[] 数组转换为 引用类型Integ[] 类型的数组
        Integer[] integers =  ArrayUtils.toObject(array);
        //将引用类型Integ[] 数组转换为 基本类型int[]  类型的数组
        int[] ints = ArrayUtils.toPrimitive(integers);
        System.out.println(Arrays.toString(ints));

三维数组

杨辉三角问题

 		/**
         *  杨辉三角
         *      第 n 行 有  n 个 项 , i 代表 行
         *
         *      1.  起始值 和 结束值 都是 1
         *      2.   第 j 项 ( j !=0 && j!=i),  j = [i-1][j-1] + [i-1][j]
         *
         *  打印 前10行的杨辉三角
         */

        // 构建一个 10行的 二维数组
        int[][] array = new int[10][] ;

        for(int i= 0 ; i< array.length ; i++) {

            // 第 i 行，构建一个 长度 为 i + 1 的数据
            int[] arr = new int[i+1] ;

            // 使用 for循环，填充列对应的数据
            for(int j = 0 ; j < arr.length ; j++) {
                if (j == 0 || j == i) arr[j] = 1 ;
                else arr[j] = array[i-1][j-1] + array[i-1][j] ;
            }
            // 在 构建的数组，放入 二维数组中
            array[i] = arr ;
        }

        //System.out.println(ArrayUtils.toString(array));

        for(int i=0 ; i<array.length ; i++) {

            for(int j=0 ; j < array[i].length ; j++) {

                System.out.print(array[i][j] + "\t");
            }

            System.out.println();
        }

    }