Java8常用语法案例

Lambda Stream Operation 时间API，可重复注解，ForkJoin效率对比案例

Lambda,Stream，Operation案例使用实体

package com.gcxzflgl.entity;

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;
	private Status status;

	public Employee() {
	}

	public Employee(String name) {
		this.name = name;
	}

	public Employee(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public Employee(int id, String name, int age, double salary) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Employee(int id, String name, int age, double salary, Status status) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}

	public Status getStatus() {
		return status;
	}

	public void setStatus(Status status) {
		this.status = status;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
				+ "]";
	}

	public enum Status {
		FREE, BUSY, VOCATION;
	}

}

案例介绍：

package com.gcxzflgl.javaEight801;

import com.gcxzflgl.entity.Employee;
import com.sun.corba.se.spi.orb.Operation;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;

import java.io.PrintStream;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TestLambda {

    List emps = Arrays.asList(
            new Employee(101, "张三", 18, 9999.99),
            new Employee(102, "李四", 59, 6666.66),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55),
            new Employee(105, "田七", 38, 5555.55)
    );

    List emps2 = Arrays.asList(
            new Employee(102, "李四", 79, 6666.66, Employee.Status.BUSY),
            new Employee(101, "张三", 18, 9999.99, Employee.Status.FREE),
            new Employee(103, "王五", 28, 3333.33, Employee.Status.VOCATION),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.BUSY),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee(105, "田七", 38, 5555.55, Employee.Status.BUSY)
    );
    /**
     * 原来的匿名内部类
     */
    @Test
    public void test1(){
        Comparator com = new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        TreeSet tree = new TreeSet<>(com);
    }

    /**
     * lambda表达式
     */
    @Test
    public void test2(){
        Comparator com = (x1,x2) -> Integer.compare(x1,x2);
        TreeSet tree = new TreeSet<>(com);

    }

    /**
     * stream使用
     */
    @Test
    public void test3(){
        emps.stream().filter(e -> e.getSalary() > 5000).forEach(System.out::println);
        System.out.println("-------");
        emps.stream()
            .filter((e) -> e.getAge() <= 35)
            .forEach(System.out::println);
    }


    /**
     * 遍历集合年龄相同按照名字排序否则按照年龄排序
     */
    @Test
    public void test4(){
        Collections.sort(emps,(e1,e2) -> {
            if(e1.getAge()==e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else{
                return Integer.compare(e1.getAge(),e2.getAge());
            }
        });
        emps.stream().forEach(System.out::println);
    }

    /**
     * 将字符串小写转换成大写
     */
    @Test
    public void test6(){
        String str =strHandler("gao",x -> x.toUpperCase());
        System.out.println(str);
    }
    public String strHandler(String str,MyFunction mf){
        return mf.get(str);
    }

    /**
     * 消费型接口
     */
    @Test
    public void test7(){
        consure(1000,x -> System.out.println("今天消费了"+x+"元"));
    }
    public void consure(int money , Consumer con){
        con.accept(money);
    }

    /**
     * 供给型接口
     */
    @Test
    public void test8(){
       List result = numList(10,() -> (int)(Math.random()*100));
       result.stream().forEach(System.out::println);
    }
    public List numList(int num, Supplier sup){
        List list =  new ArrayList<>();
        for(int i=0;i x.toUpperCase());
        String result2 =str("lisi", x -> x.substring(2));
        System.out.println(result+"---"+result2);
    }
    public String str(String str, Function fn){
        return fn.apply(str);
    }


    /**
     * 断言型接口
     */
    @Test
    public void test10(){
        List result = Arrays.asList("aa","bbb","vccccc");
        List res = predict(result, x -> x.length()>3);
        res.stream().forEach(System.out::println);
    }
    public List predict(List str, Predicate pre){
        List result = new ArrayList<>();
        for(String s:str){
            if(pre.test(s)){
                result.add(s);
            }
        }
        return result;
    }

    /**
     * 方法引用有三种     对象：：实例方法名     ----  类：：实例方法名 ---- 类：：静态方法名
     */
    @Test
    public void test11(){
        PrintStream ps =System.out;
        Consumer con = ps::println;
    }

    // 对象：：实例方法名
    @Test
    public void test12(){
        Employee emp = new Employee();
        Supplier sup = () -> emp.getName();
        System.out.println(sup.get());

        Supplier sup2 = emp::getAge;
        System.out.println(sup2.get());
    }

    // 类：：静态方法名
    @Test
    public void test13(){
        Comparator com =(x,y) -> Integer.compare(x,y);
        Comparator com2 = Integer::compare;
    }

    //类：：实例方法名
    @Test
    public void test14(){
        BiPredicate bp = (x,y) -> x.equals(y);
        BiPredicate bp2 =String::equals;
    }

    /**
     * 构造器引用
     */
    @Test
    public void test15(){
        Supplier sup = () -> new Employee();

        Supplier sup2 = Employee::new;
    }

    /**
     * 数组引用
     */
    @Test
    public void test16(){
        Function fun = x -> new String[x];
        System.out.println(fun.apply(10).length);

        Function fun2 = String[]::new;
    }


    /**
     * stream 创建
     */
    @Test
    public void test17(){
        List list = new ArrayList<>();
        Stream str=list.stream();

        Employee[] emp = new Employee[10];
        Stream str2 = Arrays.stream(emp);

        Stream str3 = Stream.of("a","bb","ccc");
        //无限流
        Stream str4 = Stream.iterate(0,x -> x+2);
        //生成无限随机数
        Stream.generate(() -> Math.random()).forEach(System.out::println);
    }

    /**
     * 筛选与切片
     * 		filter——接收 Lambda ， 从流中排除某些元素。
     * 		limit——截断流，使其元素不超过给定数量。
     *      distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
     *      skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返
     */
    @Test
    public void test18(){
        emps.stream().filter((x) -> x.getAge()<35).forEach(System.out::println);
        System.out.println("------");
        emps.stream().filter((x) -> x.getAge()<35).limit(2).forEach(System.out::println);
        System.out.println("------");
        emps.stream().filter((x) -> x.getSalary()>5000).skip(2).forEach(System.out::println);
        System.out.println("------");
        emps.stream().distinct().forEach(System.out::println);
    }

    /**
     * 映射
     * 		map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
     * 		flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
     */
    @Test
    public void test19(){
        List list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
        list.stream().map((s) -> s.toUpperCase()).forEach(System.out::println);

        emps.stream().map(Employee::getName).forEach(System.out::println);

        Stream> str= list.stream().map(TestLambda::filterStream);
        str.forEach((s) -> {s.forEach(System.out::println);});
        System.out.println("----");

        list.stream().flatMap(TestLambda::filterStream).forEach(System.out::println);
    }

    public static Stream filterStream(String str){
        List list = new ArrayList<>();
        for(Character c:str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

    /*
		sorted()——自然排序
		sorted(Comparator com)——定制排序
	 */
    @Test
    public void test20(){
        emps.stream().map(Employee::getAge)
                .sorted()
                .forEach(System.out::println);
        System.out.println("-----");

        emps.stream().sorted((x,y) -> {
            if(x.getAge() == y.getAge()){
                return x.getName().compareTo(y.getName());
            }else{
                return Integer.compare(x.getAge(),y.getAge());
            }
        }).forEach(System.out::println);
    }

    /**
     * stram终止操作
     * allMatch --检查是否匹配所有元素
     * anyMatch --检查是否匹配一个元素
     * noneMatch -- 检查是否没有匹配的元素
     * findFirst -- 返回第一个元素
     * findAny -- 返回当前流中的任意元素
     * count -- 返回流中的总个数
     * max -- 返回流中的最大值
     * min -- 返回流中的最小值
     * 归约 --reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。
     */
    @Test
    public void test21(){
        boolean result = emps2.stream().allMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(result);

        boolean result1 = emps2.stream().anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(result1);

        boolean result2 = emps2.stream().noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(result2);
        //返回的结果值可能为空
        Optional op = emps2.stream().sorted((x, y) -> -Double.compare(x.getSalary(),y.getSalary())).findFirst();
        System.out.println(op.get());
        //stream 串形流
        Optional op2 = emps2.stream().filter(e -> e.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(op2.get());
        //parallelStream 并行流
        Optional op3=emps2.parallelStream().filter(e-> e.getStatus().equals(Employee.Status.FREE)).findAny();
        System.out.println(op3.get());

        long count = emps2.stream().count();
        System.out.println(count);

        Optional op4 =  emps2.stream().max((x,y) -> -Double.compare(x.getSalary(),y.getSalary()));
        System.out.println(op4.get());

        Optional op5 = emps2.stream().map(Employee::getAge).min(Integer::compareTo);
        System.out.println(op5.get());

        List list =Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer count2 =list.stream().reduce(0,(x,y) -> x+y);
        System.out.println(count2);

        Optional result4=emps2.stream().map(Employee::getSalary).reduce(Double::sum);
        System.out.println(result4.get());
    }

    /**
     * collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
     */
    @Test
    public void test22(){
        List list=emps2.stream().map(Employee::getName)
                .collect(Collectors.toList());
        list.forEach(System.out::println);

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

        Set set =emps2.stream().map(Employee::getName).collect(Collectors.toSet());
        set.forEach(System.out::println);

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

        ArrayList array =emps2.stream().map(Employee::getName).collect(Collectors.toCollection(ArrayList::new));
        array.forEach(System.out::println);

        long count= emps2.stream().collect(Collectors.counting());
        System.out.println(count);

        Double avg =emps2.stream().collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);

        Double sum = emps2.stream().collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);

        Optional maxBy =emps2.stream().collect(Collectors.maxBy((x,y) -> Double.compare(x.getSalary(),y.getSalary())));
        System.out.println(maxBy.get());

        Optional minBy = emps2.stream().map(Employee::getSalary).collect(Collectors.minBy(Double::compare));
        System.out.println(minBy);

        //分组
        Map> map = emps2.stream().collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(map);

        //多级别分组
        Map>> map2=emps2.stream().collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(e ->{
            if(e.getAge()>=60){
                return "老年";
            }else if(e.getAge() >= 35)
                return "中年";
            else
                return "成年";
        })));
        System.out.println(map2);

        //分区
        Map > map3 =emps2.stream().collect(Collectors.partitioningBy(e -> e.getSalary()>=5000));
        System.out.println(map3);

        DoubleSummaryStatistics dss=emps2.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(dss.getMax());
        System.out.println(dss.getAverage());
        System.out.println(dss.getMin());

        //拼接字符串
        String result = emps2.stream().map(Employee::getName)
                .collect(Collectors.joining("--","[","]"));
        System.out.println(result);

        Optional dou =emps2.stream().map(Employee::getSalary).collect(Collectors.reducing(Double::sum));
        System.out.println(dou.get());
    }


}

 

