Java8新特性

最新推荐文章于 2022-10-25 11:42:34 发布
最新推荐文章于 2022-10-25 11:42:34 发布
阅读量1k 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011533553/article/details/107753786
版权

一、Lambda表达式

1、为什么使用Lambda表达式

​ Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行

​ 传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升

2、Lambda表达式

①、从匿名类到 Lambda 的转换

​ ■ 原来的方式：

	//原来的匿名内部类
	@Test
	public void test01() {
		Comparator<Integer> com = new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				return Integer.compare(o1, o2);
			}
		};
		
		TreeSet<Integer> ts = new TreeSet<>(com);
	}

​ ■ Lambda 表达式

	//Lambda 表达式
	@Test
	public void test02() {
		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
		TreeSet<Integer> ts = new TreeSet<>(com);
	}

​ ■ 小练习：获取当前公司中员工年龄大于 35 的员工信息

​ 创建员工类：

package com.pengtxyl.lambda;

public class Employee {

	private String name;
	private int age;
	private double salary;
	private Status status;
	public Employee() {
		super();
	}
	public Employee(String name, int age, double salary) {
		super();
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	
	public Employee(String name, int age, double salary, Status status) {
		super();
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}
	
	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;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	
	public Status getStatus() {
		return status;
	}
	public void setStatus(Status status) {
		this.status = status;
	}
	@Override
	public String toString() {
		return "Employee [name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status + "]";
	}


	public enum Status{
		FREE, BUSY, VOCATION;
	}
	
}

​ □ 老版本：

package com.pengtxyl.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import org.junit.Test;

public class TestLambda {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77)
	);
	
	//需求: 获取当前公司中员工年龄大于 35 的员工信息
	public List<Employee> filterEmployees1(List<Employee> list) {
		List<Employee> emps = new ArrayList<>();
		
		for (Employee emp : list) {
			if(emp.getAge() >= 35) {
				emps.add(emp);
			}
		}
		
		return emps;
	}
	
	@Test
	public void test03() {
		List<Employee> list = filterEmployees1(employees);
		
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}

​ □ 优化方式1：

​ ● 创建一个接口

package com.pengtxyl.lambda;

public interface MyPredicate<T> {

	public boolean test(T t);
	
}

​ ● 创建一个实现上述接口的实现类，方法体中实现具体的过滤条件

package com.pengtxyl.lambda;

public class FilterEmployeeByAge implements MyPredicate<Employee> {

	@Override
	public boolean test(Employee t) {
		return t.getAge() >= 35;
	}

}

//如果过滤工资, 可以创建具体的过滤工资类
//public class FilterEmployeeBySalary implements MyPredicate<Employee> {
//
//	@Override
//	public boolean test(Employee t) {
//		return t.getSalary() >= 5000;
//	}
//
//}

​ ● 测试：

package com.pengtxyl.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import org.junit.Test;

public class TestLambda {
		
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77)
	);
	
	public List<Employee> filterEmployees2(List<Employee> list, MyPredicate<Employee> mp) {
		List<Employee> emps = new ArrayList<>();
		
		for(Employee employee: list) {
			if(mp.test(employee)) {
				emps.add(employee);
			}
		}
		
		return emps;
	}
	
	//优化方式1:
	@Test
	public void test04() {
		List<Employee> list = filterEmployees2(employees, new FilterEmployeeByAge());
		
		for(Employee employee : list) {
			System.out.println(employee);
		}
	}
    
//    @Test
//	public void test05() {
//		List<Employee> list = filterEmployees2(employees, new FilterEmployeeBySalary());
//		
//		for(Employee employee : list) {
//			System.out.println(employee);
//		}
//	}

}

​ 这种优化的好处是：只需创建一个实现接口的具体实现类，过滤什么就创建一个特定的过滤类，除了测试方

​ 法，其余代码不要需再修改，这种模式叫策略设计模式

​

​ □ 优化方式2：匿名内部类

​ 由于上面的优化方式1中，如果要查找的条件不一样，那么每次都要创建一个类去实现接口，这种方式比

​ 较麻烦，我们可以使用匿名内部类，接口还是要保留，只是具体实现类不要去创建了

package com.pengtxyl.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import org.junit.Test;

public class TestLambda {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77)
	);
    
    public List<Employee> filterEmployees2(List<Employee> list, MyPredicate<Employee> mp) {
		List<Employee> emps = new ArrayList<>();
		
		for(Employee employee: list) {
			if(mp.test(employee)) {
				emps.add(employee);
			}
		}
		
		return emps;
	}
	
	//优化方式2: 匿名内部类
	@Test
	public void test05() {
		List<Employee> list = filterEmployees2(employees, new MyPredicate<Employee>() {
			
			@Override
			public boolean test(Employee t) {
				return t.getSalary() <= 5000;
			}
		});
		
		for(Employee employee : list) {
			System.out.println(employee);
		}
	}

}

​ □ 优化方式3：使用 Lambda 表达式，这种方式连接口都不要创建了

package com.pengtxyl.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import org.junit.Test;

public class TestLambda {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77)
	);
	
	public List<Employee> filterEmployees2(List<Employee> list, MyPredicate<Employee> mp) {
		List<Employee> emps = new ArrayList<>();
		
		for(Employee employee: list) {
			if(mp.test(employee)) {
				emps.add(employee);
			}
		}
		
		return emps;
	}
	
	//优化方式3: Lambda 表达式
	@Test
	public void test06() {
		List<Employee> list = filterEmployees2(employees, (e) -> e.getSalary() <= 5000);
		list.forEach(System.out::println);
	}

}

​

​ □ 优化方式4：这种方式后面还会再讲

package com.pengtxyl.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import org.junit.Test;

public class TestLambda {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77)
	);
	
	public List<Employee> filterEmployees2(List<Employee> list, MyPredicate<Employee> mp) {
		List<Employee> emps = new ArrayList<>();
		
		for(Employee employee: list) {
			if(mp.test(employee)) {
				emps.add(employee);
			}
		}
		
		return emps;
	}
	
	//优化方式4: 
	@Test
	public void test07() {
		employees.stream()
				 .filter((e) -> e.getSalary() >= 5000)
				 .forEach(System.out::println);
	}

}

3、Lambda 表达式语法

​ Lambda 表达式在 Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “ ->” ，该操作符被称为

​ Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分：

​ 左侧： 指定了 Lambda 表达式需要的所有参数

​ 右侧： 指定了 Lambda 体，即 Lambda 表达式要执行的功能。

​ Lambda 表达式需要函数式接口的支持，函数式接口即接口中只有一个抽象方法的接口

①、语法格式一：无参数，无返回值，如：

​ () -> System.out.println(“Hello Lambda!”)

package com.pengtxyl.lambda;

import org.junit.Test;

public class TestLambda2 {

	//语法格式1: 无参数, 无返回值
	@Test
	public void test1() {
		/*
		 * JDK 1.7 之前, 如果这样的变量在 run 方法中引入, 必须加 final,
		 *  而 JDK1.8 则不需要加 final, 但是不管是 JDK1.7 还是 JDK1.8, num 在
		 *  run 方法中都不可以做修改, 其实在 JDK1.8 中 num 还是 final 修饰的,
		 * 只是不要我们自己主动去写而已
		 */
		int num = 0;
		//以前的写法
		Runnable r1 = new Runnable() {
			
			@Override
			public void run() {
				System.out.println("Hello World!" + num);
			}
		};
		r1.run();
		
		System.out.println("----------------------------------");
		
		//Lambda 表达式
		Runnable r2 = () -> System.out.println("Hello Lambda!" + num);
		r2.run();
	}
}

②、语法格式二：有一个参数，并且无返回值，如：

​ (x) -> System.out.println(x);

	//语法格式二：有一个参数，并且无返回值
	@Test
	public void test2() {
		Consumer<String> con = (x) -> System.out.println(x);
		con.accept("来个大宝剑");
	}

