前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
最新优惠活动
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP最新优惠活动
返回腾讯云官网
社区首页 >专栏 >Java8

Java8

作者头像
用户5927264
发布于 2019-07-31 10:09:04
1.1K0
发布于 2019-07-31 10:09:04
举报
文章被收录于专栏：OSChina

挑战A.I.，赢百万奖金......了解更多详情>>>

代码语言：javascript
复制
package com.shi.lambda;

import java.util.Arrays;
import java.util.List;

import org.junit.Test;

import com.shi.model.Employee;

/**
 * 初始化案例
 * @author xiaoshi
 *
 */
public class _1_FirstDomo {
	
	List<Employee> employees = Arrays.asList(new Employee("张三",12,665.23),
			new Employee("张三",12,789.23),
			new Employee("张三",15,133.23),
			new Employee("张三",20,7884.23),
			new Employee("张三",30,8784.23),
			new Employee("张三",40,665.23));
	
	/**
	 * 查询年龄小于等于20岁的员工的信息  Lembda stream
	 */
	@Test
	public void getEmployeeByAge() {
		employees.stream()
				.filter((e) -> e.getAge()<20)
				.forEach(System.out::println);
	}
	
	/**
	 * 查询工资大于的1000的员工信息  Lembda  stream
	 */
	@Test
	public void getEmployeeBySalary() {
		employees.stream()
				.filter((e) -> e.getSalary()>1000)
				.forEach(System.out::println);
	}
}
  • lambda
代码语言：javascript
复制
package com.shi.lambda;

import java.util.Comparator;
import java.util.function.Consumer;

import org.junit.Test;

/**
 * 一 . lambda 表达式的基础语法：JAVA8 中引用了一个新的操作符 “->” 该操作符称为箭头操作符或者叫做lambda操作符
 * 
 * 箭头操作符将lambda表达式拆封成俩部分：
 * 左测：lambda 表达式的参数列表
 * 右侧： lambda 表达式所需执行的功能，及lambda体
 * 
 * 语法格式一：无参数，无返回值
 * 	   () -> System.out.println("hello Lambda");
 * 
 * 语法格式二：有一个参数，并且无返回值 (如果是一个参数 括号可以不写 )
 *    	x -> System.out.println(x);
 * 
 * 语法格式三：有俩个以上的参数，有返回值，并且Lambda 体中有多条语句
 * 			Comparator<Integer> con = (x,y) -> {
			System.out.println("函数式接口");
			return Integer.compare(x, y);
		};
 * 
 * 语法格式四：有俩个以上的参数，有返回值，并且Lambda 体中有只有一条语句
 *   Comparator<Integer> con = (x,y) -> Integer.compare(x, y);
 *
 * 
 * 语法格式五： Lambda 表达式的参数列表的类型可以省略不写，
 * 因为JVM编译器 通过上下文推断出，数据类型，既“类型判断”
 * 
 * 口诀： 左侧遇一括号省；
 * 		右侧遇一return省；
 * 		左侧推断类型省；
 * 		右侧多条大括号；
 * 
 * 二. lambda 表达式需要“函数式接口”的支持
 * 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口  可以使用@FunctionalInterface修饰（检查接口是否是函数式接口）
 * 
 * @author xiaoshi
 *
 */
public class _2_lambdaTest {

	//无参数，无返回值
	@Test
	public void test1() {
		System.out.println("-------之前的实现方式------");
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println("hello world!");
			}
		};
		r.run();
		
		System.out.println("-------lambda的实现方式------");
		Runnable r1 = () -> System.out.println("hello lambda");
		r1.run();
	}
	
	
	//有一个参数，并且无返回值 (如果是一个参数 括号可以不写 )
	@Test
	public void test2() {
		Consumer<String> con = x -> System.out.println(x);
		con.accept("像接口中添加元素");
	}
	
	
	//有俩个以上的参数，有返回值，并且Lambda 体中有多条语句
	@Test
	public void test3() {
		Comparator<Integer> con = (x,y) -> {
			System.out.println("函数式接口");
			return Integer.compare(x, y);
		};
		System.out.println(con.compare(10, 12));
	}
	
	
	//语法格式四：有俩个以上的参数，有返回值，并且Lambda 体中有只有一条语句
	@Test
	public void test4() {
		Comparator<Integer> con = (x,y) -> Integer.compare(x, y);
		System.out.println(con.compare(10, 6));
	}
	
	
	
}
  • 函数式接口