Operation实例：

package com.gcxzflgl.javaEight801;

import com.gcxzflgl.entity.Employee;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;

import java.util.Optional;

/**
 * 一、Optional 容器类：用于尽量避免空指针异常
 *  * 	Optional.of(T t) : 创建一个 Optional 实例
 *  * 	Optional.empty() : 创建一个空的 Optional 实例
 *  * 	Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 *  * 	isPresent() : 判断是否包含值
 *  * 	orElse(T t) :  如果调用对象包含值，返回该值，否则返回t
 *  * 	orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 *  * 	map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
 *  * 	flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
 */
public class TestOperation {
    @Test
    public void test1(){
        Optional  op =Optional.of(new Employee());
        System.out.println(op.get());

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

        Optional op2 = Optional.empty();
        System.out.println(op2.get());

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

    @Test
    public void test2(){
        Optional op=Optional.ofNullable(new Employee());
        System.out.println(op.get());
    }
    @Test
    public void test3 (){
        Optional op=Optional.ofNullable(null);
        if(op.isPresent()){
            System.out.println(op.get());
        }
        Employee em= op.orElse(new Employee(1,"张三",18,88.88, Employee.Status.FREE));
        System.out.println(em);

        Employee emp = op.orElseGet( () -> new Employee());
        System.out.println(emp);
    }

    @Test
    public void test4(){
        Optional op = Optional.of(new Employee(12,"李四",12,454.6, Employee.Status.VOCATION));
        Optional op3= op.map(e -> e.getName());
        System.out.println(op3.get());

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

        Optional op4 = op.flatMap(e -> Optional.of(e.getName()));
        System.out.println(op4.get());
    }


}

全新时间案例解决以前版本线程安全需要ThreadLocal来保证多线程问题

package com.gcxzflgl.javaEight801;

import org.junit.jupiter.api.Test;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;
import java.util.Set;

public class TestLocalDateTime {

