java8简化参数的简单介绍

本篇文章给大家谈谈java8简化参数，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、Java8新特性有哪些？
• 2、如何更好地使用Java 8的Optional
• 3、Java8有哪些新特性
• 4、Java9都快发布了,Java8的十大新特性你了解多少呢
• 5、常用JVM参数(JDK 8)

Java8新特性有哪些？

【注意】本文节选自是 DZone 指南#8194;Java 生态系统的专题文章，作者Trisha Gee是Java资深工程师和布道者。在本文中，Trisha Gee阐述了Java 8的重要特性以及使用的原因，由OneAPM工程师翻译。

一、要点速递

1、在很多情况下，Java8 都能提升应用性能，而无需任何改变或性能调优。

2、 Lambda 表达式、 Streams API 以及现有类的新方法都是提高生产力的重要工具。

3、Java8 新推出的 Optional 类型在处理 null 值时，能减少 NullPointerExceptions 的可能性，给开发者极大的灵活度。

二、其他特性：

速度更快

可以取悦老板、满足业务或运营人员的一大卖点是：Java8 运行应用时速度更快。通常，升级至 Java8 的应用都能得到速度上的提升，即便没有做任何改变或调优。对于为了迎合特定 JVM 而做出调整的应用，这或许并不适用。但 Java8 性能更优的理由还有很多：

80%以上的高端企业级应用都使用JAVA平台（电信、银行等）。JAVA是成熟的产品，已经有10年的历史。如果你想在Java行业有所建树，想要系统的进行java的学习，那么你可以来这个群，前面是二三一，中间是三一四，后面是零二八。连起来就可以了。 这里有很多互联网大牛教你学习，还有免费的课程。不是想学习的就不要加了。

常见数据结构的性能提升：对广受欢迎的 HashMap 进行的基准测试表明，它们在 Java8 中的性能更好。这种提升非常吸引人——你无需学习新的 Streams API 或 Lambda 语法，甚至不需要改变现有的代码，就能提升应用的性能。

垃圾回收器提升：通常，Java 应用性能取决于垃圾回收的效率。的确，糟糕的垃圾回收会很大程度上影响应用性能。Java8 对垃圾回收做了很多改变，能有效提升性能并简化调优。最为人熟知的改变是 PermGen 的移除与 Metaspace 的引入。

Fork/Join 速度提升：fork/join 框架是在 Java7 中首次引入的，目的是简化使用 JVM 的并发程序。Java8 中投入了很多努力进一步提升该框架。现在，fork/join 在 Streams API 中用于并发操作。

此外，Java8 中还包含诸多改进以支持并发。Oracle 在 JDK 8 中总结了这些性能提升。

代码行更少

Java 经常被人们诟病其样本代码太多。为此，Java8 新的 API 采用了更具功能性的方式，专注于实现什么而不是如何实现。

Lambda 表达式

Java8 中的 Lambda 表达式不仅是 Java 已有的匿名内部类—— Java8 推出之前传递行为的方法之外的语法糖衣。Lambda 表达式采用了 Java 7 的内部改变，因此运用起来相当流畅。想了解如何使用 Lambda 表达式简化代码，请继续阅读。

集合新方法介绍

Lambda 表达式与 Streams 可能是 Java8 最大的两个卖点，较少为人知的是 Java 现在允许开发者给现有类添加新的方法，而无需为了向后兼容性折中。这样，新的方法，结合 Lambda 表达式，能在很大程序上简化代码。比如，我们常常需要判断 Map 中的某个成员是否已经存在，如果不存在则创建之。在 Java8 之前，你可能会这么做：

private final MapCustomerId, Customer customers = new HashMap();  

public void incrementCustomerOrders(CustomerId customerId) {  

Customer customer = customers.get(customerId);  

if (customer == null) {  

    customer = new Customer(customerId);  

    customers.put(customerId, customer);  

}  

customer.incrementOrders();  

}

