集合转json（以下 com.alibaba.fastjson包）

尽量以集合来获取数据方便后续计算

//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()) {
                }
                }

获取集合某个字段的值，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);

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));

集合筛选对象 如果有返回对象，没有返回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求和
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());

其他流方法

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;
                   });

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()));