    /**
     * localDateTime localTime localDate
     */
    @Test
    public void test1(){
        LocalDateTime ldt =LocalDateTime.now();
        System.out.println(ldt);

        LocalDateTime ldt2= LocalDateTime.of(2018,10,10,12,12,12);
        System.out.println(ldt2);

        //加减小时
        LocalDateTime ldt3= ldt.plusHours(3);
        System.out.println(ldt3);
        LocalDateTime ldt4=ldt.minusHours(2);
        System.out.println(ldt4);

        System.out.println(ldt.getYear());
        System.out.println(ldt.getMonth());
        System.out.println(ldt.getMonthValue());
    }

    /**
     * Instant UTC（1970-01-01 00:00:00）
     */
    @Test
    public void test2(){
        Instant inst = Instant.now();
        System.out.println(inst.getNano());
        System.out.println("------");
        //移动时区
        OffsetDateTime odt =inst.atOffset(ZoneOffset.ofHours(8));
        System.out.println(odt);
        System.out.println("------------");
        //1970-01-01 加5s
        Instant inst2 = Instant.ofEpochSecond(5);
        System.out.println(inst2);
    }

    /**
     * 3.
     * 	//Duration : 用于计算两个“时间”间隔
     * 	//Period : 用于计算两个“日期”间隔
     */
    @Test
    public void test3(){
        Instant inst =Instant.now();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Instant end = Instant.now();
        System.out.println(Duration.between(inst,end));

        LocalDate ldt = LocalDate.now();
        LocalDate ldt2 = LocalDate.of(2017,12,12);
        Period pe = Period.between(ldt,ldt2);
        System.out.println(pe);

    }

