Java8以及Java9的一些有用的新特性总结

淩亂°似流年 2022-06-07 01:18 141阅读 0赞

Java 8:

1.Lambda表达式

首先，什么是Lambda表达式?

所谓的Lambda表达式通俗的讲就是一种没有名字的函数，其中涉及到一些函数式编程的知识，这在移动开发领域应用十分广泛，关于函数式编程网络上的资料有很多，有兴趣的朋友可以自行查阅，使用这种表达式好处是可以使得我们的代码更加的简洁，当然这会使得代码的可读性大大降低，在一些情况下，也会造成代码的效率变差。

下面给出一个使用Lambda表达式的例子:

public class Test03 {
        public static void main(String[] args) {
            List<Integer> list=new ArrayList<>();
            for(int i=0;i<10;i++){
                list.add(i);
            }
            list.forEach((temp)-> System.out.println(temp));
        }
    
    }

定义了一个匿名的函数，其作用就是输出temp的值。很不一样，是吧?通过源码，我们来看一下forEach()函数的构造:

default void forEach(Consumer<? super T> action) {
            Objects.requireNonNull(action);
            for (T t : this) {
                action.accept(t);
            }
        }

其实也是遍历了list中的元素，然后丢给action的accept()方法。

2.默认方法

然后看一下Consumer这个参数，其实这是一个函数式接口，这也是Java8的一个新特新

@FunctionalInterface
    public interface Consumer<T> {
    
        /**
         * Performs this operation on the given argument.
         *
         * @param t the input argument
         */
        void accept(T t);
    
        /**
         * Returns a composed {@code Consumer} that performs, in sequence, this
         * operation followed by the {@code after} operation. If performing either
         * operation throws an exception, it is relayed to the caller of the
         * composed operation.  If performing this operation throws an exception,
         * the {@code after} operation will not be performed.
         *
         * @param after the operation to perform after this operation
         * @return a composed {@code Consumer} that performs in sequence this
         * operation followed by the {@code after} operation
         * @throws NullPointerException if {@code after} is null
         */
        default Consumer<T> andThen(Consumer<? super T> after) {
            Objects.requireNonNull(after);
            return (T t) -> { accept(t); after.accept(t); };
        }

怎么接口中也可以定义方法了?其实这叫做缺省方法，下面是其相关的解释:  
"缺省方法是在接口中定义方法实现的一种方式，并且保证所有已经存在的子类的兼容性，所以实现了接口的类默认都拥有在接口中定义的缺省方法，这有点像一个抽象类。当一个子类中没有覆盖缺省方法时，则对子类的该方法的调用将调用接口中的实现。"

3.静态方法

public interface Test031 {
        static int test(int n){
            if(n==1) return 1;
            if(n==2) return 1;
            return test(n-1)+test(n-2);
        }
    }

4.优化了HashMap以及concurrenthashmap  
将HashMap原来的数组+链表的结构优化成了数组+链表+红黑树的结构，减少了hash碰撞造成的链表长度过长，时间复杂度过高的问题，concurrenthashmap 则改进了原先的分段锁的方式，采用transient volatile HashEntry<K,V>\[\] table来保存数据。

还有的一些特性在http://www.cnblogs.com/pkufork/p/java\_8.html中有介绍，这里不再赘述。

5.JVM

PermGen空间被移除了，取而代之的是Metaspace。JVM选项-XX:PermSize与-XX:MaxPermSize分别被-XX:MetaSpaceSize与-XX:MaxMetaspaceSize所代替。

6.新增原子性操作类LongAdder

### 7.新增StampedLock ###

Java9:

1.jshell

使用指南:

http://docs.oracle.com/javase/9/jshell/toc.htm

2.私有接口方法

现在接口真是越来越像强大了，先是可以编写方法，现在连访问权限都可以定义成private的了，我在网上copy了一个例子:

public interface MyInterface {
    
      void normalInterfaceMethod();
    
      default void interfaceMethodWithDefault() { init(); }
    
      default void anotherDefaultMethod() { init(); }
    
      // This method is not part of the public API exposed by MyInterface
      private void init() { System.out.println("Initializing"); }
    }

大体就是实现接口的类不想把复用代码创建为一个默认方法，所以通过一个私有的辅助方法解决这个问题。

3.更改了 HTTP 调用的相关api(有点像Retrofit啊，有木有)

HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest req =
      HttpRequest.newBuilder(URI.create("http://www.google.com"))
           .header("User-Agent","Java")
           .GET()
           .build();
    
    
    HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandler.asString());

4.集合工厂方法  
初始化集合类的时候不用使用add()方法去添加元素了，直接调用Set.of(...)即可完成初始化。

5.改进了 Stream API

以上就是java8、9的一些新特性，如有错误还请指正。

参考文章:

http://www.importnew.com/17262.html

http://liugang594.iteye.com/blog/2063432