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);


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