代码语言：javascript
复制
package com.shi.lambda;

import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

import org.junit.Test;

/**
 * Java8 4大核心函数式接口
 * 	
 * Consumer<T> :消费型接口 (有参数，无返回值的接口)
 * 			void accept(T t);
 * 
 * Supplier<T> :供给型接口(无参数，有返回值的接口)
 * 			T get();
 * 
 * Function<T,R> :函数型接口(参数T类型，返回值R类型)
 * 			R apply(T t);
 * 
 * Predicate<T> : 断言型接口 (参数 T类型，返回Boolean)
 * 			boolean test(T t);
 * 
 * @author xiaoshi
 *
 */
public class _3_LambdaFunction {
	
	//Consumer<T> :消费型接口    (有参数，无返回值的接口)
	@Test
	public void test1 () {
		Consumer<Double> con = (m) -> System.out.println("我消费"+m+"$");
		con.accept(100.0);//调用接口
	}
	
	
	//Supplier<T> :供给型接口   (无参数，有返回值的接口)
	@Test
	public void test2() {
		Supplier<String> supp = () -> UUID.randomUUID().toString();
		System.out.println(supp.get());//调用接口
	}
	
	//Function<T,R> :函数型接口 (参数T类型，返回值R类型)
	@Test
	public void test3() {
		//把Double转换成字符串输出
		Function<Double,String> fun = (item) -> item.toString();
		System.out.println(fun.apply(123.334));//调用接口
	}
	
	
	//Predicate<T> : 断言型接口 (参数 T类型，返回Boolean)
	@Test
	public void test4() {
		//字符串的长度大于4则返回
		Predicate<String> prd = (item) -> item.length() > 4;
		System.out.println(prd.test("shiye"));//调用接口
	}
}
  • Stream
代码语言：javascript
复制
package com.shi.stream;

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

import org.junit.Test;

import com.shi.model.Employee;

/**
 * Stream 是一个流，不改变数据源，产生一个新的数据的流
 * Stream 是一个惰性求值，延迟加载的过程
 * 
 * 
 * 一。 Stream的三个操作步骤
 * 
 * 1. 创建stream，
 * 2.中间操作
 * 3.终止操作（终端操作  ）
 * 
 * 
 * @author xiaoshi
 *
 */
public class _4_StreamTest {
	
	//创建stream
	@Test
	public void test1() {
		//1. 可以通过Collection系列集合提供的Stream(串行流) 或者 parallelStream(并行流)
		List<String> list = new ArrayList<>();
		Stream<String> stream1 = list.stream();
		
		//2. 通过Arrays 中的静态方法stream() 获取数组流
		Employee[] emps = new Employee[10];
		Stream<Employee> stream2 = Arrays.stream(emps);
		
		//3. 通过Stream类中的静态方法of()
		Stream<String> stream3 = Stream.of("aa","bb","cc");
		
		
		//4. 创建无限流(迭代)
		Stream<Integer> stream4 = Stream.iterate(0, (x) -> x+2);
		stream4.limit(5).forEach(System.out::println);
		
		//5 使用 Stream.generate() 方法
		Stream.generate(() -> Math.random())
				.limit(10).forEach(System.out::println);
	}
	

}
代码语言：javascript
复制
package com.shi.stream;

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

import org.junit.Test;

import com.shi.model.Employee;

/**
 * Stream 的中间操作
 * 
 * @author xiaoshi
 *
 */
public class _5_StreamTest {
	
	List<Employee> employees = Arrays.asList(new Employee("张三",12,100.23),
			new Employee("李四",23,789.23),
			new Employee("王五",15,133.23),
			new Employee("赵六",8,7884.23),
			new Employee("田七",30,8784.23),
			new Employee("田七",30,8784.23),
			new Employee("田七",30,8784.23),
			new Employee("田七",30,8784.23),
			new Employee("刘八",40,665.23));
	