操作“检查某个成员在 map 中是否存在，若不存在则添加之”是如此常用，Java 现在为 Map 添加了一个新方法 computeIfAbsent 来支持这个操作。该方法的第二个参数是一个 Lambda 表达式，该表达式定义了如何创建缺少的成员。

public void incrementCustomerOrders(CustomerId customerId) {  

Customer customer = customers.computeIfAbsent(customerId,  

       id - new Customer(id));  

customer.incrementOrders();  

}

其实，Java8 还有一个新的特性，称为方法引用(method references)，它能使我们用更简洁的代码实现该功能：

public void incrementCustomerOrders(CustomerId customerId) {  

Customer customer = customers.computeIfAbsent(customerId, Customer::new);  

customer.incrementOrders();  

}

Java8 为 Map 与 List 都添加了新方法。你可以了解一下这些新方法，看它们能节省多少行代码。

Streams API

Streams API 为查询、操纵数据提供了更多灵活度。这是一个很强大的功能。阅读这些文章能对 Streams API 有更全面的了解。在大数据时代建立流畅的数据查询会非常有趣，而且也是常用的操作。比如，你有一列书，你希望按照字母表顺序排列这些书的作者名，且不含重复。

public ListAuthor getAllAuthorsAlphabetically(ListBook books) {  

ListAuthor authors = new ArrayList();  

for (Book book : books) {  

    Author author = book.getAuthor();  

    if (!authors.contains(author)) {  

        authors.add(author);  

    }  

}  

Collections.sort(authors, new ComparatorAuthor() {  

    public int compare(Author o1, Author o2) {  

        return o1.getSurname().compareTo(o2.getSurname());  

    }  

});  

return authors;  

}

在上面的代码中，我们首先遍历这列书，如果书的作者从未在作者列表出现，则添加之。之后，我们根据作者的姓氏按字母表顺序对这些作者排序。这种排序操作正是 Streams 擅长解决的领域：

public ListAuthor getAllAuthorsAlphabetically(ListBook books) {  

return books.Streams()  

            .map(book - book.getAuthor())  

            .distinct()  

            .sorted((o1, o2) - o1.getSurname().compareTo(o2.getSurname()))  

            .collect(Collectors.toList());  

}

上面的做法不仅代码行更少，而且描述性更强——后来的开发者读到这段代码能够轻易理解：1、代码从书中获取作者姓名。2、只在意从未出现过的作者。3、返回的列表按照作者姓氏排序。将 Streams API 与其他新特性——方法引用(method references)、比较器(Comparator)的新方法结合使用，可以得到更加简洁的版本：

public ListAuthor getAllAuthorsAlphabetically(ListBook books) {  

return books.Streams()  

            .map(Book::getAuthor)  

            .distinct()  

            .sorted(Comparator.comparing(Author::getSurname))  

            .collect(Collectors.toList());  

}

这里，排序方法按照作者姓氏排序，更加显而易见了。

便于并行

此前我们浅聊过更利于开箱即用的性能，除了前面提到过的特性，Java8 能更好地利用 CPU 内核。将前例中的 Streams 方法替换为 parallelStreams，JVM 会将此运算分解为不同的任务，使用 fork/join 将这些任务运行在多个核上。然而，并行化并不是加速所有运算的魔法。并行化运算总是会带来更多工作——分解运算，整合结果，因此无法总是减少时间。但是，对适合并行化的例子，这么做还是颇有效率的。

最大化减少 Null 指针

Java8 的另一个新特性是全新的 Optional 类型。该类型的含义是“我可能有值，也可能是 null。“这样一来，API 就可以区分可能为 null 的返回值与绝对不会是 null 的返回值，从而最小化 NullPointerException 异常的发生几率。

Optional 最赞的用处是处理 null。例如，假设我们要从一个列表中找一本特定的书，新创建的 findFirst() 方法会返回 Optional 类型的值，表明它无法确保是否找到特定的值。有了这个可选择的值，我们接下来可以决定，如果是 null 值要如何处理。如果想要抛出一个自定义的异常，我们可以使用 orElseThrow：

