java.util 1.8_初步学习java 1.8新特性

java 8发行版是自2004年发行的java 5以来最具有革命性的一个版本。java 8为java语言、编译器、类库、开发工具与JVM等带来了大量新特性。

本文为大家详细介绍了java 1.8中的几个新特性，希望能够帮助到大家。

1、lambda表达式

格式：(参数) -> {代码段}

如：new Thread(() -> {System.out.println("hello world!")}).start(); 这就是lambda表达式。

lambda的实现需要依赖函数式接口,lambda本质上是匿名内部类，jdk1.8以前，如果方法内需要操作其他接口的实现方法，可以通过匿名内部类来实现，

jdk1.8之后可以通过lambda表达式来代替匿名内部类，并且更为简化。package java8;

public class LambdaDemo {

public static void main(String[] args) {

//JDK1.8之前使用接口,采用匿名内部类的方式

MyInterface mi = new MyInterface() {

@Override

public void test() {

System.out.println("test");

}

};

mi.test();

//JDK1.8之后，使用lambda表达式

MyInterface lmi = () -> {

System.out.println("test");

};

lmi.test();

}

}

//定义一个函数式接口，只有一个抽象方法

interface MyInterface{

void test();

}

函数式接口 : 有且只有一个的抽象方法的接口称为函数式接口

函数式接口的常用接口 Function, Predicate,Supplier,Consumer 都在java.util.function包下

Function接口：R apply(T t) 接收一个参数并返回一个对象package java8;

import java.util.function.Function;

public class LambdaDemo {

public static void main(String[] args) {

// function的使用

// 传统模式,第一个泛型：接收的参数类型 第二个泛型，返回的参数类型

Function function1 = new Function() {

@Override

public String apply(String t) {

return t;

}

};

// 调用apply方法，并获取返回结果

String res1 = function1.apply("function的使用");

System.out.println(res1);

// lambda的使用,当参数只有一个且不写参数类型时，"()"可以省略

Function function2 = t -> {

return t;

};

// 调用apply方法，并获取返回结果

String res2 = function2.apply("function的使用");

System.out.println(res2);

}

}

Predicate接口 ： boolean test(T t) 接收一个参数，返回一个boolean值

常用来比较package java8;

import java.util.function.*;

public class LambdaDemo {

public static void main(String[] args) {

// predicate的使用

// 传统模式,泛型参数：接收的参数类型

Predicate predicate1 = new Predicate() {

@Override

public boolean test(Integer t) {

// 大于等于10就为真，否则为假

return t >= 10;

}

};

// 执行predicate1的方法

System.out.println(predicate1.test(11));

System.out.println(predicate1.test(8));

//使用lambda表达式

Predicate predicate2 = new Predicate() {

@Override

public boolean test(Integer t) {

// 大于等于10就为真，否则为假

return t >= 10;

}

};

// 执行predicate1的方法

System.out.println(predicate2.test(11));

System.out.println(predicate2.test(8));

}

}

Supplier接口 ：T get() 返回一个对象

生产者消费者模式的生产者，只管生产对象package java8;

import java.util.function.*;

public class LambdaDemo {

public static void main(String[] args) {

//Supplier的使用

// 传统模式,泛型参数：返回的参数类型

Supplier s1 = new Supplier() {

@Override

public String get() {

return new String("supplier");

}

};

//调用

System.out.println(s1.get());

// 使用lambda表达式

//当代码只有一句时，可以省略"{}",不接收参数时，"()"不能省略

Supplier s2 = () -> new String("supplier");

System.out.println(s2.get());

}

}

Consumer接口 ： accept(T t)接收一个参数，不返回任何值

生产者消费者模式的生产者，只管消费对象package java8;

import java.util.function.*;

public class LambdaDemo {

public static void main(String[] args) {

// Consumer的使用

// 传统模式,泛型参数：返回的参数类型

Consumer con1 = new Consumer() {

@Override

public void accept(String t) {

System.out.println(t);

}

};

con1.accept("consumer");

//使用lambda表达式,同时省略"()","{}"

Consumer con2 = t -> System.out.println(t);

con2.accept("consumer");

}

}

(学习视频分享：java视频教程)

lambda实战用法：package java8;

import java.util.function.*;

public class LambdaDemo {

public static void main(String[] args) {

//Runnable的实现，

new Thread(() -> {

System.out.println(Thread.currentThread().getName() + " run");

}).start();

System.out.println(Thread.currentThread().getName() + " run");

}

}

2、方法引用：

方法引用是指lambda表达式中只有一句方法调用，而这个方法有真实存在，此时就可以用方法引用来替换lambda表达式。

方法引用有四种类型

类名::静态方法名

对象名::实例方法名

类名::实例方法名

类名::newpackage java8;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.function.BiConsumer;

import java.util.function.Supplier;