	/**
	 * 筛选与切片
	 * 	filter - 接收Lambda,从流中排除某些元素
	 * 	limit - 截断流，使其元素不超过给定数量
	 * 	skip(n) - 跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空值，与limit（n）互补
	 * 	distinct - 筛选，通过流中所生成元素的HashCode() 和 equals() 去除重复元素
	 */
	@Test
	public void test1() {
		//中间操作：不会执行任何操作
		System.out.println("*********** filter ************");
		Stream<Employee> stream = employees.stream()
										.filter((e) -> {
											System.out.println("遍历到当前值"+e.getAge());
											return e.getAge() > 20;
										});
		//终止操作：一次性执行全部内容，既：“惰性求值”
		stream.forEach(System.out::println);
		
		System.out.println("---------------limit----------------");
		employees.stream()
				.filter((e) -> {
					System.out.println("短路！");
					return e.getSalary() > 500;
				})
				.limit(2)
				.forEach(System.out::println);
		
		System.out.println("***************skip  distinct**************");
		employees.stream()
				 .filter((e) -> e.getSalary()>500)
				 .skip(2)
				 .distinct()
				 .forEach(System.out::println);
		
	}
	
	
	/**
	 * 映射 ：
	 * 		map - 接收lambda，将元素转换成其他形式或者提取信息。接收一个函数作为参数，
	 * 			     该函数会被应用到每个元素上，并将映射成一个新的函数
	 * 		flatMap - 接收一个函数作为参数，将流中的每个值都换成一个流，然后把所有流连接成一个流
	 */
	@Test
	public void test2() {
		List<String> list = Arrays.asList("aaa","bbb","ccc");
		
		System.out.println("************map************");
		list.stream()
			.map((str) -> str.toUpperCase())
			.forEach(System.out::println);
		
		employees.stream()
				.map(Employee::getName)
				.forEach(System.out::println);
		
		System.out.println("************flatMap************");
	}
	
	/**
	 * 排序：
	 * 		sorted() - 自然排序（comparable）
	 * 		sorted(Comparator comparator) - 定制排序(Comparator)
	 */
	@Test
	public void test3() {
		List<String> list = Arrays.asList("ccc","ddd","eee","aaa","bbb");
		
		System.out.println("------------自然排序------------");
		list.stream()
			.sorted()
			.forEach(System.out::println);
		
		System.out.println("------------定制排序------------");
		employees.stream()
				 .sorted((e1,e2) -> {
					 if(e1.getAge().equals(e2.getAge())) {
						 return e1.getName().compareTo(e2.getName());
					 }else {
						 return e1.getAge().compareTo(e2.getAge());
					 }
				 }).forEach(System.out::println);
	}
	
	
	/**
	 * 查找与匹配：
	 * 		allMatch - 检查匹配所有元素
	 * 		anyMatch - 匹配到任意一个元素
	 * 		noneMatch - 没有匹配到任意一个元素
	 */
	@Test
	public void test4() {
		
		System.out.println("-----------allMatch-----------");
		boolean allMatch = employees.stream()
				 .allMatch((e) -> {
					 System.out.println("匹配到但前元素" + e.getAge());
					 return e.getAge()< 30 ;
				 });
		System.out.println(allMatch);
		
		
		System.out.println("-----------anyMatch-----------");
		boolean anyMatch = employees.stream()
				 .anyMatch((e) -> {
					 System.out.println("匹配到但前元素" + e.getAge());
					 return e.getAge()< 30 ;
				 });
		System.out.println(anyMatch);
		
		System.out.println("-----------noneMatch-----------");
		boolean noneMatch = employees.stream()
				 .noneMatch((e) -> {
					 System.out.println("匹配到但前元素" + e.getAge());
					 return e.getAge()< 30 ;
				 });
		System.out.println(noneMatch);
		
		System.out.println("-----------findFirst-----------");
		Optional<Employee> findFirst = employees.stream()
				 .sorted((e1,e2) -> e1.getAge().compareTo(e2.getAge()))
				 .findFirst();
		System.out.println(findFirst.get());
		
		
		System.out.println("-----------findAny-----------");
		Optional<Employee> findAny = employees.stream()
				 .sorted((e1,e2) -> e1.getAge().compareTo(e2.getAge()))
				 .findAny();
		System.out.println(findAny.get());
		
		
		System.out.println("-----------max-----------");
		Optional<Employee> max = employees.stream()
				 .max((e1,e2) -> e1.getAge().compareTo(e2.getAge()));
		System.out.println(max.get());
		
		
		System.out.println("-----------min-----------");
		Optional<Integer> min = employees.stream()
				 .map( Employee::getAge)
				 .min(Integer::compareTo); //这里调用上下文中的compareTo
		System.out.println(min.get());
	} 
	
	
	/**
	 * 规约
	 * reduce(T identity, BinaryOperator<T> accumulator)/ 
	 * reduce(BinaryOperator<T> accumulator) 
	 *  - 可以将流中的元素反复结合起来，得到一个值
	 */
	@Test
	public void test5() {
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		
		System.out.println("---------reduce--------");
		Integer sum = list.stream()
			.reduce( 0 , (x,y) -> x + y );
		System.out.println(sum);
		
		System.out.println("---------reduce2--------");
		Optional<Double> reduce2 = employees.stream()
				 .map(Employee::getSalary)
				 .reduce(Double::sum);
		System.out.println(reduce2.get());
	}
	