public Book findBookByTitle(ListBook books, String title) {  

OptionalBook foundBook = books.Streams()  

       .filter(book - book.getTitle().equals(title))  

       .findFirst();  

return foundBook.orElseThrow(() - new BookNotFoundException("Did not find book with title " + title));  

}

或者，你可以返回其他书：

return foundBook.orElseGet(() - getRecommendedAlternativeBook(title));

或者，返回 Optional 类型，这样，该方法的调用者可以自己决定书没找到时要怎么做。

总结：Java8 作为 Java 语言的一次重大发布，包含语法上的更改、新的方法与数据类型，以及一些能默默提升应用性能的隐性改善。Oracle 已经不再支持 Java 7，因此许多公司都被迫向 Java8 转移。好消息是，Java8 对业务、现有的应用以及期望提高生产力的开发者都好好多。

如何更好地使用Java 8的Optional

Java 8中的OptionalT是一个可以包含或不可以包含非空值的容器对象，在 Stream API中很多地方也都使用到了Optional。

java中非常讨厌的一点就是nullpoint，碰到空指针就会出错抛Exception，然后需要逐行检查是哪个对象为空，带来大量的不必要精力损耗，抛出NPE错误不是用户操作的错误，而是开发人员的错误，应该被避免，那么只能在每个方法中加入非空检查，阅读性和维护性都比较差。

如下面这个代码的手工非空检查：

public void addAddressToCustomer(Customer customer, Address newAddress){ if ( customer == null || newAddress == null) return; if ( customer.getAddresses() == null ){ customer.setAddresses ( new ArrayList()); } customer.addAddress(newAddress);}

另外还有一些开发人员喜欢通过非空检查来实现业务逻辑，空对象不应该用来决定系统的行为，它们是意外的Exceptional值，应当被看成是错误，而不是业务逻辑状态。

当我们一个方法返回List集合时，应该总是返回一个空的List，而不是Null，这就允许调用者能够遍历它而不必检查Null，否则就抛出NPE。

但是如果我们根据标识键ID查询数据库，没有查到，需要返回一个空对象怎么办？有人建议抛出Exception，其实这不符合函数方法一进一出的原则，变成一个函数方法有两个返回，一个是正常返回，一个出错Exception，函数式编程范式告诫我们不要轻易抛Exception。

这时Java 8的Optional就发挥作用了，允许我们返回一个空的对象。

OptionalT有方法 isPresent() 和 get() 是用来检查其包含的对象是否为空或不是，然后返回它，如：

OptionalSomeType someValue = someMethod();

if (someValue.isPresent()) { // check

someValue.get().someOtherMethod(); // retrieve and call

}

但是这种用法并不能体现Java 8的全部好处，你可以将Optional看成是需要使用某个T值的方法之间某种中间人或者协调者Mediator，而不只是一个普通对象的包装器。

如果你有一个值返回类型T，你有一个方法需要使用这个值，那么你可以让 OptionalT 处于中间，确保它们之间交互进行，而不必要人工干预。

这样，协调者OptionalT能够照顾T的值提供给你的方法作为输入参数，在这种情况下，如果T是空，可以确保不会出错，这样在T值为空时也可以让一切都正常运作，你也可以让OptionalT执行其他动作，如执行一段代码块等等，这样它就实际上是语言机制的很好的补充。

下面这个案例涉及到Lambda表达式 方法引用，是将单词流中第一个以"L"开始单词取出，作为返回结果是一个OptionalString。

使用ifPresent()

这个案例的代码如下：

Streamstring names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

Optionalstring longest = names

.filter(name - name.startsWith("L"))

.findFirst();

longest.ifPresent(name - {

String s = name.toUpperCase();

System.out.println("The longest name is "+ s);

});

