当前位置:主页 > java教程 > java8 Stream大数据量List分批处理切割

java8 Stream大数据量List分批处理切割方式

发布:2023-04-04 15:05:01 59


我们帮大家精选了相关的编程文章,网友司柔静根据主题投稿了本篇教程内容,涉及到java8、Stream、大数据量List处理、大数据分批处理切割、java8 Stream大数据量List分批处理切割相关内容,已被747网友关注,下面的电子资料对本篇知识点有更加详尽的解释。

java8 Stream大数据量List分批处理切割

java8 Stream大数据量List分批处理

//按每3个一组分割
private static final Integer MAX_NUMBER = 3;

/**
* 计算切分次数
*/
private static Integer countStep(Integer size) {
    return (size + MAX_NUMBER - 1) / MAX_NUMBER;
}

public static void main(String[] args) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
      int limit = countStep(list.size());
      //方法一:使用流遍历操作
      List<List<Integer>> mglist = new ArrayList<>();
      Stream.iterate(0, n -> n + 1).limit(limit).forEach(i -> {
          mglist.add(list.stream().skip(i * MAX_NUMBER).limit(MAX_NUMBER).collect(Collectors.toList()));
      });

      System.out.println(mglist);

      //方法二:获取分割后的集合
      List<List<Integer>> splitList = Stream.iterate(0, n -> n + 1).limit(limit).parallel().map(a -> list.stream().skip(a * MAX_NUMBER).limit(MAX_NUMBER).parallel().collect(Collectors.toList())).collect(Collectors.toList());
      
      System.out.println(splitList);
}

使用google guava对List进行分割

//使用guava对list进行分割
List<User> users = userService.findAll();
//按每50个一组分割
List<List<User>> parts = Lists.partition(users, 50);
parts.stream().forEach(list -> {
    process(list);
});

使用apache common collection

List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
List<List<Integer>> subs = ListUtils.partition(intList, 3);

java 手写将一个List等分成n个list

public static <T> List<List<T>> averageAssign(List<T> source, int n) {
    List<List<T>> result = new ArrayList<>();
    //(先计算出余数)
    int remainder = source.size() % n;  
    //然后是商
    int number = source.size() / n;  
    //偏移量
    int offset = 0;
    for (int i = 0; i < n; i++) {
        List<T> value;
        if (remainder > 0) {
            value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
            remainder--;
            offset++;
        } else {
            value = source.subList(i * number + offset, (i + 1) * number + offset);
        }
        result.add(value);
    }
    return result;
}

java8部分特性及list的常见操作

主要记录如何使用Java8中的流式处理,简洁的处理各种常见的操作。

注意:

数组转集合,体现的是适配器模式,只是转换接口,后台的数据仍是数组。所以使用集合相关的操作add、remove、clear会抛异常:UNSupportOperationException。

List<String> list = Arrays.asList("官僚","买办","资产阶级");

集合转数组,不能直接使用无参toArray()方法,该方法返回的是Object[],若强转可能会存在转换异常。带参的大小,必须要跟集合list保持一致,否则会涉及重新分配内存。

Lambda表达式

  • 格式(params) -> {expression}
  • 比如我们实现一个Runnable接口
Runnable run = new Runnable() {
    @Override
    public void run() {
        // TODO
    }
}