	/**
	 * 收集 ：
	 * 	collect - 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream 中元素做汇总的方法
	 */
	@Test
	public void test6() {
		
		System.out.println("********collect********");
		Set<String> collect = employees.stream()
				 .map(Employee::getName)
				 .collect(Collectors.toSet()); //去除重复元素
		System.out.println(collect);
		
		System.out.println("**********linkedHashSet**********");
		LinkedHashSet<String> linkedHashSet = employees.stream()
				 .map(Employee::getName)
				 .collect(Collectors.toCollection(LinkedHashSet::new));
		linkedHashSet.forEach(System.out::println);
	}
}
代码语言：javascript
复制
package com.shi.frokjoin;

import java.util.concurrent.RecursiveTask;

/**
 *  简单的模拟Fork/Join框架的使用
 * @author xiaoshi
 *
 */
public class ForkJoinCalculate extends RecursiveTask<Long>{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private long start;
	private long end;
	private static final long THRESHOLD = 10000;
	
	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();
		}
	}

}
代码语言：javascript
复制
package com.shi.frokjoin;

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;

/**
 * 效率测试
 * @author xiaoshi
 *
 */
public class TestForkJoin {

	/**
	 * 使用fork/join框架进行测试用时时间
	 * 
	 * 数据：100000000L	10000000000L
	 * 时间： 34毫秒		1204毫秒
	 */
	@Test
	public void test1() {
		Instant start = Instant.now();
		
		ForkJoinPool pool = new ForkJoinPool();
		ForkJoinTask<Long> task = new ForkJoinCalculate(0,10000000000L);
		Long sum = pool.invoke(task);
		System.out.println(sum);
		
		Instant end = Instant.now();
		System.out.println("耗时时间为：" + Duration.between(start, end).toMillis() + "毫秒");
	}
	
	
	/**
	 * 使用单线程用时时间
	 * 数据：100000000L	10000000000L
	 * 时间：425毫秒		27855毫秒
	 */
	@Test
	public void test2() {
		Instant start = Instant.now();
		
		Long sum = 0L;
		for(long i = 0;i < 10000000000L; i++) {
			sum += i;
		}
		System.out.println(sum);
		
		Instant end = Instant.now();
		System.out.println("耗时时间为：" + Duration.between(start, end).toMillis() + "毫秒");
	}
		
	/**
	 * 使用JAVA 8 提供的并行流
	 * 
	 * 数据：100000000L	10000000000L
	 * 时间：66毫秒		825毫秒
	 */
	@Test
	public void test3() {
		Instant start = Instant.now();
		
		LongStream.rangeClosed(0,10000000000L)
					.parallel()
					.reduce(0, Long::sum);
		
		Instant end = Instant.now();
		System.out.println("耗时时间为：" + Duration.between(start, end).toMillis() + "毫秒");
	}
	
}
  • 日期
代码语言：javascript
复制
package com.shi.date;

import java.time.DayOfWeek;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.Set;

import org.junit.Test;

/**
 * JAVA8 日期时间的操作
 * @author xiaoshi
 *
 */
public class DateTest {
	
	/**
	 * 获取当前时间
	 * LocalDate、LocalTime、LocalDateTime
	 */
	@Test
	public void test1() {
		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		
		LocalTime localTime = LocalTime.now();
		System.out.println(localTime);
		
		LocalDateTime localDateTime = LocalDateTime.now();
		System.out.println(localDateTime);
		
	}
	
