java对象转jsonarray，并运用stream流各实例(jsonArray循环、分组、强转、某个字段集合值、集合用条件筛选对象)

置顶有梦想的小弱鸡

已于 2022-10-20 15:16:25 修改

阅读量2.3w

点赞数 18

分类专栏： java 文章标签： java 开发语言后端

于 2021-12-08 12:06:13 首次发布

本文链接：https://blog.csdn.net/qq53167889/article/details/121787137

版权

java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

持续更新

获取集合某个字段的值，set接收
list集合根据字段分组
list筛选返回对象，没有返回null
集合筛选对象如果有返回对象，没有返回null parallelStream(多线程，异步任务)
流使用lambda表达式的Map和Reduce计算总和
流集合转字符串，用逗号隔开
JSONArray对象循环
jsonArray分组
jsonArray根据字段值相等过滤出来，返回JSONArray
jsonArray对象排序
jsonArray用流计算集合元素的最大值、最小值、总和以及平均值
映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：
stream list转map
stream 统计(count/averaging)
其他流方法
jdk1.9 stream的API（新增）
Optional类API 用法（判断对象）
- Optional 用法(验证对象是否为null)

获取集合某个字段的值，set接收

//转object对象 list集合
  Set<String> sets = list.stream().map(item -> String.valueOf(item.getString("字段名"))).collect(Collectors.toSet());
  //另一种 array为jsonArray对象
  Set<String> hourSet = array.stream().map(item -> ((JSONObject) item).getString("字段名")).collect(Collectors.toSet());

list集合根据字段分组

//集合根据name分组 key为名字，value为当前相同名字的集合
 Map<String, List<User>> userItems= users.stream().collect(Collectors.groupingBy(item -> item.getName()));
 //遍历
        for (Map.Entry<String, List<User>> userItem: userItems.entrySet()) {
            
        }

list筛选返回对象，没有返回null

groups.stream().filter(temp -> {
                                   return temp.getId().equals("123456");
                               }).findAny().orElse(null);

集合筛选对象如果有返回对象，没有返回null parallelStream(多线程，异步任务)

//获取集合id
List<Long> ids= users.parallelStream().map(User::getId).collect(Collectors.toList());
//集合筛选对象 如果有返回对象，没有返回null
User user= users.parallelStream().filter(o -> item.getString("name").equals(o.getName())).findAny().orElse(null);

流使用lambda表达式的Map和Reduce计算总和

List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();

流集合转字符串，用逗号隔开

