持续更新
- 获取集合某个字段的值,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(新增)
- takeWhile() 方法----(结果里面为true的都会筛选出来)
- dropWhile() 方法----(dropWhile 的行为与 takeWhile 相反,返回剩余的元素)
- ofNullable()方法---- ofNullable 方法允许我们创建一个单元素 Stream,可以包含一个非空元素,也可以创建一个空 Stream
- iterator() 重载 的使用
- 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;
});