使用Lambda表达式:Runnable run = () -> {# TODO}

函数式接口,规范:

  • 接口中只能有一个抽象方法
  • (可选)在接口上添加@FunctionalInterface注解,这样可以检验它是否一个函数式接口

比如:

@FunctionalInterface
public interface MyFun {
    void fun();
}

//也可以使用泛型
@FunctionalInterface
public interface MyFun1<T> {
    void fun(T t);
}

使用的时候

public static void domething(MyFun myfun) {
    myfun.fun();
}

public static void domething(MyFun1<User> myFun) {
    User user = new User();
    user.setName("我是泛型");
    myFun.fun(user);
}

public static void main(String[] args) {
    domething(() -> {System.out.println("通过lambda表达式执行了函数式接口");});
    domething1((item) -> {
        item.setId(100);
        item.setAge(20);
        System.out.println("这是MyFun1函数式接口真正的执行逻辑,最终的结果是:" + JsonObject.toJsonString(item);)
    });
}

常见的list操作

/**
 * 数组转集合,体现的是适配器模式,只是转换接口,后台的数据仍是数组。
 * 所以使用集合相关的操作add/remove/clear会抛错:unSupportOperationException
 *
 */
List<String> arrList = Arrays.asList("买办", "资产阶级", "官僚");

/**
 * 集合转数组,不能直接使用无参toArray()方法,该方法的返回类型是Object[],若强转,可能存在转换异常
 * 带参的大小,必须要跟集合list保持一致,否则会涉及内存的重新分配
 */
List<String> list = new ArrayList<>();
list.add("买办");
list.add("官僚");
list.add("资产阶级");
// 注意:大小必须和list保持一致,若小于3,则需要重新分配内存地址,并返回新数组地址;
// 若数组元素大于所需,则下标为[list.size()]的元素置为null,其他元素为原值
// 所以最好将数组大小跟集合大小保持一致,可以验证new String[1],new String[5]的输出值
String[] arr = new String[list.size()];
arr = list.toArray(arr);
System.out.println("arr :" + Arrays.toString(arr));

// list 初始化(guava)
List<String> initList = Lists.newArrayList("Java", "Python", "Javascript");

List<User> students = new ArrayList<>();
User st1 = new User();
st1.setId(123);
st1.setAge(10);

User st2 = new User();
st2.setId(123);
st2.setAge(20);

User st3 = new User();
st3.setId(456);
st3.setAge(20);
students.add(st1);
students.add(st2);
students.add(st3);

// list 分割(guava)
List<List<User>> splits = Lists.partition(students, 2);
System.out.println("list分割:" + JsonUtil.toJSONString(splits));

// list分组
Map<Integer, List<User>> groupStu = students.stream().collect(
        Collectors.groupingBy(User::getAge));
System.out.println("list分组:" + JsonUtil.toJSONString(groupStu));

// list转map, (k,v),若集合中有重复的key,会抛异常:Duplicate key……
// 通过(k1, k2)->k1来处理重复情况,保留k1,舍弃k2
Map<Integer, Integer> studentIdMap = students.stream().collect(
        Collectors.toMap(User::getId, User::getAge, (k1, k2) -> k1));
System.out.println("list转map, (k,v) :" + studentIdMap);

// list转map, (k,t)
Map<Integer, User> studenteMap = students.stream().collect(
        Collectors.toMap(User::getId, Function.identity(), (k1, k2) -> k1));
System.out.println("list转map, (k,t) :" + studenteMap);

// list过滤
List<User> oldStu = students.stream().filter(
        student -> student.getAge() > 10).collect(Collectors.toList());
System.out.println("list过滤filter :" + JsonUtil.toJSONString(oldStu));

// list对象转换
List<Teacher> teachers = students.stream().map(
        student -> {
            Teacher teacher = new Teacher();
            BeanUtils.copyProperties(student, teacher);
            teacher.setTitle("教师");
            return teacher;
        }).collect(Collectors.toList());
System.out.println("list对象转化:" + JsonUtil.toJSONString(teachers));

// list转set
Set<Integer> ages = students.stream().map(User::getAge).collect(Collectors.toSet());
System.out.println("list转set:" + ages);

// 过滤掉空元素后再map
    public static void main(String[] args) {

        List<Customer> customerList = new ArrayList<>();
        customerList.add(new Customer(1L, "Ryu"));
        customerList.add(new Customer(2L, "Ken"));
        customerList.add(new Customer(3L, null));
        customerList.add(null);
        customerList.add(new Customer(5L, null));
        customerList.add(new Customer(6L, "Zangief"));
        
        
        List<String> nameList1 = customerList.stream()
                .filter(Objects::nonNull) // 過濾掉Customer為null的元素
                .map(e -> e.getName())    
                .filter(Objects::nonNull) // 過濾掉Customer.getName()為null的元素
                .collect(Collectors.toList());
        
        
        System.out.println(nameList1); // [Ryu, Ken, Zangief]
        
    }

总结

以上为个人经验,希望能给大家一个参考,也希望大家多多支持码农之家。


参考资料

相关文章

  • Java集合Stream流操作的基本使用教程分享

    发布:2023-03-26

    流操作并不会影响原来的集合,可以简单认为,流操作是把集合中的一个元素逐个复制放到一个首尾相接的流动的水槽中。这篇文章整理了Stream流操作的基本使用,需要的可以参考一下


  • Java8新特性之Collectors.joining()实例详解

    发布:2023-03-05

    在项目中我们常常要对list集合的数据做一些字符串拼接/处理等相关操作,下面这篇文章主要给大家介绍了关于Java8新特性之Collectors.joining()的相关资料,需要的朋友可以参考下


  • JDBC中使用Java8的日期LocalDate和LocalDateTime操作mysql、postgresql

    发布:2020-07-08

    这篇文章主要给大家介绍了关于JDBC中如何使用Java8的日期LocalDate和LocalDateTime的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下


  • 实现java8 list按照元素的某个字段去重的方法

    发布:2020-04-24

    这篇文章主要介绍了如何实现java8 list按照元素的某个字段去重,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,,需要的朋友可以参考下


  • Spring Cloud Stream异常处理过程讲解

    发布:2020-03-25

    这篇文章主要介绍了Spring Cloud Stream异常处理过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下


  • Spark Streaming算子开发代码讲解

    发布:2019-08-05

    这篇文章主要介绍了Spark Streaming算子开发实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧


  • C++标准库中sstream与strstream的区别点总结

    发布:2021-06-08

    以下是对C++标准库中sstream与strstream的区别进行了详细的分析介绍,需要的朋友可以过来参考下


  • Java8到Java19的一些变化分析详解

    发布:2023-03-13

    这篇文章主要为大家介绍了Java8到Java19的一些变化分析详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪


网友讨论