    /**
     * 时间校验器
     */
    @Test
    public void test4(){
        LocalDateTime ldt =LocalDateTime.now();
        System.out.println(ldt);

        //指定时间为多少
        LocalDateTime ldt2 = ldt.withDayOfMonth(10);
        System.out.println(ldt2);

        //下一个周五
        LocalDateTime ldt3= ldt.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));
        System.out.println(ldt3);

        //自定义：下一个工作日
        LocalDateTime time =ldt.with( (l) -> {
          LocalDateTime ldt4 = (LocalDateTime) l;
          DayOfWeek dow = ldt4.getDayOfWeek();
            if(dow.equals(DayOfWeek.FRIDAY)){
                return ldt4.plusDays(3);
            }else if(dow.equals(DayOfWeek.SATURDAY)){
                return ldt4.plusDays(2);
            }else{
                return ldt4.plusDays(1);
            }
        });
        System.out.println(time);

    }

    /**
     * DateTimeFormatter 格式化时间日期
     */
    @Test
    public void test5(){
       // DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE_TIME;
        DateTimeFormatter dtf =DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime ldt = LocalDateTime.now();
        String strDate = ldt.format(dtf);
        System.out.println(strDate);

        LocalDateTime ldt2 = ldt.parse(strDate,dtf);
        System.out.println(ldt2);
    }


    //6.ZonedDate、ZonedTime、ZonedDateTime ： 带时区的时间或日期
    @Test
    public void test6(){
        Set set = ZoneId.getAvailableZoneIds();
        set.forEach(System.out::println);
    }

    @Test
    public void test7(){
        LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println(ldt);

        ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));
        System.out.println(zdt);
    }


}

 

Lambda练习

实体：

package com.gcxzflgl.entity;
//交易员类
public class Trader {

	private String name;
	private String city;

	public Trader() {
	}

	public Trader(String name, String city) {
		this.name = name;
		this.city = city;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

	@Override
	public String toString() {
		return "Trader [name=" + name + ", city=" + city + "]";
	}

}

package com.gcxzflgl.entity;
//交易类
public class Transaction {

	private Trader trader;
	private int year;
	private int value;

	public Transaction() {
	}

	public Transaction(Trader trader, int year, int value) {
		this.trader = trader;
		this.year = year;
		this.value = value;
	}

	public Trader getTrader() {
		return trader;
	}

	public void setTrader(Trader trader) {
		this.trader = trader;
	}

	public int getYear() {
		return year;
	}

