java8的新特性_java8新功能

java8的性特性

java8的新特性简化了以前代码不必要的长度，加快了其运算速度；

1. Lambda
   java8中引入了Lambda;其简化了代码列如：

//没有使用java8特性
public class Test {

	static List<User> users = Arrays.asList(new User(1, "张三", 2),
			new User(2, "李四", 4),
			new User(3, "王五", 18),
			new User(4, "赵六", 13));
	
	public static void main(String[] args) {
		//使用匿名内部类的方式根据人的年龄进行升序
		Comparator<User> comparator = new Comparator<User>() {

			@Override
			public int compare(User o1, User o2) {
				return o1.getAge()-o2.getAge();
			}
		};
		Collections.sort(users, comparator);
		for (User user : users) {
			System.out.println(user);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Test {
	//使用Lambda后的代码
	static List<User> users = Arrays.asList(new User(1, "张三", 2),
			new User(2, "李四", 4),
			new User(3, "王五", 18),
			new User(4, "赵六", 13));
	
	public static void main(String[] args) {
		//使用匿名内部类的方式根据人的年龄进行升序
		Collections.sort(users, (u1,u2)->u1.getAge()-u2.getAge());
		for (User user : users) {
			System.out.println(user);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用java8的特性Lambda后代码量减少了很多
Lambda允许把函数作为一个方法的参数，或者把代码看成数据。
为了使现有函数更好的支持Lambda表达式，Java 8引入了函数式接口的概念。函数式接口就是只有一个方法的普通接口。
java.lang.Runnable与java.util.concurrent.Callable是函数式接口最典型的例子
添加了一个注解@FunctionalInterface 用来标注该类为函数式接口
也可以简洁的代码的开发例如 使用@FunctionalInterface

@FunctionalInterface
public interface FilterInfo<T> {

	boolean pro(T t);
}
1
2
3
4
5

public class Test {

   static List<User> users = Arrays.asList(new User(1, "张三", 2),
   		new User(2, "李四", 4),
   		new User(3, "王五", 18),
   		new User(4, "赵六", 13),
   		new User(5, "马", 1));
   
   public static void main(String[] args) {
   	//编号大于2且年龄大于4的人
   	List<User> userInfo = people(users, (e)->((User) e).getId()>2);
   	userInfo = people(userInfo, (a)->((User) a).getAge()>4);
   	for (User user : userInfo) {
   		System.out.println(user);
   	}
   }
   
   public static List<User> people(List<User> users,FilterInfo filterInfo) {
   	List<User> user = new ArrayList<>();
   	for (User user2 : users) {
   		if (filterInfo.pro(user2)) {
   			user.add(user2);
   		}
   	}
   	return user;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

个人感觉没啥用和自己定义一个泛型类提出公用方法来使用没什么区别——————别喷、别喷、别喷
我们可以在接口中定义默认方法，使用default关键字，并提供默认的实现。所有实现这个接口的类都会接受默认方法的实现，除非子类提供的自己的实现。例如：

public interface DefaultFunctionInterface {
     default String defaultFunction() {
         return "default function";
     }
 }
1
2
3
4
5

我们还可以在接口中定义静态方法，使用static关键字，也可以提供实现。
接口的默认方法和静态方法的引入，其实可以认为引入了C＋＋中抽象类的理念，以后我们再也不用在每个实现类中都写重复的代码了。
其实Lambda表达式的写法理解起来是这样的(个人见解)
Collections.sort(users, (u1,u2)->u1.getAge()-u2.getAge());
users大家都可以理解 -> 的左侧是要入参的参数 右侧的是条件 列如在函数式接口中定义了一个boolean类型的抽象方法在引用时进行判断时右侧的就可以理解为if判断中的判断条件。也就是Lambda的重中之重 主体的表达式。

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

public class Test {

	static List<User> users = Arrays.asList(new User(1, "张三", 2),
			new User(2, "李四", 4),
			new User(3, "王五", 18),
			new User(4, "赵六", 13),
			new User(5, "马", 1));
	
	public static void main(String[] args) {
		Integer num = users.stream().map((e)->e.getAge()).reduce((int) 0.0,(x,y)->(x+y));
		System.out.println(num);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

public class Test {

	static List<User> users = Arrays.asList(new User(1, "张三", 2),
			new User(2, "李四", 4),
			new User(3, "王五", 18),
			new User(4, "赵六", 13),
			new User(5, "张三", 1));
	
	public static void main(String[] args) {
		users.stream().filter((e)->e.getName().equals("张三")).map((e)->e.getName()).collect(Collectors.toList()).forEach(System.out::println);;
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

日期时间 API
Java 8新的Date-Time API (JSR 310)受Joda-Time的影响，提供了新的java.time包，可以用来替代 java.util.Date和java.util.Calendar。一般会用到Clock、LocaleDate、LocalTime、LocaleDateTime、ZonedDateTime、Duration这些类，对于时间日期的改进还是非常不错的。

public class Test {

	public static void main(String[] args) {
		Test java8tester = new Test();
		Test.testLocalDateTime();
	}

	public static void testLocalDateTime(){
	    
	      // 获取当前的日期时间
		Calendar calendar =Calendar.getInstance();
		Date date = calendar.getTime();
		System.out.println(date);
		
	      LocalDateTime currentTime = LocalDateTime.now();
	      System.out.println("当前时间: " + currentTime);
	        
	      LocalDate date1 = currentTime.toLocalDate();
	      System.out.println("date1: " + date1);
	        
	      Month month = currentTime.getMonth();
	      int day = currentTime.getDayOfMonth();
	      int seconds = currentTime.getSecond();
	        
	      System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
	        
	      LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
	      System.out.println("date2: " + date2);
	        
	      // 12 december 2014
	      LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
	      System.out.println("date3: " + date3);
	        
	      // 22 小时 15 分钟
	      LocalTime date4 = LocalTime.of(22, 15);
	      System.out.println("date4: " + date4);
	        
	      // 解析字符串
	      LocalTime date5 = LocalTime.parse("20:15:30");
	      System.out.println("date5: " + date5);
	   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

使用java8的新特性其实可以俭省很多的代码和时间列：
将一个逗号分割的字符串转成集合

List<Long> num = Arrays.asList(ids.split(",")).stream().map((e)->Long.parseLong(e.trim())).collect(Collectors.toList());
		System.out.println(num);
		
1
2
3