JAVA 8 新特性 （值得学习）

Posted 2020-10-03

JAVA 8 已经出现好长时间了，大的互联网公司很多都已经使用了，甚至很多知名互联网公司踩过很多坑，也有一些大牛分享出了他们的实战经验。去很多知名的互联网公司经常会被面试官问，你了解java 8吗？你知道它的一些新特性吗？好像似乎成了一面面试官必问的一道题目。这篇博文，只是简答的介绍了一下新特性，同学们还得自己实际操作，深入了解，最好能实际应用到项目里，如果你是项目组里用的比较早，用的比较多的同学，还会被其他的同事注意到你，哈哈。

Lambda表达式和函数式接口

下面就是简单的lambda表示的应用，代码非常简洁，直接item则是list集合里的String，输出就可以了

，item是编译器自动推理得出是一个String类型的

List<String> list = Arrays.asList("sdc","zs","ls","ww");
		
list.forEach(item -> {
	System.out.println(item);
});

Stream.of(12,21,13,31).filter( s -> {
System.out.println("out:" +s); return true;})
.forEach(System.out::println);;

这个就是简单的的lambda表达式，lambda其实和函数式接口联系是比较多的，java8里也有好多的类是函数式接口，什么是函数式接口？函数接口指的就是只有一个函数的接口，是不是很绕口，这又有什么关系？我也说不清楚，函数式接口是可以自定义的，一般再接口最上方加上@FunctionalInterface这个注解，就是函数式接口了，一般函数接口是不准许有其他的函数，但是默认方法和静态方法可以排除，以前java接口里没有看到可以写方法的，java8里可以写默认方法。

下面简单写一个默认方法和抽象方法，

private interface DefaultInterface {
		
		default String defaultMethod() {
			return "default method";
		}
		
}
	
private interface DefaultInterfaceStatic {
		
	    static String staticMethod() {
			return "static method";
		}
		
}

有时间的同学看一下 Collection<E> 这个接口里的东西，这个集合接口里有一些用到默认方法的实现，有一些是它本身自带的，有些是继承 Iterable<T> 这个接口而覆盖了这个接口里的默认方法。例如：

 default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

同学们可以自己动手写写函数式接口，和接口里的默认方法，尝试一下，本身自己的项目是否可以修改成这样的。

重复注解：

java 8 也可以定义重复注解，java本身是支持自自定义注解的，比如如下

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Test {

        String test() default "无";

}

这就是一个自定义注解。

java8 定义重复注解，

 @Repeatable( Filters.class )

注解上加上这个，则可以定义重复注解，不过一般公司开发或者大型公司开发，自定义注解是比较多，但是重复注解有什么用，我还是没搞懂，所以这块就简单介绍了一下，怎么定义就行，重复注解什么场景使用我就不太清楚了。

Streams

这个特性可能是java 8 里比较高级的一个特性，用java边写的时候，集合往往用的是最多的，写一个接口很大可能会涉及到集合。通常集合的迭代逻辑都是for循环，Streams则是隐藏了这种操作，简化了开发。再java8以前的集合都是加载内存中的，非常占用内用，但是又不得不使用，Streams则是再访问的时候才开始计算出来。

什么是Streams？下面几个简单的例子来解释

List<String> list = Arrays.asList("sdc","zs","ls","ww");

这样就是一套流
list.stream().filter(s -> s.startsWith("s")).map(String::toUpperCase).sorted().forEach(System.out::println);

也可以这样
Arrays.asList("sdc","zs","ls","ww").stream().findFirst().ifPresent(System.out::println);

streams包含中间和最终两种形式的操作，中间操作返回的还是一个streams，但是不会有输出，最总操作是返回有结果的。上面写的map,sorted,findFirst都是中间操作，如果不加后面的话就会没有输出操作，大多数的streams操作都是可以使用lambda表达式的。

Streams类有顺序的streams和并行的streams，并行一看就是多线程的类，适合在多线程中用。

//		Arrays.asList("sdc","zs","ls","ww").stream().findFirst().ifPresent(System.out::println);
		