List<String> strList = Arrays.asList("we","eee","zzz");
String str= strList.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
# 集合转JSONArray （以下 com.alibaba.fastjson包） 
尽量以集合来获取数据方便后续计算
```javascript
//jfinal 数据库查询
List<User> users= BusReportCrowd.dao.template("user.find", kv).find();
//转json 用此方法json只有对象的字段
JSONArray array = JSONArray.parseArray(JSON.toJSONString(users));
//用此方法json 不丢失字段
JSONArray objectsArray = JSONArray.parseArray(Json.getJson().toJson(keys));

JSONArray对象循环

//转object对象 array为jsonArray
 Object o = array.stream().max(Comparator.comparing(item -> ((JSONObject) item).size())).get();
            for (Map.Entry<String, Object> entry : ((JSONObject) o).entrySet()) {
                //entry 为jsonObject 直接获取key value
            }
//另一种
for (Object object : array) {
                JSONObject temp = (JSONObject) object;
                for (Map.Entry<String, Object> entry : temp.entrySet()) {
                }
                }

jsonArray分组

//集合根据字段名分组 key为值，value为当前相同key的集合
 Map<String, List<Object>> jsonListMap = array.stream().collect(Collectors.groupingBy(item -> ((JSONObject) item).getString("字段名")));
                        for (Map.Entry<String, List<Object>> entry : jsonListMap.entrySet()) {
                        ｝

jsonArray根据字段值相等过滤出来，返回JSONArray

//array为之前JSONArray 
JSONArray list = array.stream().filter(item -> ((JSONObject) item).getStr("name").equals(name)).collect(Collectors.toCollection(JSONArray::new));
//JSONArray 排序并返回JSONArray 
array=array.stream().sorted(Comparator.comparing(obj -> ((JSONObject) obj).getBigDecimal("hour_id"))).collect(Collectors.toCollection(JSONArray::new));

jsonArray对象排序

升序排法
staffArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getBigDecimal("orderAmt")));
降序排列
staffArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getBigDecimal("orderAmt")).reversed());
list 转map
map = data.stream().collect(Collectors.groupingBy(BelloResumeInterviewResp::getWhen, Collectors.toList()));

jsonArray用流计算集合元素的最大值、最小值、总和以及平均值

//jsonArray求和
array.stream().mapToInt(item -> ((JSONObject) item).getInteger("impression")).sum();
//获取数字的个数、最小值、最大值、总和以及平均值
List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Highest prime number in List : " + stats.getMax());
System.out.println("Lowest prime number in List : " + stats.getMin());
System.out.println("Sum of all prime numbers : " + stats.getSum());
System.out.println("Average of all prime numbers : " + stats.getAverage());

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

//将两个字符数组合并成一个新的字符数组
 List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
        List<String> listNew = list.stream().flatMap(s -> {
            // 将每个元素转换成一个stream
            String[] split = s.split(",");
            Stream<String> s2 = Arrays.stream(split);
            return s2;
        }).collect(Collectors.toList());

        System.out.println("处理前的集合：" + list);
        System.out.println("处理后的集合：" + listNew);
       // 处理前的集合：[m,k,l,a, 1,3,5,7]
//处理后的集合：[m, k, l, a, 1, 3, 5, 7]

stream list转map

List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
		List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
		Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());

		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
		
		Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
				.collect(Collectors.toMap(Person::getName, p -> p));
		System.out.println("toList:" + listNew);
		System.out.println("toSet:" + set);
		System.out.println("toMap:" + map);

stream 统计(count/averaging)

Collectors提供了一系列用于数据统计的静态方法：

计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble

List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

		// 求总数
		Long count = personList.stream().collect(Collectors.counting());
		// 求平均工资
		Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
		// 求最高工资
		Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
		// 求工资之和
		Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
		// 一次性统计所有信息
		DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

		System.out.println("员工总数：" + count);
		System.out.println("员工平均工资：" + average);
		System.out.println("员工工资总和：" + sum);
		System.out.println("员工工资所有统计：" + collect);

其他流方法

在这里插入图片描述

jdk1.9 stream的API（新增）

在 Java 9 中，Stream API 变得更好，Stream 接口中添加了 4 个新的方法：dropWhile, takeWhile, ofNullable，还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代

takeWhile() 方法----（结果里面为true的都会筛选出来）

List<Integer> list =Arrays.asList(45,43,76);
list.stream().takeWhile(x -> x < 50).forEach(System.out::println);
//45 43

dropWhile() 方法----（dropWhile 的行为与 takeWhile 相反，返回剩余的元素）

List<Integer> list =Arrays.asList(45,43,76);
list.stream().dropWhile(x -> x < 50).forEach(System.out::println);
//76

ofNullable()方法---- ofNullable 方法允许我们创建一个单元素 Stream，可以包含一个非空元素，也可以创建一个空 Stream

// 不报异常，允许通过
Stream<String> stringStream = Stream.of("AA", "BB", null);
System.out.println(stringStream.count());//3
// 不报异常，允许通过
List<String> list = new ArrayList<>();
list.add("AA");
list.add(null);
System.out.println(list.stream().count());//2
//ofNullable() ：允许值为 null
Stream<Object> stream1 = Stream.ofNullable(null);
System.out.println(stream1.count());//0
Stream<String> stream = Stream.ofNullable("hello world");
System.out.println(stream.count());//1

iterator() 重载的使用

//原来的控制终止方式：
Stream.iterate(1,i -> i + 1).limit(10).forEach(System.out::println);
//现在的终止方式：
Stream.iterate(1,i -> i < 100,i -> i + 1).forEach(System.out::println);

Optional类API 用法（判断对象）

Optional 用法(验证对象是否为null)

针对对象，例子

 Person person = new Person();
        person.setName("名称");
        //isPresent验证当前对象是否为null
        boolean is_present = Optional.ofNullable(person).isPresent();
        System.out.println(is_present);//true
        //ifPresent 对象不为null执行业务
        Optional.ofNullable(person).ifPresent(item->{
            System.out.println("执行业务");
        });
        String name = Optional.ofNullable(person).map(item -> item.getName()).get();
        System.out.println(name);//名称
        //如果对象为null，返回null
        Person person_res = Optional.ofNullable(person).orElse(null);
        System.out.println(person_res);//Person{id=null, name='名称', age=0}




Person person2 =null;
        //isPresent验证当前对象是否为null
        boolean is_present2 = Optional.ofNullable(person2).isPresent();
        System.out.println(is_present2);//fasle
        //ifPresent 对象为null不进入
        Optional.ofNullable(person2).ifPresent(item->{
            System.out.println("执行业务");
        });
        //orElse如果对象为null，返回null
        Person person_orElse = Optional.ofNullable(person2).orElse(null);
        System.out.println(person_orElse);//null
        //orElseGet如果对象为null，返回空指针
        //Person person_orElseGet = Optional.ofNullable(person2).orElseGet(null);
        //System.out.println(person_orElseGet);//java.lang.NullPointerException
        //orElseGet如果对象为null，返回新创建对象
        Person person_orElseGet2= Optional.ofNullable(person2).orElseGet(
                ()->{
                    Person person1 = new Person();
                    person1.setName("名称");
                    return person1;
                }
        );
        System.out.println(person_orElseGet2);
        //对象为null，返回异常不存在
        Optional.ofNullable(person2).orElseThrow(()->new Exception("不存在"));

写法

//比如，在主程序中，以前写法。
if(user!=null){
    dosomething(user);
}
//JAVA8写法。
Optional.ofNullable(user)
    .ifPresent(u->{
        dosomething(u);
});

//以前写法。
public User getUser(User user) throws Exception{
    if(user!=null){
        String name = user.getName();
        if("zhangsan".equals(name)){
            return user;
        }
    }else{
        user = new User();
        user.setName("zhangsan");
        return user;
    }
}
//java8写法。
public User getUser(User user) {
    return Optional.ofNullable(user)
                   .filter(u->"zhangsan".equals(u.getName()))
                   .orElseGet(()-> {
                        User user1 = new User();
                        user1.setName("zhangsan");
                        return user1;
                   });

有梦想的小弱鸡

关注

18
点赞
踩
76

收藏

觉得还不错? 一键收藏
1
评论
java对象转jsonarray，并运用stream流各实例(jsonArray循环、分组、强转、某个字段集合值、集合用条件筛选对象)

这里写目录标题集合转json（一下都用 com.alibaba.fastjson包）JSONArray对象循环获取集合某个字段的值，set接收list集合根据字段分组jsonArray分组jsonArray根据字段值相等过滤出来，返回JSONArray集合筛选对象如果有返回对象，没有返回null parallelStream(多线程，异步任务)集合转json（一下都用 com.alibaba.fastjson包）尽量以集合来获取数据方便后续计算//jfinal 数据库查询List<User&
复制链接

扫一扫