这里ifPresent() 是将一个Lambda表达式作为输入，T值如果不为空将传入这个lambda。那么这个lambda将不为空的单词转为大写输出显示。在前面names单词流寻找结果中，有可能找不到开始字母为L的单词，返回为空，也可能找到不为空，这两种情况都传入lambda中，无需我们打开盒子自己编写代码来判断，它自动帮助我们完成了，无需人工干预。

使用map()

如果你想从OptionalT中返回一个值怎么办？使用 map()，如下：

Streamstring names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

Optionalstring longest = names

.filter(name - name.startsWith("L"))

.findFirst();

Optionalstring lNameInCaps = longest.map(String::toUpperCase);

使用OptionalT的map方法能够返回另外一个Optional，如上面的 LnameInCaps，因为传入map()的参数值也许会导致一个空值。

使用orElse()

如果在T可能空时你需要一个值的话，那么可以使用 orElse()，它能在T值存在的情况下返回这个值，否则返回输入值。

StreamString names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

OptionalString longest = names

.filter(name - name.startsWith("Q"))

.findFirst();

String alternate = longest.orElse("Nimrod");

System.out.println(alternate); //prints out "Nimrod"

使用orElseGet()

orElseGet() 方法类似于orElse()，但是不是直接返回输入参数，而是调用输入参数，返回调用的结果，这个输入参数通常是lambda：

StreamString names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

OptionalString longest = names

.filter(name - name.startsWith("Q"))

.findFirst();

String alternate = longest.orElseGet(() - {

// perform some interesting code operation

// then return the alternate value.

return "Nimrod";

});

System.out.println(alternate);

使用 orElseThrow()

orElseThrow()是在当遭遇Null时，决定抛出哪个Exception时使用：

StreamString names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

OptionalString longest = names

.filter(name - name.startsWith("Q"))

.findFirst();

longest.orElseThrow(NoSuchElementStartingWithQException::new);

总结，你能创建下面三种类型的OptionalT：

OptionalSomeType getSomeValue() {

// 返回一个空的Optional类型;

return Optional.empty();

}

OptionalSomeType getSomeValue() {

SomeType value = ...;

// 使用这个方法，值不可以为空，否则抛exception

return Optional.of(value);

}

OptionalSomeType getSomeValue() {

SomeType value = ...;

// 使用这个方法，值可以为空，如果为空返回Optional.empty

return Optional.ofNullable(value);

// usage

OptionalSomeType someType = getSomeValue();

Java8有哪些新特性

jdk1.8的新特性包括如下：

一、接口的默认方法与静态方法，也就是接口中可以有实现方法

二、Lambda 表达式

三、函数式接口与静态导入

四、Lambda 作用域

在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。

五、访问局部变量，等等其他新特性。

Java9都快发布了,Java8的十大新特性你了解多少呢

一、Lambda表达式

Lambda表达式可以说是Java 8最大的卖点，她将函数式编程引入了Java。Lambda允许把函数作为一个方法的参数，或者把代码看成数据。

一个Lambda表达式可以由用逗号分隔的参数列表、–符号与函数体三部分表示。例如：

Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e - System.out.println( e ) );

1 Arrays.asList( "p", "k", "u","f", "o", "r","k").forEach( e - System.out.println( e ) );

为了使现有函数更好的支持Lambda表达式，Java

8引入了函数式接口的概念。函数式接口就是只有一个方法的普通接口。java.lang.Runnable与java.util.concurrent.Callable是函数式接口最典型的例子。为此，Java

8增加了一种特殊的注解@FunctionalInterface：

1 @FunctionalInterface

2 public interface Functional {

3 void method();

4 }

二、接口的默认方法与静态方法

我们可以在接口中定义默认方法，使用default关键字，并提供默认的实现。所有实现这个接口的类都会接受默认方法的实现，除非子类提供的自己的实现。例如：

1 public interface DefaultFunctionInterface {

2 default String defaultFunction() {

3 return "default function";

4 }

5 }