③、语法格式三：若只有一个参数，小括号可以省略不写，如：

​ x -> System.out.println(x);

④、语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

	@Test
	public void test3() {
		Comparator<Integer> com = (x, y) -> {
			System.out.println("函数式接口");
			return Integer.compare(x, y);
		};
	}

⑤、语法格式五：若 Lambda 体中只有一条语句，return 和 大括号都可以省略不写

	@Test
	public void test4() {
		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
	}

⑥、语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为 JVM 编译器通过上下文可以推断

​ 出数据类型，即 “数据推断”

​ (Integer x, Integer y) -> Integer.compare(x, y)

	//语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为 JVM 编译器通过
	//				上下文可以推断出数据类型，即 “数据推断”
	@Test
	public void test5() {
		String[] strs = {"aaa", "bbb", "ccc"};
		//这种写法是不行的, 因为无法根据上下文推断类型
		//strs = {"eee", "hhh", "ggg"};
		
		//如下面的这些都是根据类型推断出来的, 在右边的类中并没有写类型
		List<String> list = new ArrayList<>();
		show(new HashMap<>());
	}
	
	public void show(Map<String, String> map) {}

二、函数式接口

1、概念

​ Lambda 表达式需要 “函数式接口” 的支持

​ 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。可以使用注解 @FunctionalInterface 修饰，

​ 这个注解可以检查是否是函数式接口，如：

@FunctionalInterface
public interface MyPredicate<T> {

	public boolean test(T t);
	
}

​ 小练习：对一个数进行运算

​ ■ 定义一个接口

package com.pengtxyl.FunctionalInterface;

@FunctionalInterface
public interface MyFun {

	public Integer getValue(Integer num);
	
}

​ ■ 测试类：

package com.pengtxyl.FunctionalInterface;

import org.junit.Test;

public class TestFunctionInterface {

	@Test
	public void test() {
		Integer num = operation(100, x -> x * x);
		System.out.println(num);
		
		System.out.println(operation(200, x -> x + x));
	}
	
	public Integer operation(Integer num, MyFun mf) {
		return mf.getValue(num);
	}
}

2、四大内置函数式接口

①、Consumer：消费型接口

​ 方法：void accept(T t)；

	//Consumer<T>：消费型接口
	@Test
	public void test1() {
		happy(10000, m -> System.out.println("每次大宝剑消费" + m + "元"));
	}
	
	public void happy(double money, Consumer<Double> con) {
		con.accept(money);
	}

②、Supplier：供给型接口

​ 方法：T get()；

	//Supplier<T>：供给型接口
	@Test
	public void test2() {
		List<Integer> numList = getNumberList(5, () -> (int)(Math.random() * 100));
		
		for(Integer num : numList) {
			System.out.println(num);
		}
	}
	
	public List<Integer> getNumberList(int num, Supplier<Integer> sup) {
		List<Integer> list = new ArrayList<>();
		
		for(int i = 0 ; i < num ; i++) {
			Integer n = sup.get();
			list.add(n);
		}
		
		return list;
	}

③、Function<T, R>：函数型接口

​ 方法：R apply(T t)；

	//Function<T, R>：函数型接口
	@Test
	public void test3() {
		String newStr = strHandler("\t\t\t 我要大宝剑   ", (str) -> str.trim());
		System.out.println(newStr);
		
		String subStr = strHandler("老子天下第一", str -> str.substring(2, 4));
		System.out.println(subStr);
	}
	
	//用于处理字符串的函数
	public String strHandler(String str, Function<String, String> fun) {
		return fun.apply(str);
	}

④、Predicate：断言型接口

​ 方法：boolean test(T t)；

	//Predicate<T>：断言型接口
	@Test
	public void test4() {
		List<String> list = Arrays.asList("hello", "pengtxl", "lambda", "www", "ok");
		List<String> strs = filterStr(list, str -> str.length() > 3);
		System.out.println(strs);
	}
	
	//将满足条件的字符串放入集合中
	public List<String> filterStr(List<String> list, Predicate<String> pre){
		List<String> strList = new ArrayList<>();
		
		for(String str : list) {
			if(pre.test(str)) {
				strList.add(str);
			}
		}
		
		return strList;
	}

3、其他接口

函数式接口参数类型返回类型用途
Consumer 消费型接口Tvoid对类型为T的对象应用操作，包含方法: void accept(T t)
Supplier 供给型接口无T返回类型为T的对象，包含方法: T get()
Function<T,R> 函数型接口TR对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法: R apply(T t)
Predicate 断言型接口Tboolean确定类型为T的对象是否满足某约束，并返回boolean值。包含方法: boolean test(T t)
BiFunction<T,U,R>T, UR对类型为T,U参数应用操作，并返回R类型的结果。包含方法为: R apply(T t, U u)
UnaryOperator (Function的子接口)TT对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为: T apply(T t)
BinaryOperator (BiFunction的子接口)T, TT对类型为T的对象进行二院运算，并返回T类型的结果。包含方法为: T apply(T t1, T t2)
BiConsumer<T,U>T, Uvoid对类型为T, U参数应用操作。包含方法为: void accept(T t, U u)
ToIntFunction ToLongFunction ToDoubleFunctionTint long double分别计算int、long、double值的函数
IntFunction LongFunction DoubleFunctionint long doubleR参数分别为int、long、double类型的函数

三、方法引用与构造器引用

1、方法引用

​ 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！(实现抽象方法的参数列表，必须与

​ 方法引用方法的参数列表保持一致)

​ 方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。

​ 注意：

​ ①、Lambda体中调用方法的参数列表与返回值类型要与函数式接口中抽象方法的函数列表和返回值类型保持

​ 一致

​ ②、若 Lambda 参数列表中的第一个参数时实例方法的调用者，而第二个参数时实例方法的参数时，可以使

​ 用 ClassName::method

​ 有如下三种主要使用情况：

①、对象 : : 实例方法名

	//对象::实例方法名
	@Test
	public void test1() {
		Consumer<String> con = x -> System.out.println(x);
		
		PrintStream ps = System.out;
		Consumer<String> con1 = ps::println;
		
		Consumer<String> con2 = System.out::println;
		con2.accept("abcdef");
	}
	
	@Test
	public void test2() {
		Employee emp = new Employee();
		Supplier<String> sup = () -> emp.getName();
		String name = sup.get();
		System.out.println(name);
		
		Supplier<Integer> sup2 = emp::getAge;
		Integer age = sup2.get();
		System.out.println(age);
	}

②、类 : : 静态方法

	//类::静态方法名
	@Test
	public void test3() {
		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
		
		Comparator<Integer> com1 = Integer::compare;
	}

③、类 : : 实例方法

	//类::实例方法名
	//若 Lambda 参数列表中的第一个参数时实例方法的调用者，
	//并且第二个参数是需要引用方法的第二个参数(或无参数)时，可以使用 ClassName::method
	@Test
	public void test4() {
		BiPredicate<String, String> bp = (x, y) -> x.equals(y);
		
		BiPredicate<String, String> bp2 = String::equals;
	}

2、构造器引用

​ 格式：ClassName : : new

​ 注意：需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致

	//构造器引用
	@Test
	public void test5() {
		Supplier<Employee> sup = () -> new Employee();
		
		//构造器引用方式
		Supplier<Employee> sup2 = Employee::new;
	}

	@Test
	public void test6() {
        Function<Integer, Employee> fun = (x) -> new Employee(x);
        Function<Integer, Employee> fun2 = Employee:new;
        Employee emp = fun2.apply(101);
        System.out.println(emp);
        
        BiFunction<Integer, Integer, Employee> bf = Employee.new;
    }

