Java数组排序一云图智联

12次阅读

共计 4182 个字符，预计需要花费 11 分钟才能阅读完成。

数组概念：
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

声明一个数组就是在内存空间中划出一串连续的空间

数组名代表的是连续空间的首地址

通过首地址可以依次访问数组所有元素

方式一

` 数据类型 []  数组名字 = new 数据类型 [ 长度];`

数组定义格式详解

数据类型： 创建的数组容器可以存储任意数据类型。

[] : 表示数组。

数组名字： 为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。

[长度]：数组的长度，表示数组容器中可以存储多少个元素

注意：数组有定长特性，长度一旦指定，不可更改。

方式二：采用静态初始化定义数组（完整格式）

 数据类型 [] 数组名 = new 数据类型 []{元素 1, 元素 2, 元素 3...};

在开发之中，对于静态数组的初始化强烈建议使用完整语法模式

方式三：采用静态初始化定义数组（简化格式）

 数据类型 [] 数组名 = { 元素 1, 元素 2, 元素 3...};

数组最大的缺陷：长度固定。

1、通过数组的索引访问到数组中的元素。格式：数组名 [索引]

2、获取数组的长度属性格式：数组名 .length

数组的最大索引值为数组名 .length-1

3、数组的遍历：使用 for 循环

static 关键字，可以修饰变量、方法和代码块。

在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。下面的工具类，可以体现 static 方法的便利。

类变量


*    当 static 修饰成员变量时，该变量称为类变量
*    该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

静态方法


* 当 static 修饰成员方法时，该方法称为类方法。静态方法在声明中有 static，建议使用类名来调用

*  静态方法调用的注意事项：(静态方法只能访问静态成员)

         静态方法可以直接访问类变量和静态方法。静态方法 不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。静态方法中，不能使用 this 关键字。

静态代码块

定义位置：类中方法外

执行：随着类的加载而执行且执行一次，优先于 main 方法和构造方法的执行

作用：给类变量进行初始化赋值

Arrays 类是一个工具类，其中包含了很多操作数组的方法。这个 Arrays 类里均为 static 修饰的方法

1、type[] copyOf(type[] original, int length)

这个方法将会把 original 数组复制成一个新数组，其中 length 是新数组的长度。
如果 length 小于 original 数组的长度，则新数组就是原数组的前面 length 个元素

如果 length 大于 original 数组的长度，则新数组的前面元索就是原数组的所有元素，后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。

   int[] arr1 = {1, 2, 3, 4, 5};
   int[] arr2 = Arrays.copyOf(arr1,4);

   int[] arr3 = Arrays.copyOf(arr1, 10);

   System.out.println(Arrays.toString(arr2)); // [1, 2, 3, 4]
   System.out.println(Arrays.toString(arr3)); // [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

2、public static String toString(int[] a)：返回指定数组内容的字符串表示形式。

public static void main(String[] args) {int[] arr = {2,34,35,4,657,8,69,9};
    // 打印数组, 输出地址值
    System.out.println(arr);  // [I@1b6d3586
 
    // 数组内容转为字符串
    String s = Arrays.toString(arr);
    System.out.println(s);  // [2, 34, 35, 4, 657, 8, 69, 9]
}

3、public static void sort(int[] a)：对指定的 int 型数组按数字升序进行排序


public static void main(String[] args) {
// 定义 int 数组
int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
System.out.println("排序前:"+ Arrays.toString(arr)); 
// 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6,2]
 
// 升序排序
Arrays.sort(arr);
System.out.println("排序后:"+ Arrays.toString(arr));
// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46,48]
}

**4、Arrays.sort(Object[] array, int from, int to)
对数组元素指定范围进行排序（排序范围是从元素下标为 from, 到下标为 to- 1 的元素进行排序）**

5、Arrays.fill(Object[] array,Object object) 可以为数组元素填充相同的值

    int[] nums = {2,5,0,4,1,-10};

    Arrays.fill(nums, 1);

    for(int i :nums){System.out.print(i+" ");
    }


    /* 之前:2 5 0 4 1 -10
     * 结果:1 1 1 1 1 1 
     */

6、Arrays.asList(T… a) 数组转集合（常用）

int array = new int[]{3, 10, 4, 0, 2};
List<int[]> ints = Arrays.asList(array);
 
Integer arr[] = new Integer[]{3, 10, 4, 0, 2};
List<Integer> integers = Arrays.asList(arr);

int 类型和包装类数组转集合的区别：

原始数据类型 int 的数组调用 asList 之后得到的 List 只有一个元素，这个元素就是元素类型的数组。

而封装类 Integer 数组调用 asList 是把数组中每个元素加到了 List 中。

7、Arrays. equals(int[] a, int[] a2) 数组比较两个数组元素以相同的顺序包含相同的元素则他们是相等的

public static void main(String[] args) {int[] arr = {2,34,35,4,657,8,69,9};
    int[] arr2 = {2,34,35,4,657,8,69,9};
    System.out.println(Arrays.equals(arr,arr2)); // true
 
    Integer[] a =  new Integer[]{2,34,35};
    Integer[] a1 =  new Integer[] {2,34,35};
    System.out.println(Arrays.equals(a,a1)); // true
}

8、parallelPrefix (T[] array, BinaryOperator<T> op)

parallelPrefix (T[] array, int fromIndex, int toIndex,BinaryOperator<T> op) 二元迭代，对原数组内容进行二元操作

public static void main(String[] args) {Integer[] arrayTest={1,2,3,4,5,7,6};
    // 二元迭代，对原数组内容进行二元操作
    Arrays.parallelPrefix(arrayTest,(x,y)->x*y);
    System.out.println(Arrays.toString(arrayTest)); // [1, 2, 6, 24, 120, 840, 5040]
 
    // 在指定下标范围内，对原数组内容进行二元操作，下标含头不含尾
    Integer[] arrayTest2={1,2,3,4,5,7,6};
    Arrays.parallelPrefix(arrayTest2,0,3,(x,y)->x*y);
    System.out.println(Arrays.toString(arrayTest2));  // [1, 2, 6, 4, 5, 7, 6]
}

9、parallelSort：对数组进行升序排序或自定义排序

public static void main(String[] args) {Integer[] arrayTest={1,2,3,4,5,6,7};
    // 每个元素的下标 +2 然后赋到数组对应元素
    Arrays.parallelSetAll(arrayTest,(x)->(x+2)); //[2, 3, 4, 5, 6, 7, 8]
    System.out.println(Arrays.toString(arrayTest));
 
    Integer[] arrayTest2={3,1,6,4,10,7,5};
   // 对指定下标范围内的元素进行指定排序方法的排序，含头不含尾
    Arrays.parallelSort(arrayTest2,0,5,(x,y)->y.compareTo(x));
    System.out.println(Arrays.toString(arrayTest2)); // [10, 6, 4, 3, 1, 7, 5]

10、Arrays.setAll(int[] array,IntUnaryOperator generator) 串行，对数组元素进行设置

Integer[] arrayTest={1,2,3,4,5,6,7};
// 每个元素的下标 +3 然后赋到数组对应元素
Arrays.setAll(arrayTest, (x)->(x+3));
System.out.println(Arrays.toString(arrayTest)); // [3, 4, 5, 6, 7, 8, 9]

11、Arrays.stream（int[] array）构造流

后面还有冒泡排序, 后续会继续分享.

正文完