	public void setYear(int year) {
		this.year = year;
	}

	public int getValue() {
		return value;
	}

	public void setValue(int value) {
		this.value = value;
	}

	@Override
	public String toString() {
		return "Transaction [trader=" + trader + ", year=" + year + ", value="
				+ value + "]";
	}

}

案例说明：

package com.gcxzflgl.javaEight801;

import com.gcxzflgl.entity.Employee;
import com.gcxzflgl.entity.Trader;
import com.gcxzflgl.entity.Transaction;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

public class TestTransaction {
	
	List transactions = null;
	
	@Before
	public void before(){
		Trader raoul = new Trader("Raoul", "Cambridge");
		Trader mario = new Trader("Mario", "Milan");
		Trader alan = new Trader("Alan", "Cambridge");
		Trader brian = new Trader("Brian", "Cambridge");
		
		transactions = Arrays.asList(
				new Transaction(brian, 2011, 300),
				new Transaction(raoul, 2012, 1000),
				new Transaction(raoul, 2011, 400),
				new Transaction(mario, 2012, 710),
				new Transaction(mario, 2012, 700),
				new Transaction(alan, 2012, 950)
		);
	}
	
	//1. 找出2011年发生的所有交易， 并按交易额排序（从低到高）
	@Test
	public void test1(){
		transactions.stream().filter(x -> x.getYear()==2011)
				.sorted((x,y) -> Integer.compare(x.getValue(),y.getValue()))
				.forEach(System.out::println);
	}
	
	//2. 交易员都在哪些不同的城市工作过？
	@Test
	public void test2(){
		transactions.stream().map(t -> t.getTrader().getCity()).distinct().forEach(System.out::println);
	}
	
	//3. 查找所有来自剑桥的交易员，并按姓名排序
	@Test
	public void test3(){
		transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge"))
				.map(Transaction::getTrader)
				.sorted((t1,t2) -> t1.getName().compareTo(t2.getName()))
				.distinct()
				.forEach(System.out::println);
	}
	
	//4. 返回所有交易员的姓名字符串，按字母顺序排序
	@Test
	public void test4(){
		transactions.stream()
					.map((t) -> t.getTrader().getName())
					.sorted()
					.forEach(System.out::println);
		
		System.out.println("-----------------------------------");
		
		String str = transactions.stream()
					.map((t) -> t.getTrader().getName())
					.sorted()
					.reduce("-", String::concat);

		System.out.println(str);

		System.out.println("------------------------------------");
		
		transactions.stream()
					.map((t) -> t.getTrader().getName())
					.flatMap(TestTransaction::filterCharacter)
					.sorted((s1, s2) -> s1.compareToIgnoreCase(s2))
					.forEach(System.out::print);
	}
	
	public static Stream filterCharacter(String str){
		List list = new ArrayList<>();
		
		for (Character ch : str.toCharArray()) {
			list.add(ch.toString());
		}
		
		return list.stream();
	}
	
	//5. 有没有交易员是在米兰工作的？
	@Test
	public void test5(){
		boolean bl = transactions.stream()
					.anyMatch((t) -> t.getTrader().getCity().equals("Milan"));
		
		System.out.println(bl);
	}
	
	
	//6. 打印生活在剑桥的交易员的所有交易额
	@Test
	public void test6(){
		Optional sum = transactions.stream()
					.filter((e) -> e.getTrader().getCity().equals("Cambridge"))
					.map(Transaction::getValue)
					.reduce(Integer::sum);
		
		System.out.println(sum.get());
	}
	
	
	//7. 所有交易中，最高的交易额是多少
	@Test
	public void test7(){
		Optional max = transactions.stream()
					.map((t) -> t.getValue())
					.max(Integer::compare);
		
		System.out.println(max.get());
	}
	
	//8. 找到交易额最小的交易
	@Test
	public void test8(){
		Optional op = transactions.stream()
					.min((t1, t2) -> Integer.compare(t1.getValue(), t2.getValue()));
		
		System.out.println(op.get());
	}