3、数组引用

	//数组引用
	@Test
	public void test6() {
		Function<Integer, String[]> fun = x -> new String[x];
		String[] strs = fun.apply(10);
		System.out.println(strs.length);
		
		Function<Integer, String[]> fun2 = String[]::new;
		String[] strs2 = fun2.apply(20);
		System.out.println(strs2.length);
	}

四、Stream API

1、了解Stream

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

​ Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查

​ 找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也

​ 可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方

​ 式。

2、什么是 Stream

​ 流(Stream) 到底是什么呢？

​ 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算！ ”

​ 注意：

​ ① Stream 自己不会存储元素。

​ ② Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

​ ③ Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

3、Stream 的操作三个步骤

①、创建 Stream

​ 一个数据源（如： 集合、数组）， 获取一个流

②、中间操作

​ 一个中间操作链，对数据源的数据进行处理

③、终止操作(终端操作)

​ 一个终止操作，执行中间操作链，并产生结果

在这里插入图片描述

4、创建 Stream

​ Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

​ ● default Stream stream() : 返回一个顺序流

​ ● default Stream parallelStream() : 返回一个并行流

package com.pengtxyl.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;

public class TestStreamAPI1 {

	//创建 Stream
	@Test
	public void test1() {
		//1.可以通过 Collection 系列集合提供的 stream() 或 parallelStream()
		List<String> list = new ArrayList<>();
		Stream<String> stream1 = list.stream();
	}
	
}

①、由数组创建流

​ Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

​ static Stream stream(T[] array)：返回一个流

​ 重载形式，能够处理对应基本类型的数组：

​ ● public static IntStream stream(int[] array)

​ ● public static LongStream stream(long[] array)

​ ● public static DoubleStream stream(double[] array)

	//创建 Stream
	@Test
	public void test1() {
		//2.通过 Arrays 中的静态方法 stream() 获取数组流
		Employee[] emps = new Employee[10];
		Stream<Employee> stream2 = Arrays.stream(emps);
	}

②、由值创建流

​ 可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数

​ public static Stream of(T… values) ：返回一个流

	//创建 Stream
	@Test
	public void test1() {	
        //3.通过 Stream 类中的静态方法 of()
		Stream<String> stream3 = Stream.of("aa", "bb", "cc");
	}

③、由函数创建流：创建无限流

​ 可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

​ ● 迭代

​ public static Stream iterate(final T seed, final UnaryOperator f )

​ ● 生成

​ public static Stream generate(Supplier s)

	//创建 Stream
	@Test
	public void test1() {	
		//4.创建无限流
		//迭代
		Stream<Integer> stream4 = Stream.iterate(0, x -> x + 2);
		stream4.forEach(System.out::println);
		//生成
		Stream.generate(() -> Math.random()).limit(5).forEach(System.out::println);
	}

5、Stream 的中间操作

​ 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理

​ 而在终止操作时一次性全部处理，称为“惰性求值” 。

①、筛选与切片

方法描述
filter(Predicate p)接收 Lambda ， 从流中排除某些元素。
distinct()筛选，通过流所生成元素的 hashCode() 和 equals() 去 除重复元素
limit(long maxSize)截断流，使其元素不超过给定数量。
skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素 不足 n 个，则返回一个空流。与 limit(n) 互补
package com.pengtxyl.stream;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;

public class TestStreamAPI2 {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77)
	);

	//中间操作
	
	/*
		 filter(Predicate p)：接收 Lambda,从流中排除某些元素
		 distinct()：筛选,通过流所生成元素的hashCode()和equals()去除重复元素
		 limit(long maxSize)：截断流,使其元素不超过给定数量
		 skip(long n)：跳过元素,返回一个扔掉了前n个元素的流.若流中元素不足n个,则返回一个空流,与limit(n)互补
	 */
	//内部迭代：迭代操作由 Stream API 完成
	@Test
	public void test01() {
		Stream<Employee> stream = employees.stream()
				.filter(e -> {
					System.out.println("Stream API 的中间操作");
					return e.getAge() > 35;
				});
		
		//终止操作
		stream.forEach(System.out::println);
	}
	
	//外部迭代
	@Test
	public void test2() {
		Iterator<Employee> it = employees.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
	
	@Test
	public void test3() {
		employees.stream()
				 .filter(e -> {
					 System.out.println("短路!");
					 return e.getSalary() > 5000;
				 })
				 .limit(2)
				 .forEach(System.out::println);
	}
	
	@Test
	public void test4() {
		employees.stream()
				 .filter(e -> e.getSalary() > 5000)
				 .skip(2)
				 .distinct() //需要在 employee 中重写 hashcode和 equals 方法
				 .forEach(System.out::println);
	}
	
}

②、映射

方法描述
map(Function f)接收一个函数作为参数，该函数会被应用到每个元 素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 LongStream。
flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另 一个流，然后把所有流连接成一个流
package com.pengtxyl.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;

public class TestStreamAPI2 {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77),
			new Employee("田七", 8, 7777.77),
			new Employee("田七", 8, 7777.77)
	);
	
	//中间操作
	/*
		映射
			map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
			flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
	 */
	@Test
	public void test5() {
		List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
		
		list.stream()
			.map(str -> str.toUpperCase())
			.forEach(System.out::println);
		
		System.out.println("-----------------------------------");
		
		employees.stream()
				 .map(Employee::getName)
				 .forEach(System.out::println);
		
		System.out.println("-----------------------------------");
		
		Stream<Stream<Character>> stream = list.stream().map(TestStreamAPI2::filterCharacter);
		
		stream.forEach(sm -> {
			sm.forEach(System.out::println);
		});
		
		System.out.println("-----------------------------------");
		
		Stream<Character> sm = list.stream().flatMap(TestStreamAPI2::filterCharacter);
	}
	
	public static Stream<Character> filterCharacter(String str){
		List<Character> list = new ArrayList<Character>();
		
		for(Character ch : str.toCharArray()) {
			list.add(ch);
		}
		return list.stream();
	}
	
}

③、排序

方法描述
sorted()产生一个新流，其中按自然顺序排序
sorted(Comparator comp)产生一个新流，其中按比较器顺序排序
package com.pengtxyl.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;

public class TestStreamAPI2 {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99),
			new Employee("李四", 38, 5555.55),
			new Employee("王五", 50, 6666.66),
			new Employee("赵六", 16, 3333.33),
			new Employee("田七", 8, 7777.77),
			new Employee("田七b", 8, 7777.77),
			new Employee("田七c", 8, 7777.77)
	);
	
	//中间操作
	/*
	 * 排序
	 * 		sorted(): 自然排序
	 * 		sorted(Comparator com): 定制排序
	 */
	@Test
	public void test7() {
		List<String> list = Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");
		
		list.stream()
			.sorted()
			.forEach(System.out::println);
		
		System.out.println("------------------------");
		
		employees.stream()
				 .sorted((e1, e2) -> {
					 if(e1.getAge() == e2.getAge()) {
						 return e1.getName().compareTo(e2.getName());
					 } else {
						 return e1.getAge() > e2.getAge() ? -1 : 1;
					 }
				 }).forEach(System.out::println);
	}
	
}

6、Stream 的终止操作

​ 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如： List、 Integer，甚至是 void

①、查找与匹配

方法描述
allMatch(Predicate p)检查是否匹配所有元素
anyMatch(Predicate p)检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素
count()返回流中元素总数
max(Comparator c)返回流中最大值
min(Comparator c)返回流中最小值
forEach(Consumer c)内部迭代(使用 Collection 接口需要用户去做迭 代，称为外部迭代。相反， Stream API 使用内部 迭代——它帮你把迭代做了)
package com.pengtxyl.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;
import com.pengtxyl.lambda.Employee.Status;

