java8增加了不少新特性,下面就一些常见的新特性进行学习。。。

1、接口中的方法

2、函数式接口

3、Lambda表达式

4、java8内置的四大核心函数式接口

5、方法引用和构造器引用

6、Stream API

7、并行流和串行流

8、Optional 类

9、新的时间与日期API

一:接口中的方法

  在之前,接口中的方法都是抽象方法,默认被public abstract修饰,没有方法体。接口中的成员变量都是常量。

 (1)接口中的静态方法

package com.bjsxt.testInterface;

import sun.plugin2.os.windows.FLASHWINFO;

/**
* Created by Administrator on 2019/3/5.
* 接口中使用static修饰的方法必须有方法体
* 接口中使用static修饰的方法只能被接口本身调用。 接口名.方法名(...)
* 接口中的static方法不能被子接口继承
* 接口中的static方法不能被实现类重写或者直接调用
*/
public interface Fly { //接口中的抽象方法
void air(); //接口中的静态方法,有方法体
static void wings(){
System.out.println("有翅膀。。。。。可以飞");
} } interface FlyChildren extends Fly{ } class Bird implements Fly{
@Override
public void air() {
System.out.println("鸟飞翔需要空气。。。");
} } class Test{
public static void main(String[] args){
Fly.wings(); //接口调用接口中的静态方法
FlyChildren.wings(); //报错,无法调用
Bird bird=new Bird();
bird.wings(); //报错,无法调用
}
}

  (2)接口中default修饰的方法

注意:接口默认方法的”类优先”原则

若一个接口中定义了一个默认方法,而另外一个父类或接口中又定义了一个同名的方法时选择父类中的方法。如果一个父类提供了具体的实现,那么接口中具有相同名称和参数的默认方法会被忽略。接口冲突。如果一个父接口提供一个默认方法,而另一个接口也提供了一个具有相同名称和参数列表的方法(不管方法是否是默认方法),那么必须覆盖该方法来解决冲突

package com.bjsxt.testInterface;

import sun.plugin2.os.windows.FLASHWINFO;

/**
* Created by Administrator on 2019/3/5.
* 接口中使用default修饰的方法必须有方法体
* 接口中使用default修饰的方法不能被接口本身调用。
* 接口中的default方法可以被子接口继承
* 接口中的default方法可以被实现类重写或者直接调用
*/
public interface Fly { //接口中的抽象方法
void air(); //接口中default修饰的方法,有方法体
default void wings(){
System.out.println("有翅膀。。。。。可以飞");
} } interface FlyChildren extends Fly{ } class Bird implements Fly{
@Override
public void air() {
System.out.println("鸟飞翔需要空气。。。");
} // @Override
// public void wings() {
// System.out.println("鸟儿有翅膀,可以飞......");
// }
} class Test{
public static void main(String[] args){
Bird bird=new Bird();
bird.wings();  //此时调用的是接口中的方法
}
}

二:函数式接口

  有且仅有一个抽象方法,但是可以有很多个非抽象方法的接口就是函数式接口,函数式接口可以被隐式转换为lambda表达式,函数式接口上面可以加个

@FunctionalInterface注解

  

@FunctionalInterface
public interface Fly { //接口中的抽象方法
void air(); //接口中default修饰的方法,有方法体
default void wings(){
System.out.println("有翅膀。。。。。可以飞");
}
}

三、Lambda表达式

Lambda 表达式需要“函数式接口”的支持(感觉就是对匿名内部类的简化)
函数式接口:接口中只有一个抽象方法的接口,称为函数式接口。 可以使用注解 @FunctionalInterface 修饰可以检查是否是函数式接口

Lambda 表达式的基础语法:Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符箭头操作符将 Lambda 表达式拆分成两部分:
左侧:Lambda 表达式的参数列表
右侧:Lambda 表达式中所需执行的功能, 即 Lambda 体

package com.bjsxt.testInterface;

/**
* Created by Administrator on 2019/3/5.
*/
public interface TestInterface { int sum(int num1,int num2);
} class Test{
public static void main(String[] args){
test3();
} public static void test1(){
//使用匿名内部类的写法
TestInterface testInterface=new TestInterface() {
@Override
public int sum(int num1, int num2) {
return num1+num2;
}
};
System.out.println(testInterface.sum(10,20));
} public static void test2(){
//lambda写法1,常规写法
TestInterface testInterface=(int num1, int num2)->{
return num1+num2;
};
System.out.println(testInterface.sum(10,20));
} public static void test3(){
/*
* lambda写法2,简略写法
* 形参的数据类型可以省略掉,jvm虚拟机会根据上下文自动推断(类型推断),如果只有一个参数()也可以省略掉
* 如果方法体中的代码只有一行,{}可以省略掉,如果是return返回数据的,return也可以省略掉
**/ TestInterface testInterface=(num1, num2)->num1+num2;
System.out.println(testInterface.sum(10,20));
}
}

案例:

package com.bjsxt.lambda;