	/**
	 * 指定时间日期的转化 (不能超出时间限制)
	 */
	@Test
	public void test2() {
		LocalDate localDate = LocalDate.of(2019, 5, 18);
		System.out.println(localDate);
		
		LocalTime localTime = LocalTime.of(18, 29, 45);
		System.out.println(localTime);
		
		LocalDateTime localDateTime = LocalDateTime.of(2018, 12, 1, 23, 11, 12);
		System.out.println(localDateTime);
	}
	
	/**
	 * 日期的加减操作（+ - ）
	 */
	@Test
	public void test3() {
		LocalDate localDate = LocalDate.now();
		System.out.println("当前时间："+localDate);
		System.out.println("当前时间加3天："+localDate.plusDays(3));
		System.out.println("当前时间加3个月："+localDate.plusMonths(3));
		System.out.println("当前时间加3年："+localDate.plusYears(3));
		System.out.println("当前时间加2周："+localDate.plusWeeks(2));
		
		System.out.println("当前时间减去3天："+localDate.minusDays(3));
		System.out.println("当前时间减去3个月："+localDate.minusMonths(3));
		System.out.println("当前时间减去3年："+localDate.minusYears(3));
		System.out.println("当前时间减去2周："+localDate.minusWeeks(2));
	}
	
	/**
	 * 获取年月日，和时间基本判断
	 */
	@Test
	public void test4() {
		LocalDate localDate = LocalDate.now();
		System.out.println("这个月的天数："+localDate.getDayOfMonth());
		System.out.println("今年的第几天："+localDate.getDayOfYear());
		System.out.println("今天是周几："+localDate.getDayOfWeek());
		System.out.println("今天是第几月："+localDate.getMonth());
		System.out.println("今天是第几年："+localDate.getYear());
		
		
		LocalDate plusDays = localDate.plusDays(3);
		LocalDate minusDays = localDate.minusDays(2);
		
		System.out.println("localDate在plusDays之前：" + localDate.isBefore(plusDays));
		System.out.println("localDate在minusDays之后：" + localDate.isAfter(minusDays));
		
		System.out.println("今年是不是润年"+localDate.isLeapYear());
	}
	
	/**
	 * Duration 和 Period  
	 * Duration:用于计算两个“时间”间隔
	 * Period:用于计算两个“日期”间隔
	 */
	@Test
	public void test5() {
		LocalDate localDate = LocalDate.now();
		LocalDate plusDays = localDate.plusDays(10);
		
		LocalDateTime localDateTime = LocalDateTime.now();
		LocalDateTime plusMinutes = localDateTime.plusMinutes(46);
		
		System.out.println("时间相差：" + Duration.between(localDateTime, plusMinutes).toMinutes() + "分钟");
		System.out.println("日期相差：" + Period.between(localDate, plusDays).getDays() + "天");
	}
	
	/**
	 * 时间矫正器
	 * 下一个日期的指定
	 */
	@Test
	public void test6() {
		LocalDate nextLocalDate = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.WEDNESDAY));
		System.out.println("下一个周三的日期 : " + nextLocalDate);
	}
	
	/**
	 * 格式化日期时间
	 */
	@Test
	public void test7() {
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
		LocalDateTime localDateTime = LocalDateTime.now();
		String now = dateTimeFormatter.format(localDateTime);
		System.out.println(" 根据ISO_LOCAL_DATE_TIME格式化日期 ：  " + now);
		
		DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
		System.out.println("指定日期格式转化 : " + ofPattern.format(localDateTime));
	}
	
	/**
	 * 获取所有时区
	 */
	@Test
	public void test8() {
		Set<String> set = ZoneId.getAvailableZoneIds();
		set.forEach(System.out::println);
	}
	
	/**
	 * ZonedDate、ZonedTime、ZonedDateTime
	 * 获取指定时区下的时间
	 */
	@Test
	public void test9() {
		LocalDateTime localDateTime1 = LocalDateTime.now(ZoneId.of("America/Cuiaba"));
		System.out.println("America/Cuiaba时区下面的时间 : " + localDateTime1);
		
		LocalDateTime localDateTime2 = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
		System.out.println("Asia/Shanghai时区下的时间 :  " + localDateTime2);
		
	}
	
	
	
}
  • 其他特性
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除
api

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

api
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
LV.
文章
0
获赞
0
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2024 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论