JAVA 8 新特性（值得学习）-阿里云开发者社区

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