我们还可以在接口中定义静态方法，使用static关键字，也可以提供实现。例如：

1 public interface StaticFunctionInterface {

2 static String staticFunction() {

3 return "static function";

4 }

5 }

接口的默认方法和静态方法的引入，其实可以认为引入了C＋＋中抽象类的理念，以后我们再也不用在每个实现类中都写重复的代码了。

三、方法引用

通常与Lambda表达式联合使用，可以直接引用已有Java类或对象的方法。一般有四种不同的方法引用：

构造器引用。语法是Class::new，或者更一般的Class T ::new，要求构造器方法是没有参数；

静态方法引用。语法是Class::static_method，要求接受一个Class类型的参数；

特定类的任意对象方法引用。它的语法是Class::method。要求方法是没有参数的；

特定对象的方法引用，它的语法是instance::method。要求方法接受一个参数，与3不同的地方在于，3是在列表元素上分别调用方法，而4是在某个对象上调用方法，将列表元素作为参数传入；

四、重复注解

在Java 5中使用注解有一个限制，即相同的注解在同一位置只能声明一次。Java

8引入重复注解，这样相同的注解在同一地方也可以声明多次。重复注解机制本身需要用@Repeatable注解。Java

8在编译器层做了优化，相同注解会以集合的方式保存，因此底层的原理并没有变化。

五、扩展注解的支持

Java 8扩展了注解的上下文，几乎可以为任何东西添加注解，包括局部变量、泛型类、父类与接口的实现，连方法的异常也能添加注解。

六、Optional

Java 8引入Optional类来防止空指针异常，Optional类最先是由Google的Guava项目引入的。Optional类实际上是个容器：它可以保存类型T的值，或者保存null。使用Optional类我们就不用显式进行空指针检查了。

七、Stream

Stream

API是把真正的函数式编程风格引入到Java中。其实简单来说可以把Stream理解为MapReduce，当然Google的MapReduce的灵感也是来自函数式编程。她其实是一连串支持连续、并行聚集操作的元素。从语法上看，也很像linux的管道、或者链式编程，代码写起来简洁明了，非常酷帅！

八、Date/Time API (JSR 310)

Java 8新的Date-Time API (JSR 310)受Joda-Time的影响，提供了新的java.time包，可以用来替代

java.util.Date和java.util.Calendar。一般会用到Clock、LocaleDate、LocalTime、LocaleDateTime、ZonedDateTime、Duration这些类，对于时间日期的改进还是非常不错的。

九、JavaScript引擎Nashorn

Nashorn允许在JVM上开发运行JavaScript应用，允许Java与JavaScript相互调用。

十、Base64

在Java 8中，Base64编码成为了Java类库的标准。Base64类同时还提供了对URL、MIME友好的编码器与解码器。

除了这十大新特性之外，还有另外的一些新特性：

更好的类型推测机制：Java 8在类型推测方面有了很大的提高，这就使代码更整洁，不需要太多的强制类型转换了。

编译器优化：Java 8将方法的参数名加入了字节码中，这样在运行时通过反射就能获取到参数名，只需要在编译时使用-parameters参数。

并行（parallel）数组：支持对数组进行并行处理，主要是parallelSort()方法，它可以在多核机器上极大提高数组排序的速度。

并发（Concurrency）：在新增Stream机制与Lambda的基础之上，加入了一些新方法来支持聚集操作。

Nashorn引擎jjs：基于Nashorn引擎的命令行工具。它接受一些JavaScript源代码为参数，并且执行这些源代码。

类依赖分析器jdeps：可以显示Java类的包级别或类级别的依赖。

JVM的PermGen空间被移除：取代它的是Metaspace（JEP 122）。

常用JVM参数(JDK 8)

-Xss ：线程栈空间

-Xms : 初始堆空间，如： -Xms512M

-Xmx : 最大堆空间，如： -Xmx512M

-XX:MinHeapFreeRatio : 堆空间最小空闲比，当堆空间空闲内存小于这个数值时，JVM会扩展堆空间。

