java8的常用写法

package com.sf.gis.boot;

 

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Optional;

import java.util.OptionalInt;

import java.util.Set;

import java.util.function.Function;

import java.util.stream.Collectors;

import java.util.stream.IntStream;

import java.util.stream.Stream;

 

import com.google.common.collect.Lists;

 

public class Test {

 

/**

* jdk8中使用了::的用法

* 就是把方法当做参数传到stream内部，使stream的每个元素都传入到该方法里面执行一下，双冒号运算就是Java中的[方法引用],[方法引用]的格式是：

* 

* 表达式

* person -> person.getAge();

* 

* 使用双冒号：

* Person：：getAge

* 

* 表达式：

* new HashMap<>()

* 

* 使用双冒号：

* HashMap :: new

*/

 

public static void main(String[] args) {

 

String[] arrayStr = { "珊瑚", "冷光", "冷光", "冷暖", "阳光" };

Arrays.stream(arrayStr).filter(n -> n.startsWith("冷")).forEach(System.out::println);

 

List<String> strList = new ArrayList(Arrays.asList(arrayStr)) ;

System.out.println(strList);

 

/**

* filter使用

*/

System.out.println("filter");

strList.stream().filter(n -> n.startsWith("冷")).forEach(System.out::println);

 

/**

* distinct去重

*/

System.out.println("distinct");

strList.stream().distinct().forEach(System.out::println);

 

/**

* limit 截取

*/

System.out.println("limit");

strList.stream().limit(2).forEach(System.out::println);

 

/**

* skip 跳过

*/

System.out.println("skip");

strList.stream().skip(2).forEach(System.out::println);

 

/**

* map 映射 map 方法用于映射每个元素到对应的结果。

* map() 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

* flatMap()接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

*/

System.out.println("map");

strList.stream().map(item -> item + "你好").forEach(System.out::println);

 

Product prod1 = new Product(1L, 1, new Double(15), "面包");

//Product prod11 = new Product(1L, 1, new Double(15), "面包2");

Product prod2 = new Product(2L, 2, new Double(20), "饼干");

Product prod3 = new Product(3L, 3, new Double(30), "月饼");

List<Product> prodList = Lists.newArrayList(prod1, prod2, prod3);

 

List<String> nameList = prodList.stream().map(item -> item.getName()).collect(Collectors.toList());

System.out.println(nameList); // [面包, 饼干, 月饼]

Long count = prodList.stream().mapToInt(item -> item.getNum()).count();

System.out.println(count); // 3

Long min = prodList.stream().mapToLong(item -> item.getId()).min().getAsLong();

System.out.println(min); // 1

prodList.stream().mapToDouble(item -> item.getPrice()).forEach(System.out::println); 

 

/**

* sorted 排序

*/

System.out.println("sorted");

strList.stream().sorted(String :: compareTo).forEach(System.out::println);

 

/**

* match 匹配

*/

System.out.println("match");

Boolean result1 = strList.stream().allMatch(s -> s.equals("冷光"));

        System.out.println(result1);

        

        Boolean result3 = strList.stream().anyMatch(s -> s.equals("冷光"));

        System.out.println(result3);

        

        Boolean reslut2 = strList.stream().noneMatch(s -> s.equals("冷光"));

        System.out.println(reslut2);

        //随机读取一个

        Optional<String> getResult = strList.stream().findAny();

        System.out.println(getResult);

        System.out.printf("获取Optional中的值：%s%n", getResult.get());

        

        /**

         * collect

         */

        // 转为list Collectors.toList()

        List<String> nameList2 = prodList.stream().map(item -> item.getName()).collect(Collectors.toList());

 

        // 转为Set Collectors.toSet()

        Set<String> nameSet = prodList.stream().map(item -> item.getName()).collect(Collectors.toSet());

 

        // 转为Map Collectors.toMap(Product::getId, Product::getId) 第一个参数是map的key 第二个参数是map的value

        Map<Long, Product> collect = prodList.stream().collect(Collectors.toMap(Product::getId, product -> product));

        System.out.println(collect);

 

        // 转为LinkedList

        prodList.stream().map(item -> item.getName()).collect(Collectors.toCollection(LinkedList::new));

 

        //统计总数

        Long count1 = prodList.stream().collect(Collectors.counting());

 

        // 分组(分组完成后key value键值对，key为分组的字段 值为集合)

        Map<Long, List<Product>> listMap = prodList.stream().collect(Collectors.groupingBy(Product::getId));

        System.out.println(listMap);

 

        // 拼接

        String nameJoin = prodList.stream().map(Product::getName).collect(Collectors.joining());

        

        /**

         * reduce 归约

         */

        //第一种方法求和

        System.out.println("reduce");

        String connectStrings = strList.stream().reduce("111", (x, y) -> x + y);

        System.out.println(connectStrings);

 

        // 第二种方法求和

        System.out.println("reduce2");

        String connectStrings1 = strList.stream().reduce("222", Test::getConnectStrings);

        System.out.println(connectStrings1);

        

        System.out.println("-----------------------------------------------------------");

        

        String[] numberStrings = {"1", "2", "3"};

        // mapToInt参数： 需要转换成相应的类型方法

        IntStream intStream = Arrays.stream(numberStrings).mapToInt(Integer::valueOf);

        //使用对应的 Optional 接收

        OptionalInt optionalNumber = intStream.max();

        // 取值，给默认值 0，为空结果为0

        System.out.printf("numberStrings's max number is: %s%n", optionalNumber.orElse(0));

        

        

        //Collectors 集合归约

        //  toList

        List<String> list2 = Arrays.stream(numberStrings).collect(Collectors.toList());

        // Get String by connected

        String connectStrings2 = Arrays.stream(numberStrings).collect(Collectors.joining(","));

        System.out.printf("Collectors toList: %s , Conlletors Join Strings: %s%n", list2, connectStrings2);

        

        /**

         * group by

         */

        System.out.println("group by");

        Map<String, List<Locale>> countryToLocaleList = Stream.of(Locale.getAvailableLocales()).collect(Collectors.groupingBy(l -> l.getDisplayCountry()));

        

        // predicate

        Map<Boolean, List<Locale>> englishAndOtherLocales = Stream.of(Locale.getAvailableLocales())

        .collect(Collectors.groupingBy(l -> l.getDisplayLanguage().equalsIgnoreCase("English")));

 

        // partitioningBy

        Map<Boolean, List<Locale>> englishAndOtherLocales2 = Stream.of(Locale.getAvailableLocales())

        .collect(Collectors.partitioningBy(l -> l.getDisplayLanguage().equalsIgnoreCase("English")));

        

        

}

 

/**

* Connect Strings

* @param s1 参数1

* @param s2 参数2

* @return java.lang.String

*/

private static String getConnectStrings(String s1, String s2) {

    return s1 + s2;

}

 

public static class Product {

 

private Long id;

private Integer num;

private Double price;

private String name;

 

public Product() {}

 

public Product(Long id, Integer num, Double price, String name) {

this.id = id;

this.num = num;

this.price = price;

this.name = name;

}

 

public Long getId() {

return id;

}

 

public void setId(Long id) {

this.id = id;

}

 

public Integer getNum() {

return num;

}

 

public void setNum(Integer num) {

this.num = num;

}

 

public Double getPrice() {

return price;

}

 

public void setPrice(Double price) {

this.price = price;

}

 

public String getName() {

return name;

}

 

public void setName(String name) {

this.name = name;

}

}

}