//终止操作
public class TestStreamAPI3 {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99, Status.FREE),
			new Employee("李四", 38, 5555.55, Status.BUSY),
			new Employee("王五", 50, 6666.66, Status.VOCATION),
			new Employee("赵六", 16, 3333.33, Status.FREE),
			new Employee("田七", 8, 7777.77, Status.BUSY)
	);

	/*
		allMatch(Predicate p): 	检查是否匹配所有元素
		anyMatch(Predicate p): 	检查是否至少匹配一个元素
		noneMatch(Predicate p):	检查是否没有匹配所有元素
		findFirst():			返回第一个元素
		findAny():				返回当前流中的任意元素
		count():				返回流中元素总数
		max(Comparator c):		返回流中最大值
		min(Comparator c):		返回流中最小值
		forEach(Consumer c):	内部迭代(使用 Collection 接口需要用户去做迭代，
				称为外部迭代。相反， Stream API 使用内部迭代——它帮你把迭代做了)
	 */
	@Test
	public void test01() {
		boolean b1 = employees.stream()
				 			  .allMatch(e -> e.getStatus().equals(Status.BUSY));
		System.out.println(b1);	//false
		
		boolean b2 = employees.stream()
							  .anyMatch(e -> e.getStatus().equals(Status.BUSY));
		System.out.println(b2);	//true
		
		boolean b3 = employees.stream()
							  .noneMatch(e -> e.getStatus().equals(Status.BUSY));
		System.out.println(b3);	//false
		
		Optional<Employee> op = employees.stream()
										 .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
										 .findFirst();
		System.out.println(op.get());
		
		Optional<Employee> op2 = employees.stream()
				.filter(e -> e.getStatus().equals(Status.FREE))
				.findAny();
		System.out.println(op2);
		
		Long count = employees.stream().count();
		System.out.println(count);
		
		Optional<Employee> op3 = employees.stream()
				.max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
		System.out.println(op3.get());
		
		Optional<Double> op4 = employees.stream()
				.map(Employee::getSalary)
				.min(Double::compare);
		System.out.println(op4.get());
	}
	
}

②、归约

方法描述
reduce(T iden, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。 返回 T
reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。 返回 Optional

​ 备注： map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。

package com.pengtxyl.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;
import com.pengtxyl.lambda.Employee.Status;

//终止操作
public class TestStreamAPI3 {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99, Status.FREE),
			new Employee("李四", 38, 5555.55, Status.BUSY),
			new Employee("王五", 50, 6666.66, Status.VOCATION),
			new Employee("赵六", 16, 3333.33, Status.FREE),
			new Employee("田七", 8, 7777.77, Status.BUSY)
	);
	
	/*
	 * 归约
	 * 		reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 T
	 */
	@Test
	public void test3() {
		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
		/*
		 * 将x+y的计算结果代入x中, 实际的计算步骤是:
		 * 	将 redurce 函数的第一个参数代入x, list集合中的元素代入y,
		 * 	然后将计算结果又代入x, list中的后一个元素代入y,依次类推算出最终结果
		 */
		Integer num = list.stream().reduce(0, (x, y) -> x + y);
		System.out.println(num);
		
		System.out.println("------------------------");
		
		Optional<Double> op = employees.stream()
				.map(Employee::getSalary)
				.reduce(Double::sum);
		System.out.println(op.get());
	}
	
}

③、收集

方法描述
collect(Collector c)将流转换为其他形式。接收一个 Collector接口的 实现，用于给Stream中元素做汇总的方法

​ Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、 Set、 Map)。但是 Collectors 实用

​ 类提供了很多静态方法，可以方便地创建常见收集器实例， 具体方法与实例如下：

方法返回类型作用举例
toListList把流中元素收集到ListList emps= list.stream().collect(Collectors.toList())
toSetSet把流中元素收集到SetSet emps= list.stream().collect(Collectors.toSet())
toCollectionCollection把流中元素收集到创建的集合Collection emps= list.stream().collect(
Collectors.toCollection(
ArrayList::new))
countingLong计算流中元素的个数long count = list.stream()
.collect(Collectors.counting());
summingIntInteger对流中元素的整数属性求和int total= list.stream()
.collect(Collectors.summingInt(
Employee::getSalary));
averagingIntDouble计算流中元素Integer属性的平均 值doubleavg= list.stream()
.collect(Collectors
.averagingInt(
Employee::getSalary));
summarizingIntIntSummaryStatistics收集流中Integer属性的统计值。 如：平均值IntSummaryStatistics iss=
list.stream().collect(
Collectors.summarizingInt(
Employee::getSalary));
joiningString连接流中每个字符串String str=
list.stream().
map(Employee::getName)
.collect(Collectors.joining());
maxByOptional根据比较器选择最大值Optionalmax=
list.stream().collect(
Collectors.maxBy(
comparingInt(Employee::getSalary)))
minByOptional根据比较器选择最小值Optional min =
list.stream().collect(
Collectors.minBy(
comparingInt(Employee::getSalary)))
reducing归约产生的类型从一个作为累加器的初始值 开始， 利用BinaryOperator与 流中元素逐个结合， 从而归 约成单个值int total=list.stream().collect(
Collectors.reducing(0,
Employee::getSalar,
Integer::sum));
collectingAndThen转换函数返回的类型包裹另一个收集器， 对其结 果转换函数int how= list.stream()
.collect(Collectors
.collectingAndThen(
Collectors.toList(), List::size));
groupingByMap<K, List>根据某属性值对流分组， 属 性为K， 结果为VMap<Emp.Status,
List> map=
list.stream()
.collect(Collectors
.groupingBy(
Employee::getStatus));
partitioningByMap<Boolean, List>根据true或false进行分区Map<Boolean,
List> vd=
list.stream().collect(
Collectors.partitioningBy(
Employee::getManage));
package com.pengtxyl.stream;

import java.util.Arrays;
import java.util.DoubleSummaryStatistics;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;
import com.pengtxyl.lambda.Employee.Status;

//终止操作
public class TestStreamAPI3 {
	
	List<Employee> employees = Arrays.asList(
			new Employee("张三", 18, 9999.99, Status.FREE),
			new Employee("李四", 38, 5555.55, Status.BUSY),
			new Employee("王五", 50, 6666.66, Status.VOCATION),
			new Employee("赵六", 16, 3333.33, Status.FREE),
			new Employee("田七", 8, 7777.77, Status.BUSY)
	);
	
	/*
	 * 收集
	 * 		collect(Collector c) 将流转换为其他形式.
	 * 			接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
	 */
	@Test
	public void test4() {
		List<String> list = employees.stream()
				.map(Employee::getName)
				.collect(Collectors.toList());
		list.forEach(System.out::println);
		
		System.out.println("------------------------------");
		
		Set<String> set = employees.stream()
				.map(Employee::getName)
				.collect(Collectors.toSet());
		set.forEach(System.out::println);
		
		System.out.println("------------------------------");
		
		HashSet<String> hs = employees.stream()
				.map(Employee::getName)
				.collect(Collectors.toCollection(HashSet::new));
		hs.forEach(System.out::println);
		
		System.out.println("------------------------------");
		
	}
	
	@Test
	public void test5() {
		//总数
		Long count = employees.stream()
				.collect(Collectors.counting());
		System.out.println(count);
		
		System.out.println("------------------------------");
		
		//平均值
		Double avg = employees.stream()
				.collect(Collectors.averagingDouble(Employee::getSalary));
		System.out.println(avg);
		
		//总和
		Double sum = employees.stream()
				.collect(Collectors.summingDouble(Employee::getSalary));
		System.out.println(sum);
		
		//最大值
		Optional<Employee> max = employees.stream()
				.collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
		System.out.println(max.get());
		
		//最小值
		Optional<Double> min = employees.stream()
				.map(Employee::getSalary)
				.collect(Collectors.minBy(Double::compare));
		System.out.println(min.get());
	}
	