public class MethodReferenceDemo {

public static void main(String[] args) {

// 定义3个Student对象

Student s1 = new Student("zhangsan", 90);

Student s2 = new Student("lisi", 60);

Student s3 = new Student("wangwu", 70);

// 添加到集合

List students = Arrays.asList(s1, s2, s3);

//普通的lambda实现

// sort接收两个参数，第一个参数，要排序的集合，第二个参数，Comparator接口的实现

// Collections.sort(students, (stu1,stu2) -> StudentSortUtil.sortByScore(stu1,stu2));

// students.forEach(t -> System.out.println(t.getScore()));

// 方法引用1---类名::静态方法名

// Collections.sort(students, StudentSortUtil::sortByScore);

// students.forEach(t -> System.out.println(t.getScore()));

//创建实例对象，调用实例对象的方法

StudentSortUtil ssu = new StudentSortUtil();

//普通的lambda实现

//Collections.sort(students, (stu1, stu2) -> ssu.sortByScoreInstance(stu1, stu2));

//students.forEach(t -> System.out.println(t.getScore()));

// 方法引用2---对象名::实例方法名

//Collections.sort(students, ssu::sortByScoreInstance);

//students.forEach(t -> System.out.println(t.getScore()));

/*

* 方法引用3---类名::实例方法名

* Student的sortByScore()只有一个参数，而Comparator的实现需要两个参数，为什么编译器不报错？

* 这是因为sortByScore是一个普通方法，要使用这个方法肯定要有一个Student类的实例对象来调用

* 而调用的这个方法的对象就作为Comparator的第一个参数对象传递进来

* 例String的compareTo()方法，调用这个方法首先要有一个String的实例对象，

* 此处str就是这个实例对象,str就作为Comparator的第一个参数

* "hello"这个String对象就作为第二个参数

* String str = new String("str1");

* str.compareTo("hello");

*/

Collections.sort(students, Student::sortByScore);

//创建一个新的Student对象,使用lambda表达式创建

//不接收参数，返回一个对象，其实就是Supplier接口的实例

Supplier su1 = () -> new Student();

//方法引用4---类名::new

Supplier su2 = Student::new;

//BiConsumer是Consumer的扩展，可以接受两个参数返回一个值

BiConsumer bc1 = (name,score) -> new Student(name,score);

//替换上面的lambda表达式，需要接收两个参数，所以调用的是有参构造方法

BiConsumer bc2 = Student::new;

}

}

//定义一个学生实体类

class Student {

private String name;

private int score;

public Student() {

}

public Student(String name, int score) {

this.name = name;

this.score = score;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

public int sortByScore(Student stu) {

return this.getScore() - stu.getScore();

}

public int sortByName(Student stu) {

return this.getName().compareTo(stu.getName());

}

}

//定义一个学生排序工具类

class StudentSortUtil {

public static int sortByScore(Student stu1, Student stu2) {

return stu1.getScore() - stu2.getScore();

}

public static int sortByName(Student stu1, Student stu2) {

return stu1.getName().compareTo(stu2.getName());

}

// 普通方法，创建对象才能调用

public int sortByScoreInstance(Student stu1, Student stu2) {

return stu1.getScore() - stu2.getScore();

}

// 普通方法，创建对象才能调用

public int sortByNameInstance(Student stu1, Student stu2) {

return stu1.getName().compareTo(stu2.getName());

}

}

3、Stream：

Stream分为中间操作和终止操作，中间操作会继续返回一个新的流，终止操作返回一个结果。

一行代码中如果只有中间操作，则不会执行，只有遇见终止操作才会执行。package java8;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedList;

import java.util.stream.Stream;

public class StreamDemo {

public static void main(String[] args) {

//Stream的使用

//创建流，参数为可变参数

Stream stream = Stream.of(50,66,88);

//将Stream转化为数组

//Object[] array = stream.toArray();

//System.out.println(Arrays.toString(array));

//筛选过滤条件,参数为Predicate，动作自己指定,找到大于60的数

//流分为中间操作和终止操作，节点流会继续返回一个流对象，终止操作会返回一个结果，

//只有中间流，代码不会执行，只有遇见终止操作才会执行

//stream.filter((target) -> target > 60).forEach(System.out::println);

//map对数据进行操作,接收一个Function实例 例：对流中的每个元素都乘以2

stream.map((t) -> 2 * t).forEach(System.out::println);

//流的无限模式,会对seed一直执行UnaryOperator的事件,一般和limit配合使用

//skip(n)跳过n个元素,limit(n) 返回n个元素的流

Stream.iterate(0, t -> t + 2).skip(2).limit(6).forEach(System.out::println);

//将流转换为集合对象,第一个参数，传递一个Supplier 最终结果类型由此提供

//第二个参数 BiConsumer() 传递两个参数，第一个要操作的集合，第二个当前的流元素

//第三个元素BiConsumer() 传递两个集合，最终合并成一个集合

//类似StringBuffer.append()方法

//stream.collect(() -> new ArrayList(),

//(target,item)-> target.add(item),

//(result,target)-> result.addAll(target)).forEach(System.out::println);

//可以使用方法引用简化

stream.collect(LinkedList::new,LinkedList::add,LinkedList::addAll);

}

}