	List emps2 = Arrays.asList(
			new Employee(102, "李四", 79, 6666.66, Employee.Status.BUSY),
			new Employee(101, "张三", 18, 9999.99, Employee.Status.FREE),
			new Employee(103, "王五", 28, 3333.33, Employee.Status.VOCATION),
			new Employee(104, "赵六", 8, 7777.77, Employee.Status.BUSY),
			new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
			new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
			new Employee(105, "田七", 38, 5555.55, Employee.Status.BUSY)
	);
	/**
	 * 1.	给定一个数字列表，返回一个由每个数的平方构成的列表呢
	 * 		，给定【1，2，3，4，5】， 应该返回【1，4，9，16，25】。
	 * 	2.用 map 和 reduce 方法数一数流中有多少个Employee呢
	 */
	@Test
	public void test23(){
		Integer[] sum = new Integer[]{1,2,3,4,5};
		Arrays.stream(sum).map(x -> x*x).forEach(System.out::println);
		System.out.println("----------");

		Optional count =emps2.stream().map(e -> 1).reduce(Integer::sum);
		System.out.println(count.get());
	}

}

ForkJoin案例效率：

package com.gcxzflgl.javaEight801;

import java.util.concurrent.RecursiveTask;

public class ForkJoinCalculate extends RecursiveTask{

	/**
	 * 
	 */
	private static final long serialVersionUID = 13475679780L;
	
	private long start;
	private long end;
	
	private static final long THRESHOLD = 10000L; //临界值
	
	public ForkJoinCalculate(long start, long end) {
		this.start = start;
		this.end = end;
	}
	
	@Override
	protected Long compute() {
		long length = end - start;
		
		if(length <= THRESHOLD){
			long sum = 0;
			
			for (long i = start; i <= end; i++) {
				sum += i;
			}
			
			return sum;
		}else{
			long middle = (start + end) / 2;
			
			ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
			left.fork(); //拆分，并将该子任务压入线程队列
			
			ForkJoinCalculate right = new ForkJoinCalculate(middle+1, end);
			right.fork();
			
			return left.join() + right.join();
		}
		
	}

}

package com.gcxzflgl.javaEight801;

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

import org.junit.Test;

public class TestForkJoin {
	
	@Test
	public void test1(){
		long start = System.currentTimeMillis();
		
		ForkJoinPool pool = new ForkJoinPool();
		ForkJoinTask task = new ForkJoinCalculate(0L, 100000000L);
		
		long sum = pool.invoke(task);
		System.out.println(sum);
		
		long end = System.currentTimeMillis();
		
		System.out.println("耗费的时间为: " + (end - start)); 
	}
	
	@Test
	public void test2(){
		long start = System.currentTimeMillis();
		
		long sum = 0L;
		
		for (long i = 0L; i <= 100000000L; i++) {
			sum += i;
		}
		
		System.out.println(sum);
		
		long end = System.currentTimeMillis();
		
		System.out.println("耗费的时间为: " + (end - start)); 
	}
	
	@Test
	public void test3(){
		long start = System.currentTimeMillis();
		
		Long sum = LongStream.rangeClosed(0L, 10000000000L)
							 .parallel()
							 .sum();
		
		System.out.println(sum);
		
		long end = System.currentTimeMillis();
		
		System.out.println("耗费的时间为: " + (end - start));
	}
	/**
	 * 并行流
	 */
	@Test
	public void test4(){
		Instant inst = Instant.now();
		LongStream.rangeClosed(0,1000000000L)
				.parallel()
				.reduce(0,Long::sum);
		Instant end = Instant.now();
		System.out.println(Duration.between(inst,end).toMillis());
	}

}

 

可重复注解使用说明：

package com.gcxzflgl.annotation;

import java.lang.annotation.*;

@Repeatable(MyAnnotation.class)
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER,ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Annotation {
    String value() default "gcxzflgl";
}

package com.gcxzflgl.annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER,ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
   Annotation[] value();
}

package com.gcxzflgl.javaEight801;

import com.gcxzflgl.annotation.Annotation;
import com.gcxzflgl.annotation.MyAnnotation;
import org.junit.Test;


import java.lang.reflect.Method;

public class TestRepeatAnnotation {

    @Test
    public void test1(){
        Class clazz = TestRepeatAnnotation.class;
        Method  m1 = null;
        try {
            m1 = clazz.getMethod("show");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        Annotation[] my = m1.getAnnotationsByType(Annotation.class);
        for(int i=0;i