/**
* Created by Administrator on 2019/3/6.
* 函数式接口
*/
@FunctionalInterface
public interface MyFunction { Integer getValue(Integer num);
}
package com.bjsxt.lambda;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List; /**
* Created by Administrator on 2019/3/6.
*/
public class TestLambda01 { public static void main(String[] args){
int aa=test1(100,(num)->{return num*num;});
} public static Integer test1(Integer num,MyFunction myFunction){
return myFunction.getValue(num);
} }

四、java8内置的四大核心函数式接口

Java8 内置的四大核心函数式接口

Consumer<T> : 消费型接口
  void accept(T t);  //抽象方法
Supplier<T> : 供给型接口
  T get();   //抽象方法
Function<T, R> : 函数型接口
  R apply(T t);  //抽象方法
Predicate<T> : 断言型接口
  boolean test(T t);  //抽象方法

package com.bjsxt.lambda;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier; /**
* Java8 内置的四大核心函数式接口
*
* Consumer<T> : 消费型接口
* void accept(T t);
*
* Supplier<T> : 供给型接口
* T get();
*
* Function<T, R> : 函数型接口
* R apply(T t);
*
* Predicate<T> : 断言型接口
* boolean test(T t);
*/
public class TestLambda02 { public static void main(String[] args){ test1("helloWorld",str->System.out.println(str)); List list=test2(()->(int)(Math.random()*100));
list.forEach(System.out::print); } /**
* 测试消费型接口
* @param str
*/
public static void test1(String str,Consumer<String> consumer){
consumer.accept(str);
} /**
* 测试供给型接口
*/
public static List<Integer> test2(Supplier<Integer> supplier){
List<Integer> list=new ArrayList<>();
for(int i=0;i<10;i++){
list.add(supplier.get());
}
return list;
} }

其他两个接口也是同样,不再测试,还有其他一些内置的子接口,都是同样的用法

五、方法引用和构造器引用

package com.bjsxt.lambda;

import java.io.PrintStream;
import java.util.function.*; /**
* 一、方法引用:若 Lambda 体中的功能,已经有方法提供了实现,可以使用方法引用
* (可以将方法引用理解为 Lambda 表达式的另外一种表现形式)
* 1. 对象的引用 :: 实例方法名
* 2. 类名 :: 静态方法名
* 3. 类名 :: 实例方法名
* 注意:
* ①方法引用所引用的方法的参数列表与返回值类型,需要与函数式接口中抽象方法的参数列表和返回值类型保持一致!
* ②若Lambda 的参数列表的第一个参数,是实例方法的调用者,第二个参数(或无参)是实例方法的参数时,格式:类名 :: 实例方法名
*
* 二、构造器引用 :构造器的参数列表,需要与函数式接口中参数列表保持一致!
* 1. 类名 :: new
*
* 三、数组引用
* 类型[] :: new;
*/
public class TestLambda03 { public static void main(String[] args){
// test1(); test2();
} /**
* 方法引用
* 对象的引用 :: 实例方法名
*/
public static void test1(){
Consumer<String> consumer=str->System.out.println(str); //原来的写法
consumer.accept("hello world");
PrintStream ps=System.out;
Consumer<String> consumer1=ps::println; //现在写法
consumer1.accept("hello world2"); System.out.println("---------------------------------------"); Student stu=new Student(1,"段然涛",24);
Supplier<String> supplier=()->stu.getName(); //原来写法
System.out.println(supplier.get()); Supplier<String> supplier2=stu::getName; //现在写法
System.out.println(supplier.get());
} /**
* 方法引用
* 类名 :: 静态方法名
*/
public static void test2(){
BiFunction<Integer,Integer,Integer> biFunction=(x,y)->Math.max(x,y); //以前的写法
System.out.println(biFunction.apply(3,4)); BiFunction<Integer,Integer,Integer> biFunction2=Math::max; //现在的写法
System.out.println(biFunction2.apply(6,5));
} /**
* 方法引用
* 类名 :: 实例方法名
*/
public static void test3(){
BiPredicate<String, String> bp = (x, y) -> x.equals(y); //以前写法
System.out.println(bp.test("abx","abx"));
BiPredicate<String, String> bp2=String::equals; //现在写法
System.out.println(bp.test("abx","abx"));
} /**
* 构造器引用
* 类名 :: new
*/
public static void test4(){
Supplier<Student> supplier=()->new Student(2,"李飞宇",34); //以前写法
System.out.println(supplier.get());
Supplier<Student> supplier2=Student::new; //现在写法,用的是无参的构造函数,因为该函数式接口里面的抽象方法是无参的
System.out.println(supplier.get()); BiFunction<Integer,String,Student> biFunction=Student::new; //用的是两个参数的构造函数
System.out.println(biFunction.apply(3,"阿飞")); } /**
* 数组引用
* 类型[] :: new;
*/
public static void test5(){
Function<Integer,String[]> function=(num)->new String[num]; //以前的写法
System.out.println(function.apply(10)); Function<Integer,String[]> function2=String[]::new; //现在写法
System.out.println(function2.apply(10)); }
} class Student{
public int id; public String name; public int age; public Student() { } public Student(int id, String name) {
this.id = id;
this.name = name;
} public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
} public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
}
}

