使用Java函数式编程来生成基础数据（数组）

Java函数式编程来生成基础数组

源代码头部

import lombok.Getter;

import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import java.util.function.BiFunction;
import java.util.stream.IntStream;
@Getter
public class ArrayGenerate {

第一个属性，使用经典方法来逐个生成有序Integer数组

    private BiFunction<Integer, Integer, Integer[]> classic_array_generate =
            (Integer start, Integer end) -> {
                int len = end - start + 1;
                Integer[] arr = new Integer[len];
                for (int i = 0; i < len; i++) {
                    arr[i] = start + i;
                }
                return arr;
            };

第二个属性，使用Stream来生成有序的Integer数组

    private BiFunction<Integer, Integer, Integer[]> stream_array_generate =
            (Integer start, Integer end) -> IntStream.rangeClosed(start, end).boxed().toArray(Integer[]::new);

第三个属性，使用Stream生成一个降序的Integer数组

把降序的排序成升序的最考验时长

    private final BiFunction<Integer, Integer, Integer[]> stream_array_desc_generate =
            (Integer start, Integer end) -> {
                Integer[] integers = IntStream.rangeClosed(start, end).boxed().toArray(Integer[]::new);
                Arrays.sort(integers, Collections.reverseOrder());
                return integers;
            };

第四属性，使用Stream生成一个乱序的Integer数组

    private final BiFunction<Integer, Integer, Integer[]> stream_array_unordered_generate =
            (Integer start, Integer end) -> {
                Integer[] integers = IntStream.rangeClosed(start, end).boxed().toArray(Integer[]::new);
                Random random = new Random();
                for (int i = integers.length - 1; i > 0; i--) {
                    int position = random.nextInt(i + 1);
                    int temp = integers[position];
                    integers[position] = integers[i];
                    integers[i] = temp;
                }
                return integers;
            };

以下与上面内容对应，只不过是生成int数组

    private BiFunction<Integer, Integer, int[]> stream_array_int_generate =
            (Integer start, Integer end) -> IntStream.rangeClosed(start, end).toArray();
    private BiFunction<Integer, Integer, int[]> stream_array_int_unordered_generate1 =
            (Integer start, Integer end) -> {
                int[] arr_temp = IntStream.rangeClosed(start, end).toArray();
                int len = arr_temp.length;
                int[] arr = new int[len];
                Random random = new Random();
                for(int i = end - start; i >= 0; i--) {
                   int position = random.nextInt(i + 1);
                   arr[i] = arr_temp[position];
                   arr_temp[position] = arr_temp[i];
                }
                // arr[0] = arr_temp[0];
                return arr;
            };
    private BiFunction<Integer, Integer, int[]> stream_array_int_unordered_generate =
            (Integer start, Integer end) -> {
                int[] arr = IntStream.rangeClosed(start, end).toArray();
                Random random = new Random();
                for (int i = arr.length - 1; i > 0; i--) {
                    int position = random.nextInt(i + 1);
                    int temp = arr[position];
                    arr[position] = arr[i];
                    arr[i] = temp;
                }
                return arr;
            };
}

说明

• 生成基础数组没有使用任何方法，因为使用函数数式接口，就可以只定义属性，而可以不再使用方法了
• 在外部调用时，使用Lombok的getter方法就可以调用这些属性来生成基础数组
• 这些接口，要接收两个入参start与end，分别表示数据开始与结束时的值，在数组中包括这两个值
• 接口返回的数组，分为包装类型数组与基础类型数组
• 后期再补写用Kotlin的代码
• 上述属性特点都是一种函数式接口类型BiFunction<Integer, Integer, int[]>，这样写属性有一个重大好处，就是生成数组的名字不同，但类型是是相同，这样当使用这里生成的数组时，可以使用统一参数来完成，不必在算法代码中加入不同的方法名来调用不同的数组生成方法，这样代码的通用性就提高了，举例来说：

public void algorithm() {
    int[] arr = ...;//这里的...代表了生成数组的方法名，这里要硬编码，调用不同方法就要修改方法名
    // 对数组arr执行排序等算法处理代码
}
public void algorithm_better(BiFunction<Integer, Integer, int[]> bi, ...) {//...代表其它参数
	int[] arr = bi.apply(a, b);//使用这种参数传入方式，可以不再有硬编码，数组生成方法被统一了
	// 对数组arr执行排序等算法处理代码
}