//		Stream.of("sdc","zs","ls","ww").findFirst().ifPresent(System.out::println);
		
//		IntStream.range(1, 4).forEach(System.out::println);
		
//		Arrays.stream(new int[]{4,5,6}).map(n -> 2*n +1).average().ifPresent(System.out::println);
		
//		IntStream.range(1, 4).mapToObj(p -> "sucess" + p).forEach(System.out::println);
		
//		Stream.of(100.0, 200.0, 300.0).mapToInt(Double::intValue).mapToObj(h -> h+"str").forEach(System.out::println);
		
//		Stream.of(12,21,13,31).filter( s -> {System.out.println("out:" +s); return true;});
		
//		Stream.of(12,21,13,31).filter( s -> {System.out.println("out:" +s); return true;}).forEach(System.out::println);;
		
//		Stream.of("ds","qw","ty","op","as")
//			.map(s -> {
//				System.out.println("map:" + s);
//				return s.toUpperCase();
//			})
//			.filter(s -> {
//				System.out.println("filter:" + s);
//				return s.startsWith("Q");
//			})
//			.forEach(s -> {
//				System.out.println("foreach:" + s);
//			});
		
//		Stream.of("ds","qw","ty","op","as")
//		.filter(s -> {
//			System.out.println("filter:" + s);
//			return s.startsWith("q");
//		})
//		.map(s -> {
//			System.out.println("map:" + s);
//			return s.toUpperCase();
//		})
//		.forEach(s -> {
//			System.out.println("foreach:" + s);
//		});
	
//		Stream.of("ds","qw","ty","op","as")
//		.sorted((s1, s2) -> {
//			System.out.println("sorted:" + s1 +"," +s2);
//			return s1.compareTo(s2);
//		})
//		.filter(s -> {
//			System.out.println("filter:" + s);
//			return s.startsWith("q");
//		})
//		.map(s -> {
//			System.out.println("map:" + s);
//			return s.toUpperCase();
//		})
//		.forEach(s -> {
//			System.out.println("foreach:" + s);
//		});
		
//		Stream.of("ds","qw","ty","op","as")
//		.filter(s -> {
//			System.out.println("filter:" + s);
//			return s.startsWith("q");
//		})
//		.sorted((s1, s2) -> {
//			System.out.println("sorted:" + s1 +"," +s2);
//			return s1.compareTo(s2);
//		})
//		.map(s -> {
//			System.out.println("map:" + s);
//			return s.toUpperCase();
//		})
//		.forEach(s -> {
//			System.out.println("foreach:" + s);
//		});
		
//		Stream<String> stream = Stream.of("a1", "d3", "i9","r8").filter( s-> s.startsWith("i"));
//		stream.anyMatch(s -> true);
//		stream.noneMatch(s -> true);
		
//		Supplier<Stream<String>> streamSupplier = () ->Stream.of("a1", "d3", "i9","r8").filter( s-> s.startsWith("i"));
//		streamSupplier.get().anyMatch(s -> true);
//		streamSupplier.get().noneMatch(s -> true);
		
		//stream 的高级特性
		List<User> userList = Arrays.asList(new User("sdc", 20), new User("zhangsan", 20), new User("lisi", 34));
//		List<User> newList = userList.stream().filter(u -> u.getUser().startsWith("s")).collect(Collectors.toList());
//		Set<User> set = userList.stream().filter(u -> u.getUser().startsWith("s")).collect(Collectors.toSet());
//		System.out.println(set);
		
//		Map<Integer, List<User>> userGMap = userList.stream().collect(Collectors.groupingBy(u -> u.getAge()));
//		userGMap.forEach((age, p) -> {
//			System.out.println(age + "||" + p);
//		});
		
//		double averrage = userList.stream().collect(Collectors.averagingInt(u -> u.getAge()));
//		System.out.println(averrage);
		
//		String phrase = userList.stream().filter(u -> u.getAge() >=19).map(p -> p.getUser()).collect(Collectors.joining(" and ", " in ", " high age "));
//		System.out.println(phrase);

这些是基本的一些方法，我觉得还是自己用用，实战一下，可能很多人都不太习惯这些操作。