JDK8 部分代码测试

JDK8 部分代码测试

• Lambda 表达式 -

 (p1, p2) -> p1.firstName

（）放参数，可不带类型

->  特定

{ } 方法块 或者一行代码；

( int x, int y) -> x + y    //两整形参数，返回它们的和

() -> 42                   //无参数，直接返回 42

x -> 100 ;                  //可推断出参数 x 的类型

(String s) -> { System.out.println(s); } //传入一个字符，只执行一个操作，无返回值

• “::” 域操作符
  

JDK8 又重新借用了 C++ 的那个 “::” 域操作符，全称为作用域解析操作符。

• 测试代码
  

package com.test.jdk;

import java.time.Clock;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class JDK8Test {

	public static void main(String[] args) {

		 Comparator<Person> comparator = (p1, p2) -> p1.firstName
		 .compareTo(p2.firstName);
		
		 Person p1 = new Person("John", "Doe");
		 Person p2 = new Person("Alice", "Wonderland");
		
		 System.out.println(comparator.compare(p1, p2)); // > 0
		
		 System.out.println(comparator.reversed().compare(p1, p2)); // < 0
		
		 // Function 接口有一个参数并且返回一个结果，
		 // 并附带了一些可以和其他函数组合的默认方法（compose, andThen）：
		 Function<String, Integer> toInteger = Integer::valueOf;
		 Function<String, String> backToString = toInteger
		 .andThen(String::valueOf);
		
		 backToString.apply("123"); // "123"
		
		 System.out.println(backToString);
		
		 // Supplier 接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数
		 Supplier<Object> personSupplier = Object::new;
		 personSupplier.get(); // new Object
		
		 System.out.println(personSupplier.get());
		
		 new Thread(() -> {
		 for (int i = 0; i < 9; i++) {
		 System.out.println(String.format(
		 "Message #%d from inside the thread!", i));
		 }
		 }).start();
		
		 new Thread(() -> {
		 System.out.println(String.format(
		 "Message #%d from inside the thread!", 1024));
		 }).start();
		
		 List inputList = new LinkedList<>();
		 List upper = new LinkedList<>();
		 //有问题u
//		 inputList.stream().filter(x -> (x != null &&
//		 x.matches("[A-Z0-9]*"))).into(upper);
//		
//		 int sumX = inputList.stream()
//		 .filter(x -> (x != null && x.matches("[A-Z0-9]*")))
//		 .map(String::length).reduce(0, Integer::sum);
//		 //从集合中取出每个元素然后打印
//		 List list = new ArrayList<>();
//		 list.add("123aa");
//		 list.add("124aa");
//		 list.add("125aa");
//		 list.forEach(x -> System.out.println(x));
//		 Arrays.asList("Alice", "Bob", "Charlie",
//		 "Dave").forEach(System.out::println);
//		 //names.filter 有问题 啊，，怎么回事啊~！~
//		 List<String> names = Arrays.asList("Alice", "Bob", "Charlie",
//		 "Dave");
//		 List<String> filteredNames = names.filter((e) -> e.length() >= 4)
//		 .into(new ArrayList<String>());
//		
//		 names.filter(e -> e.length() >= 4)
//		 .forEach(x -> System.out.println(x));
		 //并行Streams
		 int max = 1000000;
		 List<String> values = new ArrayList<>(max);
		 for (int i = 0; i < max; i++) {
		 UUID uuid = UUID.randomUUID();
		 values.add(uuid.toString());
		 }
		 //串行排序：
		 long t0 = System.nanoTime();
		
		 long count = values.stream().sorted().count();
		 System.out.println(count);
		
		 long t1 = System.nanoTime();
		
		 long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
		 System.out.println(String.format("sequential sort took: %d ms",
		 millis));
		
		 //并行排序：
		 t0 = System.nanoTime();
		 count = values.parallelStream().sorted().count();
		 System.out.println(count);
		 t1 = System.nanoTime();
		 millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
		 System.out.println(String.format("parallel sort took: %d ms",
		 millis));
		 //DATE API
		// Clock 时钟
		Clock clock = Clock.systemDefaultZone();
		 millis = clock.millis();

		Instant instant = clock.instant();
		Date legacyDate = Date.from(instant); // legacy java.util.Date
		System.out.println(legacyDate);
		
		// Timezones 时区
		System.out.println(ZoneId.getAvailableZoneIds());
		// prints all available timezone ids

		ZoneId zone1 = ZoneId.of("Europe/Berlin");
		ZoneId zone2 = ZoneId.of("Brazil/East");
		System.out.println(zone1.getRules());// ZoneRules[currentStandardOffset=+01:00]
		System.out.println(zone2.getRules());// ZoneRules[currentStandardOffset=-03:00]
		//LocalTime 本地时间
		LocalTime now1 = LocalTime.now(zone1);
		LocalTime now2 = LocalTime.now(zone2);

		System.out.println(now1.isBefore(now2));  // false

		long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
		long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);

		System.out.println(hoursBetween);       
		System.out.println(minutesBetween);     
		LocalTime late = LocalTime.of(23, 59, 59);
		System.out.println(late);       // 23:59:59

		DateTimeFormatter germanFormatter =
		    DateTimeFormatter
		        .ofLocalizedTime(FormatStyle.SHORT)
		        .withLocale(Locale.GERMAN);

		LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
		System.out.println(leetTime);   // 13:37
		//LocalDate 本地日期
		LocalDate today = LocalDate.now();
		LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
		LocalDate yesterday = tomorrow.minusDays(2);

		LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
		DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
		System.out.println(dayOfWeek); // FRIDAY
		//从字符串解析一个LocalDate类型和解析LocalTime一样简单：
		 germanFormatter =
			    DateTimeFormatter
			        .ofLocalizedDate(FormatStyle.MEDIUM)
			        .withLocale(Locale.GERMAN);

		LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
		System.out.println(xmas);   // 2014-12-24
		//LocalDateTime 本地日期时间
		LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);

		 dayOfWeek = sylvester.getDayOfWeek();
		System.out.println(dayOfWeek);      // WEDNESDAY

		Month month = sylvester.getMonth();
		System.out.println(month);          // DECEMBER

		long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
		System.out.println(minuteOfDay);    // 1439
		//只要附加上时区信息，就可以将其转换为一个时间点Instant对象，
		//Instant时间点对象可以很容易的转换为老式的java.util.Date。
		 instant = sylvester
		        .atZone(ZoneId.systemDefault())
		        .toInstant();
		 legacyDate = Date.from(instant);
		System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014
		
		DateTimeFormatter formatter =
			    DateTimeFormatter
			        .ofPattern("MMM dd, yyyy - HH:mm");

		LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
		String string = formatter.format(parsed);
		System.out.println(string);     // Nov 03, 2014 - 07:13
		
	}

}