	@Test
	public void test6() {
		//分组
		Map<Status, List<Employee>> map = employees.stream()
				 .collect(Collectors.groupingBy(Employee::getStatus));
		System.out.println(map);
		
		//多级分组
		Map<Status, Map<String, List<Employee>>> maps = employees.stream()
				.collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(e -> {
					if(((Employee) e).getAge() <= 35){
						return "青年";
					} else if(((Employee) e).getAge() <= 50) {
						return "中年";
					} else {
						return "老年";
					}
				})));
		System.out.println(maps);
		
		//分区
		Map<Boolean, List<Employee>> mapG = employees.stream()
				.collect(Collectors.partitioningBy(e -> e.getSalary() > 8000));
		System.out.println(map);
	}
	
	@Test
	public void test7() {
		DoubleSummaryStatistics dss = employees.stream()
				.collect(Collectors.summarizingDouble(Employee::getSalary));
		
		System.out.println(dss.getSum());
		System.out.println(dss.getAverage());
		System.out.println(dss.getMax());
	}
	
	@Test
	public void test10() {
		String str = employees.stream()
				.map(Employee::getName)
				.collect(Collectors.joining());
			//	.collect(Collectors.joining(",", "===", "==="));	// ===张三,李四,王五,赵六,田七===
		System.out.println(str);	//张三李四王五赵六田七
	}
	
}

7、并行流与串行流

​ 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

​ Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel()

​ 与sequential() 在并行流与顺序流之间进行切换。

8、了解 Fork/Join 框架

​ Fork/Join 框架： 就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），

​ 再将一个个的小任务运算的结果进行 join 汇总

在这里插入图片描述

9、Fork/Join 框架与传统线程池的区别

​ 采用 “工作窃取”模式（ work-stealing）：

​ 当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线

​ 程的队列中偷一个并把它放在自己的队列中。

​ 相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果

​ 一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,

​ 如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他

​ 尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能.

package com.pengtxyl.ForkJoin;

import java.util.concurrent.RecursiveTask;

public class ForkJoinCalculate extends RecursiveTask<Long>{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private long start;
	private long end;
	
	private static final long THRESHOLD = 10000;
	
	public ForkJoinCalculate(long start, long end) {
		this.start = start;
		this.end = end;
	}

	@Override
	protected Long compute() {
		
		long length = end - start;
		if(length <= THRESHOLD) {
			long sum = 0;
			for(long i = start ; i <= end ; i++) {
				sum += i;
			}
			return sum;
		} else {
			long middle = (start + end) / 2;
			ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
			left.fork();	//拆分子任务, 同时压入线程队列
			
			ForkJoinCalculate right = new ForkJoinCalculate(middle + 1, end);
			right.fork();
			return left.join() + right.join();
		}
	}

}

测试类：

package com.pengtxyl.ForkJoin;

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

import org.junit.Test;

//数据越大, ForkJoin 框架和并行流处理速度越快
public class TestForkJoin {

	//ForkJoin框架
	@Test
	public void test1() {
		Instant start = Instant.now();
		
		ForkJoinPool pool = new ForkJoinPool();
		ForkJoinTask<Long> task = new ForkJoinCalculate(0, 100000000L);
		Long num = pool.invoke(task);
		System.out.println(num);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为: " + Duration.between(start, end));
	}
	
	//普通for
	@Test
	public void test2() {
		Instant start = Instant.now();
		
		long sum = 0L;
		
		for(long i = 0 ; i < 100000000L ; i++) {
			sum += i;
		}
		
		System.out.println(sum);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为: " + Duration.between(start, end));
	}
	
	//java8并行流
	@Test
	public void test3() {
		Instant start = Instant.now();
		
		LongStream.rangeClosed(0, 100000000000L)
				  .parallel()
				  .reduce(0, Long::sum);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为: " + Duration.between(start, end));
	}
	
}

五、Optional容器类

​ Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存

​ 在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

1、常用方法

​ Optional.of(T t)：创建一个 Optional 实例

​ Optional.empty()：创建一个空的 Optional 实例

​ Optional.ofNullable(T t)：若 t 不为 null,创建 Optional 实例,否则创建空实例

​ isPresent()：判断是否包含值

​ orElse(T t)：如果调用对象包含值，返回该值，否则返回t

​ orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回 s 获取的值

​ map(Function f)：如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()

​ flatMap(Function mapper)：与 map 类似，要求返回值必须是Optional

测试类：

package com.pengtxyl.optional;

import java.util.Optional;

import org.junit.Test;

import com.pengtxyl.lambda.Employee;
import com.pengtxyl.lambda.Employee.Status;

public class TestOptional {

	/*
		Optional.of(T t): 创建一个 Optional 实例
		Optional.empty(): 创建一个空的 Optional 实例
		Optional.ofNullable(T t): 若 t 不为 null,创建 Optional 实例,否则创建空实例
		isPresent(): 判断是否包含值
		orElse(T t): 如果调用对象包含值，返回该值，否则返回t
		orElseGet(Supplier s): 如果调用对象包含值，返回该值，否则返回 s 获取的值
		map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
		flatMap(Function mapper): 与 map 类似，要求返回值必须是Optional
	 */
	@Test
	public void test1() {
//		Optional<Employee> op = Optional.of(new Employee());
		//可以快速锁定空指针发生的位置
		Optional<Employee> op = Optional.of(null);
		Employee emp = op.get();
		System.out.println(emp);
	}
	
	@Test
	public void test2() {
		//构建空的Optional对象
		Optional<Employee> op = Optional.empty();
		System.out.println(op.get());
	}
	
	@Test
	public void test3() {
		Optional<Employee> op = Optional.ofNullable(null);
		System.out.println(op.get());
	}
	
	@Test
	public void test4() {
		Optional<Employee> op = Optional.ofNullable(null);
		if(op.isPresent()) {
			System.out.println(op.get());
		}
		
		Employee emp = op.orElse(new Employee("张三", 18, 5000, Status.FREE));
		System.out.println(emp);
		
		Employee emp1 = op.orElseGet(() -> new Employee());
		System.out.println(emp1);
	}
	
	@Test
	public void test5() {
		Optional<Employee> op = Optional.ofNullable(new Employee("张三", 18, 888.88, Status.FREE));
		
//		Optional<String> str = op.map(e -> e.getName());
//		System.out.println(str.get());
		
		Optional<String> str2 = op.flatMap(e -> Optional.of(e.getName()));
		System.out.println(str2.get());
		
	}
	
	//例题
	@Test
	public void test6() {
//		Man man = new Man();
//		String n = getGodnessName(man);
//		System.out.println(n);
		
		Optional<Godness> gn = Optional.ofNullable(new Godness("波多野结衣老师"));
		Optional<NewMan> op = Optional.ofNullable(null);
		String str = getGodnessName2(op);
		System.out.println(str);
	}
	//需求: 获取一个男人心中女神的名字
	public String getGodnessName(Man man) {
//		return man.getGodness().getName();
		if(man != null) {
			Godness gn = man.getGodness();
			if(gn != null) {
				return gn.getName();
			}
		}
		return "苍老师";
	}
	public String getGodnessName2(Optional<NewMan> man) {
		return man.orElse(new NewMan()) 
				  .getGodness()
				  .orElse(new Godness("苍老师"))
				  .getName();
	}
}


package com.pengtxyl.optional;

public class Man {

	private Godness godness;
	
	public Man() {
		super();
	}
	
	public Man(Godness godness) {
		super();
		this.godness = godness;
	}

	public Godness getGodness() {
		return godness;
	}

	public void setGodness(Godness godness) {
		this.godness = godness;
	}

	@Override
	public String toString() {
		return "Man [godness=" + godness + "]";
	}
	
}



package com.pengtxyl.optional;

public class Godness {

	private String name;
	
	public Godness() {
		super();
	}
	
	public Godness(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Godness [name=" + name + "]";
	}
	
}



package com.pengtxyl.optional;

import java.util.Optional;

public class NewMan {

	private Optional<Godness> godness = Optional.empty();

	public NewMan() {
		super();
	}