-XX:MaxHeapFreeRatio : 堆空间最大空闲比，当堆空间空闲内存大于这个数值时，JVM会压缩堆空间，得到一个较小的堆。

-XX:NewSize : 新生代初始空间

-XX:MaxNewSize : 最大新生代空间

-Xmn : 相当于设置相同的 -XX:NewSize 和 -XX:MaxNewSize .

-XX:SurvivorRatio : 新生代中eden空间和s0空间的比例

-XX:TargetSurvivorRatio : survivor区的可使用率，当survivor区的空间使用率达到这个数值时，会将对象送入老年代。

-XX:NewRatio : 老年代 / 新生代的空间比例

-XX:MetaspaceSize=512m : 分配给类元数据空间的初始大小，以bytes为单位，达到该值就会触发垃圾收集进行类型卸载，同时GC会对该值进行调整：如果释放了大量的空间，就适当的降低该值；如果释放了很少的空间，那么在不超过MaxMetaspaceSize（如果设置了的话），适当的提高该值。

-XX:MaxMetaspaceSize=512m : 分配给类元数据空间的最大值, 超过此值就会触发Full GC. 此值仅受限于系统内存的大小, JVM会动态地改变此值

-XX:MinMetaspaceFreeRatio ,在GC之后，最小的Metaspace剩余空间容量的百分比，减少为class metadata分配空间导致的垃圾收集。

-XX:MaxMetaspaceFreeRatio ,在GC之后，最大的Metaspace剩余空间容量的百分比，减少为class metadata释放空间导致的垃圾收集。

-XX:CompressedClassSpaceSize=512m : 类指针压缩空间大小, 默认为1G

-XX:+PrintGCDetails : 打印GC细节

-XX:+PrintGC :

-XX:+PrintGCTimeStamps :

-XX:+PrintHeapAtGC :

Java 8 以前的JVM内存结构图：

其中：

虚拟机栈 在运行时使用 栈帧 保存上下文，栈帧中存储了以下内容：

更为精细地， 堆 和 方法区 的结构如下：

堆 分为 新生代 和 老年代 .

新生代 分为 Eden区 、 s0区（survivor space0或from space） 和 s1区（survivor space1或to space） 。

大部分新创建的对象进入Eden区，幸存区s0区和s1区存放经历了至少一次GC的“幸存者”。如果幸存区中的对象到了指定年龄仍未被回收，则有机会进入 老年代（tenured）

对于习惯了HotSpot虚拟机的程序员来说，很多都愿意将 方法区 称作 永久代 。本质上来讲两者并不等价，仅因为Hotspot将GC分代扩展至方法区，或者说使用永久代来实现方法区。在其他虚拟机上是没有永久代的概念的。也就是说方法区是Java虚拟机规范，永久代是Hotspot针对该规范进行的实现。

堆 和 方法区 都是被JVM中所有线程共享的。

Java 8以后的JVM内存结构图：

Java8中，Hotspot取消了永久代，永久代的参数 -XX:PermSize 和 -XX：MaxPermSize 也随之失效。

对于Java8，HotSpots取消了永久代，是不是就没有方法区了呢？当然不是，方法区只是一个规范，只不过它的实现变了。

在Java8中， 方法区存在于元空间(Metaspace) 。同时，元空间不再与堆连续，而且是存在于本地内存（Native memory）。

本地内存（Native memory） ，也称为 C-Heap ，是供JVM自身进程使用的。当Java Heap空间不足时会触发GC，但本地内存空间不够却不会触发GC。

元空间存在于本地内存，意味着只要本地内存足够，它不会出现像永久代中 java.lang.OutOfMemoryError: PermGen space 这种错误。默认情况下元空间是可以无限使用本地内存的，但JVM同样提供了参数 -XX:MaxMetaspaceSize 来限制它使用的空间。

java8简化参数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、java8简化参数的信息别忘了在本站进行查找喔。