这篇“java 1.8新特性有哪些”文章，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要参考一下，对于“java 1.8新特性有哪些”，小编整理了以下知识点，请大家跟着小编的步伐一步一步的慢慢理解，接下来就让我们进入主题吧。

临清网站制作公司哪家好，找成都创新互联公司！从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设公司等网站项目制作，到程序开发，运营维护。成都创新互联公司于2013年开始到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选成都创新互联公司。

Java可以用来干什么

Java主要应用于：1. web开发；2. Android开发；3. 客户端开发；4. 网页开发；5. 企业级应用开发；6. Java大数据开发；7.游戏开发等。

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

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表达式。

方法引用有四种类型

类名::静态方法名

对象名::实例方法名

类名::实例方法名

类名::new

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

以上是“java 1.8新特性有哪些”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！

新闻名称：java1.8新特性有哪些
分享链接：http://azwzsj.com/article/joeihh.html