	public NewMan(Optional<Godness> godness) {
		super();
		this.godness = godness;
	}

	public Optional<Godness> getGodness() {
		return godness;
	}

	public void setGodness(Optional<Godness> godness) {
		this.godness = godness;
	}

	@Override
	public String toString() {
		return "NewMan [godness=" + godness + "]";
	}
	
}

六、接口中的默认方法与静态方法

1、接口中的默认方法

​ Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰

如：

package com.pengtxyl.interfaceMethod;

public interface MyFun {

	default String getName() {
		return "哈哈哈";
	}
	
}


package com.pengtxyl.interfaceMethod;

public class MyClass {

	public String getName() {
		return "嘿嘿嘿";
	}
	
}


package com.pengtxyl.interfaceMethod;

public class SubClass extends MyClass implements MyFun{

	public static void main(String[] args) {
		SubClass sc = new SubClass();
		System.out.println(sc.getName());	//打印嘿嘿嘿
	}
	
}

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

​ 若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时

​ ①、选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被

​ 忽略。
​ ②、接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的

​ 方法（不管方法是否是默认方法）， 那么必须覆盖该方法来解决冲突

package com.pengtxyl.interfaceMethod;

public interface MyFun {

	default String getName() {
		return "哈哈哈";
	}
	
}


package com.pengtxyl.interfaceMethod;

public interface MyInterface {

	default String getName() {
		return "呵呵呵";
	}
	
}


package com.pengtxyl.interfaceMethod;

public class SubClass /*extends MyClass*/ implements MyFun, MyInterface{

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return MyInterface.super.getName();
	}
	
}


package com.pengtxyl.interfaceMethod;

public class TestDefaultInterface {

	public static void main(String[] args) {
		SubClass sc = new SubClass();
		System.out.println(sc.getName());	//呵呵呵
	}
	
}

2、接口中的静态方法

​ Java8 中，接口中允许添加静态方法。 如：

package com.pengtxyl.interfaceMethod;

public interface MyInterface {

	default String getName() {
		return "呵呵呵";
	}
	
	public static void show() {
		System.out.println("接口中的静态方法");
	}
	
}


package com.pengtxyl.interfaceMethod;

public class TestDefaultInterface {

	public static void main(String[] args) {
		SubClass sc = new SubClass();
		System.out.println(sc.getName());	//呵呵呵
		
		MyInterface.show();	//打印 接口中的静态方法
	}
	
}

七、新时间日期API

1、使用 LocalDate、LocalTime、LocalDateTime

​ LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、

​ 时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

​ 注： ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法

​ 这三个类是给使用者自己看的

方法描述示例
now()静态方法， 根据当前时间创建对象LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
of()静态方法， 根据指定日期/时间创建 对象LocalDate localDate = LocalDate.of(2016, 10, 26);
LocalTime localTime = LocalTime.of(02, 22, 56);
LocalDateTime localDateTime = LocalDateTime.of(2016, 10, 26, 12, 10, 55);
plusDays,
plusWeeks, plusMonths,
plusYears		向当前 LocalDate 对象添加几天、 几周、 几个月、 几年
minusDays,
minusWeeks, minusMonths, minusYears		从当前 LocalDate 对象减去几天、 几周、 几个月、 几年
plus,
minus		添加或减少一个 Duration 或 Period
withDayOfMonth, withDayOfYear, withMonth,
withYear		将月份天数、 年份天数、 月份、 年 份 修 改 为 指 定 的 值 并 返 回 新 的 LocalDate 对象
getDayOfMonth获得月份天数(1-31)
getDayOfYear获得年份天数(1-366)
getDayOfWeek获得星期几(返回一个 DayOfWeek 枚举值)
getMonth获得月份, 返回一个 Month 枚举值
getMonthValue获得月份(1-12)
getYear获得年份
until获得两个日期之间的 Period 对象， 或者指定 ChronoUnits 的数字
isBefore, isAfter比较两个 LocalDate
isLeapYear判断是否是闰年

​ Java8提供的时间日期API是线程安全的。在 Java8 以前的日期时间 API 是线程不安全的，例如，同时启动10个

​ 线程对日期进行格式化，会报错，如下代码：

package com.pengtxyl.timedate;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestSimpleDateFormat {

	public static void main(String[] args) throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Callable<Date> task = new Callable<Date>() {

			@Override
			public Date call() throws Exception {
				return sdf.parse("20200413");
			}
		};
		
		ExecutorService pool = Executors.newFixedThreadPool(10);
		
		List<Future<Date>> results = new ArrayList<>();
		
		for(int i = 0 ; i < 10 ; i++) {
			results.add(pool.submit(task));
		}
		for(Future<Date> future : results) {
			System.out.println(future.get());
		}
        pool.shutdown();
	}
	
}

​ 会报如下错误：

Mon Apr 13 00:00:00 CST 2020
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.NumberFormatException: For input string: ""
	at java.util.concurrent.FutureTask.report(Unknown Source)
	at java.util.concurrent.FutureTask.get(Unknown Source)
	at com.pengtxyl.timedate.TestSimpleDateFormat.main(TestSimpleDateFormat.java:32)
Caused by: java.lang.NumberFormatException: For input string: ""
	at java.lang.NumberFormatException.forInputString(Unknown Source)
	at java.lang.Long.parseLong(Unknown Source)
	at java.lang.Long.parseLong(Unknown Source)
	at java.text.DigitList.getLong(Unknown Source)
	at java.text.DecimalFormat.parse(Unknown Source)
	at java.text.SimpleDateFormat.subParse(Unknown Source)
	at java.text.SimpleDateFormat.parse(Unknown Source)
	at java.text.DateFormat.parse(Unknown Source)
	at com.pengtxyl.timedate.TestSimpleDateFormat$1.call(TestSimpleDateFormat.java:20)
	at com.pengtxyl.timedate.TestSimpleDateFormat$1.call(TestSimpleDateFormat.java:1)
	at java.util.concurrent.FutureTask.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)

​ 由于 Java8 以前如果使用多线程操作时间日期 API 会报错，那么我们的解决办法如下：

​ 先创建一个本地线程变量：

package com.pengtxyl.timedate;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatThreadLocal {

	private static final ThreadLocal<DateFormat> df = 
			new ThreadLocal<DateFormat>() {
		protected DateFormat initialValue() {
			return new SimpleDateFormat("yyyyMMdd");
		}
	};
	
	public static Date convert(String source) throws ParseException {
		return df.get().parse(source);
	}
	
}

​ 然后将上面的 SimpleDateFormat 替换为创建好的 DateFormatThreadLocal：

package com.pengtxyl.timedate;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestSimpleDateFormat {

	public static void main(String[] args) throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Callable<Date> task = new Callable<Date>() {

			@Override
			public Date call() throws Exception {
//				return sdf.parse("20200413");
                //使用 DateFormatThreadLocal
				return DateFormatThreadLocal.convert("20200413");
			}
		};
		
		ExecutorService pool = Executors.newFixedThreadPool(10);
		
		List<Future<Date>> results = new ArrayList<>();
		
		for(int i = 0 ; i < 10 ; i++) {
			results.add(pool.submit(task));
		}
		for(Future<Date> future : results) {
			System.out.println(future.get());
		}
        pool.shutdown();
	}
	
}

​ 而现在的 Java8 可以直接使用下面这种方式：

package com.pengtxyl.timedate;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestSimpleDateFormat {

	public static void main(String[] args) throws Exception {
		
//		DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;
		//若需要转换为自定义的样式可以使用下面的格式
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
		
		Callable<LocalDate> task = new Callable<LocalDate>() {

			@Override
			public LocalDate call() throws Exception {
				return LocalDate.parse("20200413", dtf);
			}
		};
		
		ExecutorService pool = Executors.newFixedThreadPool(10);
		
		List<Future<LocalDate>> results = new ArrayList<>();
		
		for(int i = 0 ; i < 10 ; i++) {
			results.add(pool.submit(task));
		}
		for(Future<LocalDate> future : results) {
			System.out.println(future.get());
		}
	}		
}