java8新特性学习1的更多相关文章

  1. Java8 新特性学习 Lambda表达式 和 Stream 用法案例

    Java8 新特性学习 Lambda表达式 和 Stream 用法案例 学习参考文章: https://www.cnblogs.com/coprince/p/8692972.html 1.使用lamb ...

  2. java8 新特性学习笔记

    Java8新特性 学习笔记 1主要内容 Lambda 表达式 函数式接口 方法引用与构造器引用 Stream API 接口中的默认方法与静态方法 新时间日期 API 其他新特性 2 简洁 速度更快 修 ...

  3. java8新特性学习:函数式接口

    本文概要 什么是函数式接口? 如何定义函数式接口? 常用的函数式接口 函数式接口语法注意事项 总结 1. 什么是函数式接口? 函数式接口其实本质上还是一个接口,但是它是一种特殊的接口:SAM类型的接口 ...

  4. java8新特性学习:stream与lambda

    Streams api 对 Stream 的使用就是实现一个 filter-map-reduce 过程,产生一个最终结果,或者导致一个副作用(side effect). 流的操作类型分为两种: Int ...

  5. Java8 新特性学习

    摘自:https://blog.csdn.net/shuaicihai/article/details/72615495 Lambda 表达式 Lambda 是一个匿名函数,我们可以把 Lambda ...

  6. java8新特性学习2

    六.Stream API Java8中有两大最为重要的改变.第一个是 Lambda 表达式:另外一个则是 Stream API(java.util.stream.*).Stream 是 Java8 中 ...

  7. java8新特性学习笔记(二) 使用流(各种API)

    筛选和切片 用谓词筛选,筛选出各个不相同的元素,忽略流中的头几个元素,或将流截断至指定长度 用谓词筛选 Stream接口支持filter方法,该操作接受一个谓词(返回一个boolean的函数) 作为参 ...

  8. java8新特性学习笔记(二) 流的相关思想

    流是什么 流是Java API的新成员,他允许你以声明的方式处理数据集合,就现在来说,可以把他们看成遍历数据集合的高级迭代器.此外,流还可以透明地并行处理,你无须写任何多线程代码. 下面例子是新老AP ...

  9. Java8新特性学习笔记(一) Lambda表达式

    没有用Lambda表达式的写法: Comparator<Transaction> byYear = new Comparator<Transaction>() { @Overr ...

随机推荐

  1. css设置文字中间的小竖线

    主要css属性是border-right border-right:1px solid gray; padding-right:10px; padding-left:10px; <div dat ...

  2. WPF的项目,ListBox 纵向滚动条不显示

    最近在做WPF的项目,ListBox 纵向滚动条不显示,但是鼠标滚轮可以在ListBox中使用,但是必须要出现纵向滚动条.  索性就直接在listBox外面包裹一个ScrollViewer. Scro ...

  3. Junit入门教程

    做开发的时候,完成一个接口.方法.函数或者功能等,需要测试,是否有bug,有逻辑错误.这里有两种方案测试 1. 在main中写测试方法 2. 使用开源框架,这里使用的junit main写测试方法优点 ...

  4. The twentyth day

    10th Dec 2018 Cause It's hard for me to lose in my life I've found  因为失去你是一种煎熬 Only time will tell a ...

  5. 转 【<meta name="description" content=">】作用讲解

    今天在看别人写的网站代码,发现类似<meta name="Keywords" content="" >.<meta name="De ...

  6. SharedPreferences的封装

    android.content.SharedPreferences是一个接口,用来获取和修改持久化存储的数据.有三种获取系统中保存的持久化数据的方式: 1). public SharedPrefere ...

  7. BIEE入门(二)物理层的定义

    使用BIEE的第一步是使用admintool去建立一个多维数据模型,而建立多维数据模型的第一步则是建立物理层,请注意因为BIEE本身并不存 储数据,所以所谓BIEE物理层的意义是需要在BIEE里建立各 ...

  8. 【Leetcode】【Easy】Add Binary

    Given two binary strings, return their sum (also a binary string). For example,a = "11"b = ...

  9. vs2010开发链接服务器出现错误(SourceSafe)

    用vs2010开发项目链接服务器时出现 之前是因为权限问题,每次打开项目文件时 ,都要先直接进服务器然后打开项目. 用了两天,又不行了.就这个问题已经问了了老大不下3次了. 其实很是不想再麻烦他老人家 ...

  10. 观察者模式在One Order回调函数中的应用

    例如需求是搞清楚function module CRM_PRODUCT_I_A_CHANGE_ORGM_EC在什么样的场景下会被调用.当然最费时间的做法是设一个断点,然后跑对应的场景,观察断点何时被触 ...