JAVA 8 已经出现好长时间了，大的互联网公司很多都已经使用了，甚至很多知名互联网公司踩过很多坑，也有一些大牛分享出了他们的实战经验。去很多知名的互联网公司经常会被面试官问，你了解java 8吗？你知道它的一些新特性吗？好像似乎成了一面面试官必问的一道题目。这篇博文，只是简答的介绍了一下新特性，同学们还得自己实际操作，深入了解，最好能实际应用到项目里，如果你是项目组里用的比较早，用的比较多的同学，还会被其他的同事注意到你，哈哈。
Lambda表达式和函数式接口
下面就是简单的lambda表示的应用，代码非常简洁，直接item则是list集合里的String，输出就可以了
，item是编译器自动推理得出是一个String类型的
|
1
2
3
4
5
6
7
8
9
|
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里可以写默认方法。
下面简单写一个默认方法和抽象方法，
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
private
interface
DefaultInterface {
default
String defaultMethod() {
return
"default method"
;
}
}
private
interface
DefaultInterfaceStatic {
static
String staticMethod() {
return
"static method"
;
}
}
|
有时间的同学看一下 Collection<E> 这个接口里的东西，这个集合接口里有一些用到默认方法的实现，有一些是它本身自带的，有些是继承 Iterable<T> 这个接口而覆盖了这个接口里的默认方法。例如：
|
1
2
3
|
default
Stream<E> stream() {
return
StreamSupport.stream(spliterator(),
false
);
}
|
同学们可以自己动手写写函数式接口，和接口里的默认方法，尝试一下，本身自己的项目是否可以修改成这样的。
重复注解：
java 8 也可以定义重复注解，java本身是支持自自定义注解的，比如如下
|
1
2
3
4
5
6
7
8
|
@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？下面几个简单的例子来解释
|
1
2
3
4
5
6
7
|
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，并行一看就是多线程的类，适合在多线程中用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
// 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);
|
这些是基本的一些方法，我觉得还是自己用用，实战一下，可能很多人都不太习惯这些操作。