LocalDate、LocalTime、LocalDateTime具体使用

​ 它们的用法都是一样，这里用 LocalDateTime 进行举例：

package com.pengtxyl.timedate;

import java.time.LocalDateTime;

import org.junit.Test;

public class TestLocalDateTime {

	//1.LocalDate、LocalTime、LocalDateTime
	@Test
	public void test01() {
		LocalDateTime ldt1 = LocalDateTime.now();
		System.out.println(ldt1); //2020-04-13T21:52:44.600
		
		LocalDateTime ldt2 = LocalDateTime.of(2020, 4, 13, 21, 53, 40);
		System.out.println(ldt2); //2020-04-13T21:53:40
		
		//将 年份 加2
		LocalDateTime ldt3 = ldt1.plusYears(2);
		System.out.println(ldt3); //2022-04-13T21:54:17.740
		
		//将 月份 减2
		LocalDateTime ldt4 = ldt1.minusMonths(2);
		System.out.println(ldt4); //2020-02-13T21:55:14.850
		
		System.out.println(ldt1.getYear()); //2020
		System.out.println(ldt1.getMonthValue()); //4
		System.out.println(ldt1.getDayOfMonth()); //13
		System.out.println(ldt1.getHour()); //21
		System.out.println(ldt1.getMinute()); //56
		System.out.println(ldt1.getSecond()); //55
	}
	
}

2、Instant 时间戳

​ 用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运

​ 算，这个类是给计算机看的

package com.pengtxyl.timedate;

import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

import org.junit.Test;

public class TestInstant {

	//Instant: 时间戳
	@Test
	public void test1() {
		Instant ins1 = Instant.now(); //默认获取 UTC 时区
		System.out.println(ins1); //2020-04-13T14:02:16.031Z
		
		//将时区偏移指定的数
		OffsetDateTime odt = ins1.atOffset(ZoneOffset.ofHours(8));
		System.out.println(odt); //2020-04-13T22:02:16.031+08:00
		
		//打印毫秒数
		System.out.println(ins1.toEpochMilli()); //1586786536031
		
		//从 Unix 元年(1970年1月1号)加上指定的秒
		Instant ins2 = Instant.ofEpochSecond(60);
		System.out.println(ins2); //1970-01-01T00:01:00Z
	}
	
}

3、Duration 和 Period

​ ● Duration:用于计算两个“时间”间隔

​ ● Period:用于计算两个“日期”间隔

	@Test
	public void test2() {
		Instant ins1 = Instant.now();
		
		try {
			Thread.sleep(1000);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		Instant ins2 = Instant.now();
		
		Duration duration = Duration.between(ins1, ins2);
		System.out.println(duration); //PT1.002S
		System.out.println(duration.toMillis()); //1001
		
		LocalTime lt1 = LocalTime.now();
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		LocalTime lt2 = LocalTime.now();
		
		System.out.println(Duration.between(lt1, lt2).toMillis()); //1001
	}

4、日期的操纵

​ ● TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。

​ ● TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。

	@Test
	public void test3() {
		LocalDateTime ldt1 = LocalDateTime.now();
		System.out.println(ldt1); //2020-04-13T22:11:05.440
		
		//指定当前月份的哪一天
		LocalDateTime ldt2 = ldt1.withDayOfMonth(30);
		System.out.println(ldt2); //2020-04-10T22:11:05.440
		
		//指定下一个星期天
		LocalDateTime ldt3 = ldt1.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
		System.out.println(ldt3); //2020-04-19T22:11:05.440
		
		//自定义: 下一个工作日
		LocalDateTime ldt5 = ldt1.with(l -> {
			LocalDateTime ldt4 = (LocalDateTime) l;
			DayOfWeek dow = ldt4.getDayOfWeek(); //获取当前是星期几
			if(dow.equals(DayOfWeek.FRIDAY)) {//如果是星期五,则下一个工作日要加3
				return ldt4.plusDays(3);
			} else if(dow.equals(DayOfWeek.SATURDAY)) {//如果是星期六,则下一个工作日要加2
				return ldt4.plusDays(2);
			} else {
				return ldt4.plusDays(1);//否则如果是其他的,下一个工作日只需加1
			}
		});
		System.out.println(ldt5); //2020-04-14T22:16:08.010
	}

5、解析与格式化

​ java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：

​ ● 预定义的标准格式

​ ● 语言环境相关的格式

​ ● 自定义的格式

	@Test
	public void test4() {
		DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE;
		LocalDateTime ldt = LocalDateTime.now();
		
		String strDate = ldt.format(dtf);
		System.out.println(strDate); //2020-04-13
		
		System.out.println("------------------------");
		
		DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
		String strDate2 = dtf2.format(ldt);
		System.out.println(strDate2); //2020年04月13日 22:21:32
		
		LocalDateTime newDate = ldt.parse(strDate2, dtf2);
		System.out.println(newDate); //2020-04-13T22:21:32
	}

6、时区的处理

​ Java8 中加入了对时区的支持，带时区的时间为分别为：

​ ZonedDate、 ZonedTime、 ZonedDateTime

​ 其中每个时区都对应着 ID，地区ID都为 “ {区域}/{城市}”的格式

​ 例如 ： Asia/Shanghai 等

​ ZoneId：该类中包含了所有的时区信息

​ getAvailableZoneIds() : 可以获取所有时区时区信息

​ of(id) : 用指定的时区信息获取 ZoneId 对象

与传统日期处理的转换：

类To 遗留类From 遗留类
java.time.Instant
java.util.Date		Date.from(instant)date.toInstant()
java.time.Instant
java.sql.Timestamp		Timestamp.from(instant)timestamp.toInstant()
java.time.ZonedDateTime java.util.GregorianCalendarGregorianCalendar.from(zonedDateTim e)cal.toZonedDateTime()
java.time.LocalDate
java.sql.Time		Date.valueOf(localDate)date.toLocalDate()
java.time.LocalTime
java.sql.Time		Date.valueOf(localDate)date.toLocalTime()
java.time.LocalDateTime java.sql.TimestampTimestamp.valueOf(localDateTime)timestamp.toLocalDateTime()
java.time.ZoneId java.util.TimeZoneTimezone.getTimeZone(id)timeZone.toZoneId()
java.time.format.DateTimeFormatter java.text.DateFormatformatter.toFormat()无
	@Test
	public void test5() {
		Set<String> set = ZoneId.getAvailableZoneIds();
		set.forEach(System.out::println);
		
		LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Europe/Tallinn"));
		System.out.println(ldt); //2020-04-13T17:27:32.207
		
		LocalDateTime ldt2 = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
		ZonedDateTime zdt = ldt2.atZone(ZoneId.of("Asia/Shanghai"));
		System.out.println(zdt); //2020-04-13T22:27:32.210+08:00[Asia/Shanghai]
	}

八、其他新特性

1、重复注解与类型注解

​ Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解

定义一个注解：

package com.pengtxyl.timedate;

import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Repeatable(MyAnnotations.class)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE, ElementType.TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

	String value() default "pengtxyl";
	
}

为了让注解能重复定义，需要使用下面的注解：

package com.pengtxyl.timedate;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {

	MyAnnotation[] value();
	
}

测试：

package com.pengtxyl.timedate;

import java.lang.reflect.Method;

import org.junit.Test;

public class TestAnnotation {

	@MyAnnotation("hello")
	@MyAnnotation("world")
	public void show(@MyAnnotation("abc") String str) {
		
	}
	
	@Test
	public void test1() throws Exception {
		Class<TestAnnotation> clazz = TestAnnotation.class;
		Method m1 = clazz.getMethod("show");
		
		MyAnnotation[] mas = m1.getAnnotationsByType(MyAnnotation.class);
		
		for(MyAnnotation myAnnotation : mas) {
			System.out.println(myAnnotation.value()); //打印 hello 和 world
		}
	}
	
}
u011533553
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Beagle Bone Black System Reference Manual（BBB系统参考手册）
10-26
Beagle Bone Black 开发板系统参考手册，完整版，手工整理。
java8新特性
11-08
本视频为java8新特性，百度云链接和密码，永久有效，失效联系我
POJ - 1679（次小生成树&&MST的唯一性）
samscream的博客
10-01 2846
 最小生成树的唯一性，思路是先判断每条边是否有重边，有的话flag=1，否则0.然后第一次求出最小生成树，将结果记录下来， 然后依次去掉第一次使用过的且含有重边的边，再求一次最小生成树，若结果与第一次结果一样，则不唯一。 #include&lt;iostream&gt; #include&lt;cstdlib&gt; #include&lt;cstdio&gt; #include&lt;alg...
es6数组循环
记录美好生活
03-05 3785
先说说es5的循环，一下几种循环的前五种接收的参数是一样的，都是两个参数： 第一个参数：循环里面执行的回调函数，循环调用执行的语句 第二个参数：this的指向 循环中回调函数的参数有三个： 第一个参数：循环出来的值 第二个参数：循环出来的索引值 第三个参数：数组本身 1.forEach() let arr = ['东','京','很','热']; arr.forEach(function(val,...
day11【List、Collections、set】
weixin_43525993的博客
06-22 1664
今日内容 List集合 Collections工具类 Set集合 教学目标 能够说出List集合特点 能够使用集合工具类 能够使用Comparator比较器进行排序 能够使用可变参数 能够说出Set集合的特点 能够说出哈希表的特点 使用HashSet集合存储自定义元素 第一章 List接口 我们掌握了Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？ 接下来，我们一起学习Collection中的常用几个子接口（java.uti
leetcode：984. 不含 AAA 或 BBB 的字符串（贪心）
weixin_42721412的博客
01-29 1860
题目： 分析： 又是放位置的问题。很有思路： 现放个数少的，放到2，5。。。放完放0，3.。。。剩下的放多的即可。 更简单一点，直接初始化为多的 代码： char c1='b'; char c2='a'; int n1=B; int n2=A; if(A>B) { c1='a'; c2='b'; n1=A; n2=B; } string ss(A+B,c1...
BBB板 --重装操作系统
weixin的博客
01-15 1809
文章目录前言一、下载镜像二、 制作引导盘1.工具2.制作过程二、 安装系统1、启动过程安装前：安装后：进入系统查看IP修改静态IP总结 前言 我都是在windows操作的，用到了SSH工具， 一、下载镜像 通常是在BBB官网下载的镜像https://beagleboard.org/latest-images 不同的板子适用的系统版本不同，请结合自己需要下载。 下载的镜像需要解压，解压后的文件是**.img**格式的 二、 制作引导盘 1.工具 需要用到软件工具：balenaEtcher, 这个工具有不同的
map,list集合怎么遍历
08-31 200
map集合遍历：package cn.dingyi;import java.util.HashMap;import java.util.Iterator;import java.util.Map;/** * author:dingyi * time:2019/8/31 0031 15:17 */public class Map集合遍历 { public static void ma...
C# 插入条码到Excel指定单元格
akn76920的博客
03-03 277
.NET中Barcode Library的应用二 介绍 在上一篇中我已经简单介绍了这个函数库（条形码应用之一------------函数库的简介）。在这一篇中我将使用这个库提供更多的操作，希望对大家有用。 让我们来看下下面的设定: 我们有许多要处理的条形码。它们的类型被存储在Excel文件的一列中（如上图BarcodeType），它们的数据包含在另一列（Bar...
signature=df7d8ae98d6f3f1b52b9209e655b0ff2,cheat-engine/frmmicrotransactionsunit.lfm at master · che...
weixin_30703633的博客
05-30 13万+
object frmMicroTransactions: TfrmMicroTransactionsLeft = 826Height = 240Top = 87Width = 320AutoSize = TrueBorderIcons = [biSystemMenu]BorderStyle = bsDialogCaption = 'Cheat-E-Coins'ClientHeight = 240C...
public下文件页面引用app下的js，css以及配置404 500跳转
hhg08的专栏
07-02 3万+
自己在做404跳转页面的时候把404放在public文件下，然后按照平常的方式 用上面之后就会出现在开发模式下能正常运行，但是在编译环境下就不能运行， 应该改成静态方式应用 至于配置可以参考给力链接，我也复制一份，主要防止其它文档删除，难找 首先在 config/environment/development.rb中，找到下面这句代码，将其设为false confi...
java.lang.NumberFormatException: For input string: ““解决方案
娜可璐璐的博客
01-26 10万+
引起异常的主要原因如下： 1.传参字段和映射字段不一致 2.传参类型和映射类型不一致 3.时间类型转换时间戳长度不一致 4.参数长度和数据库不一致 今天在编写代码的时候发现了这样一个问题，平时在将String的字符型数据转化成Iint类型数据的时候，习惯性用的是Integer类中的Integer.parseInt("");方法，但是实际使用的时候却总是报错。 java.lang.NumberFormatException: For input string: “” 报错信息大同小异，大部分都是在上面的语句的
java.lang.NumberFormatException: For input string: “.“
欢迎来到“無昂博奥”的博客
10-25 1800
java.lang.NumberFormatException: For input string: "."
java.lang.NumberFormatException: For input string: 错误及解决办法
热门推荐
weixin_43800761的博客
06-15 18万+
这种问题我遇到过两次不同的，一种是 String 转换为 int 型报错，另一种是 String 转换为 double 报错，其实是同一类型的错误，只是我运用的不同场景，忽略了本质。 第一种、错误提示信息如下： Exception in thread "main" java.lang.NumberFormatException: For input string: "1 " at java.lang.NumberFormatException.forInputString(NumberFormatExce
java.lang.NumberFormatException: For input string: “M“
ClearLoveQ的博客
11-03 873
mybatis在传入一个字符串时一直报错说我的数字异常，但我传的是字符串啊，怎么会这样 java.lang.NumberFormatException: For input string: "M" mapper中是这样写的 原因： mybatis映射文件，是使用的ognl表达式，ognl是java语言（强类型语言），会把‘X’解析成字符，而不是字符串。 如果要用用双引号的来包含但引号，怎需要使用‘string’.toString()来转成字符串类型，在进行比较，如下所示 解决： ...
java.lang.NumberFormatException: For input string: ““ 异常的分析与处理
a1024978453的博客
04-19 1954
在写项目的时候遇到了一个NumberFormatException异常，错误如下图所示。 在运行界面按F12发现，代码所传的ID并未出现，初步判断是数据传输错误。 部分源代码如下： <td width="30%" bgcolor="#EEE" align="center"> <br> <b>您浏览过的商品</b><br> <c:forEach
Java 中实现 给定一个字符串，找到只包含两个唯一字符的最长子字符串
qq_41806546的博客
04-18 543
例如，给定“ abcbbbbcccbdddadacb”，包含2个唯一字符的最长子字符串为“ bcbbbbcccb”。 1.包含2个唯一字符的最长子字符串 在此解决方案中，哈希图用于跟踪地图中的唯一元素。当第三个字符添加到地图时，左指针需要向右移动。 您可以使用“ abac”浏览此解决方案。 public int lengthOfLongestSubstringTwoDistinct(String ...
java 8 新特性
最新发布
07-27
Java 8引入了许多令人兴奋的新特性，以下是其中一些： 1. Lambda表达式：Lambda表达式允许以更简洁的方式编写匿名函数，并且可以更方便地使用函数式编程风格。 2. 函数式接口：Java 8引入了函数式接口的概念，这是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值