原文：
http://www.cnblogs.com/langtianya/p/3757993.html （本文原文）
http://developer.51cto.com/art/201404/435591.htm （jdk8 特性）
JDK各个版本的新特性
JDK1.5新特性：
1.自动装箱与拆箱：
JDK 1.6新特性
JDK 1.7 新特性
|
1，switch中可以使用字串了  mport java.util.*; public class JDK7GenericTest { public static void main(String[] args) { // Pre-JDK 7 List<String> lst1 = new ArrayList<String>(); // JDK 7 supports limited type inference for generic instance creation List<String> lst2 = new ArrayList<>(); lst1.add("Mon"); lst1.add("Tue"); lst2.add("Wed"); lst2.add("Thu"); for (String item: lst1) { System.out.println(item); } for (String item: lst2) { System.out.println(item); } } }
以下是jdk7 api中的接口，（不过注释太长，删掉了close()方法的一部分注释） /** * A resource that must be closed when it is no longer needed. * * @author Josh Bloch * @since 1.7 */ public interface AutoCloseable { /** * Closes this resource, relinquishing any underlying resources. * This method is invoked automatically on objects managed by the * {@code try}-with-resources statement. * */ void close() throws Exception; } 只要实现该接口，在该类对象销毁时自动调用close方法，你可以在close方法关闭你想关闭的资源，例子如下 class TryClose implements AutoCloseable { @Override public void close() throw Exception { System.out.println(" Custom close method … close resources "); } }
|
|
1.对Java集合（Collections）的增强支持 在JDK1.7之前的版本中，Java集合容器中存取元素的形式如下： 以List、Set、Map集合容器为例：
//创建List接口对象
//创建Set接口对象
//创建Map接口对象
在JDK1.7中，摒弃了Java集合接口的实现类，如：ArrayList、HashSet和HashMap。而是直接采用[]、{}的形式存入对象，采用[]的形式按照索引、键值来获取集合中的对象，如下：
Set<String> set={"item"}; //向Set集合对象中添加元素
Map<String,Integer> map={"key":1}; //向Map集合中添加对象
2.在Switch中可用String 在之前的版本中是不支持在Switch语句块中用String类型的数据的，这个功能在C#语言中早已被支持，好在JDK1.7中加入了。
String s = "test";
3.数值可加下划线 例如：int one_million = 1_000_000;
4.支持二进制文字 例如：int binary = 0b1001_1001;
5.简化了可变参数方法的调用 当程序员试图使用一个不可具体化的可变参数并调用一个*varargs* （可变）方法时，编辑器会生成一个“非安全操作”的警告。
6、在try catch异常扑捉中，一个catch可以写多个异常类型，用"|"隔开， jdk7之前： try { ...... } catch(ClassNotFoundException ex) { ex.printStackTrace(); } catch(SQLException ex) { ex.printStackTrace(); } jdk7例子如下 try { ...... } catch(ClassNotFoundException|SQLException ex) { ex.printStackTrace(); }
7、jdk7之前，你必须用try{}finally{}在try内使用资源，在finally中关闭资源，不管try中的代码是否正常退出或者异常退出。jdk7之后，你可以不必要写finally语句来关闭资源，只要你在try()的括号内部定义要使用的资源。请看例子： jdk7之前 import java.io.*; // Copy from one file to another file character by character. // Pre-JDK 7 requires you to close the resources using a finally block. public class FileCopyPreJDK7 { public static void main(String[] args) { BufferedReader in = null; BufferedWriter out = null; try { in = new BufferedReader(new FileReader("in.txt")); out = new BufferedWriter(new FileWriter("out.txt")); int charRead; while ((charRead = in.read()) != -1) { System.out.printf("%c ", (char)charRead); out.write(charRead); } } catch (IOException ex) { ex.printStackTrace(); } finally { // always close the streams try { if (in != null) in.close(); if (out != null) out.close(); } catch (IOException ex) { ex.printStackTrace(); } } try { in.read(); // Trigger IOException: Stream closed } catch (IOException ex) { ex.printStackTrace(); } } } jdk7之后 import java.io.*; // Copy from one file to another file character by character. // JDK 7 has a try-with-resources statement, which ensures that // each resource opened in try() is closed at the end of the statement. public class FileCopyJDK7 { public static void main(String[] args) { try (BufferedReader in = new BufferedReader(new FileReader("in.txt")); BufferedWriter out = new BufferedWriter(new FileWriter("out.txt"))) { int charRead; while ((charRead = in.read()) != -1) { System.out.printf("%c ", (char)charRead); out.write(charRead); } } catch (IOException ex) { ex.printStackTrace(); } } }
|
jAVA8 十大新特性
“Java is still not dead—and people are starting to figure that out.”
本教程将用带注释的简单代码来描述新特性，你将看不到大片吓人的文字。
一、接口的默认方法
Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，示例如下：
interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
Formula接口在拥有calculate方法之外同时还定义了sqrt方法，实现了Formula接口的子类只需要实现一个calculate方法，默认方法sqrt将在子类上可以直接使用。
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0
文中的formula被实现为一个匿名类的实例，该代码非常容易理解，6行代码实现了计算 sqrt(a * 100)。在下一节中，我们将会看到实现单方法接口的更简单的做法。
译者注： 在Java中只有单继承，如果要让一个类赋予新的特性，通常是使用接口来实现，在C++中支持多继承，允许一个子类同时具有多个父类的接口与功能，在其他 语言中，让一个类同时具有其他的可复用代码的方法叫做mixin。新的Java 8 的这个特新在编译器实现的角度上来说更加接近Scala的trait。 在C#中也有名为扩展方法的概念，允许给已存在的类型扩展方法，和Java 8的这个在语义上有差别。
二、Lambda 表达式
首先看看在老版本的Java中是如何排列字符串的：
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。
在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});
看到了吧，代码变得更段且更具有可读性，但是实际上还可以写得更短：
Collections.sort(names, (String a, String b) -> b.compareTo(a));
对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：
Collections.sort(names, (a, b) -> b.compareTo(a));
Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。接下来我们看看lambda表达式还能作出什么更方便的东西来：
三、函数式接口
Lambda 表达式是如何在java的类型系统中表示的呢？每一个lambda表达式都对应一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的 接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。
我们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。
示例如下：
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123
需要注意如果@FunctionalInterface如果没有指定，上面的代码也是对的。
译者注 将lambda表达式映射到一个单方法的接口上，这种做法在Java 8之前就有别的语言实现，比如Rhino JavaScript解释器，如果一个函数参数接收一个单方法的接口而你传递的是一个function，Rhino 解释器会自动做一个单接口的实例到function的适配器，典型的应用场景有 org.w3c.dom.events.EventTarget 的addEventListener 第二个参数 EventListener。
四、方法与构造函数引用
前一节中的代码还可以通过静态方法引用来表示：
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123
Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用，上面的代码展示了如何引用一个静态方法，我们也可以引用一个对象的方法：
converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted); // "J"
接下来看看构造函数是如何使用::关键字来引用的，首先我们定义一个包含多个构造函数的简单类：
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
接下来我们指定一个用来创建Person对象的对象工厂接口：
interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}
这里我们使用构造函数引用来将他们关联起来，而不是实现一个完整的工厂：
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
我们只需要使用 Person::new 来获取Person类构造函数的引用，Java编译器会自动根据PersonFactory.create方法的签名来选择合适的构造函数。
五、Lambda 作用域
在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。
六、访问局部变量
我们可以直接在lambda表达式中访问外层的局部变量：
final int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确：
int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
不过这里的num必须不可被后面的代码修改（即隐性的具有final的语义），例如下面的就无法编译：
int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
num = 3;
在lambda表达式中试图修改num同样是不允许的。
七、访问对象字段与静态变量
和本地变量不同的是，lambda内部对于实例的字段以及静态变量是即可读又可写。该行为和匿名对象是一致的：
static int outerStaticNum;
int outerNum;
void testScopes() {
Converter<Integer, String> stringConverter1 = (from) -> {
outerNum = 23;
return String.valueOf(from);
};
Converter<Integer, String> stringConverter2 = (from) -> {
outerStaticNum = 72;
return String.valueOf(from);
};
}
}
八、访问接口的默认方法
还记得第一节中的formula例子么，接口Formula定义了一个默认方法sqrt可以直接被formula的实例包括匿名对象访问到，但是在lambda表达式中这个是不行的。
Lambda表达式中是无法访问到默认方法的，以下代码将无法编译：
Formula formula = (a) -> sqrt( a * 100);
Built-in Functional Interfaces
JDK 1.8 API包含了很多内建的函数式接口，在老Java中常用到的比如Comparator或者Runnable接口，这些接口都增加了@FunctionalInterface注解以便能用在lambda上。
Java 8 API同样还提供了很多全新的函数式接口来让工作更加方便，有一些接口是来自Google Guava库里的，即便你对这些很熟悉了，还是有必要看看这些是如何扩展到lambda上使用的。
Predicate接口
Predicate 接口只有一个参数，返回boolean类型。该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）：
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();
Function 接口
Function 接口有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法（compose, andThen）：
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
Supplier 接口
Supplier 接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person
Consumer 接口
Consumer 接口表示执行在单个参数上的操作。
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
Comparator 接口
Comparator 是老Java中的经典接口， Java 8在此之上添加了多种默认方法：
Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0
Optional 接口
Optional 不是函数是接口，这是个用来防止NullPointerException异常的辅助类型，这是下一届中将要用到的重要概念，现在先简单的看看这个接口能干什么：
Optional 被定义为一个简单的容器，其值可能是null或者不是null。在Java 8之前一般某个函数应该返回非空对象但是偶尔却可能返回了null，而在Java 8中，不推荐你返回null而是返回Optional。
Optional<String> optional = Optional.of("bam");
optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
Stream 接口
java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。 Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。Stream的操作可以串行执行或者并行执行。
首先看看Stream是怎么用，首先创建实例代码的用到的数据List：
List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");
Java 8扩展了集合类，可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream。下面几节将详细解释常用的Stream操作：
Filter 过滤
过滤通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于中间操作，所以我们可以在过滤后的结果来应用其他Stream操作 （比如forEach）。forEach需要一个函数来对过滤后的元素依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行 其他Stream操作。
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa2", "aaa1"
Sort 排序
排序是一个中间操作，返回的是排序好后的Stream。如果你不指定一个自定义的Comparator则会使用默认排序。
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa1", "aaa2"
需要注意的是，排序只创建了一个排列好后的Stream，而不会影响原有的数据源，排序之后原数据stringCollection是不会被修改的：
System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
Map 映射
中间操作map会将元素根据指定的Function接口来依次将元素转成另外的对象，下面的示例展示了将字符串转换为大写字符串。你也可以通过map来讲对象转换成其他类型，map返回的Stream类型是根据你map传递进去的函数的返回值决定的。
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);
// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
Match 匹配
Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是最终操作，并返回一个boolean类型的值。
boolean anyStartsWithA =
stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
boolean allStartsWithA =
stringCollection
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
boolean noneStartsWithZ =
stringCollection
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true
Count 计数
计数是一个最终操作，返回Stream中元素的个数，返回值类型是long。
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
Reduce 规约
这是一个最终操作，允许通过指定的函数来讲stream中的多个元素规约为一个元素，规越后的结果是通过Optional接口表示的：
Optional<String> reduced =
stringCollection
.stream()
.sorted()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"
并行Streams
前面提到过Stream有串行和并行两种，串行Stream上的操作是在一个线程中依次完成，而并行Stream则是在多个线程上同时执行。
下面的例子展示了是如何通过并行Stream来提升性能：
首先我们创建一个没有重复元素的大表：
int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}
然后我们计算一下排序这个Stream要耗时多久，
串行排序：
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));
// 串行耗时: 899 ms
并行排序：
long t0 = System.nanoTime();
long count = values.parallelStream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));
// 并行排序耗时: 472 ms
上面两个代码几乎是一样的，但是并行版的快了50%之多，唯一需要做的改动就是将stream()改为parallelStream()。
Map
前面提到过，Map类型不支持stream，不过Map提供了一些新的有用的方法来处理一些日常任务。
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.putIfAbsent(i, "val" + i);
}
map.forEach((id, val) -> System.out.println(val));
以上代码很容易理解， putIfAbsent 不需要我们做额外的存在性检查，而forEach则接收一个Consumer接口来对map里的每一个键值对进行操作。
下面的例子展示了map上的其他有用的函数：
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3); // val33
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9); // false
map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23); // true
map.computeIfAbsent(3, num -> "bam");
map.get(3); // val33
接下来展示如何在Map里删除一个键值全都匹配的项：
map.remove(3, "val3");
map.get(3); // val33
map.remove(3, "val33");
map.get(3); // null
另外一个有用的方法：
map.getOrDefault(42, "not found"); // not found
对Map的元素做合并也变得很容易了：
map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9); // val9
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat
Merge做的事情是如果键名不存在则插入，否则则对原键对应的值做合并操作并重新插入到map中。
九、Date API
Java 8 在包java.time下包含了一组全新的时间日期API。新的日期API和开源的Joda-Time库差不多，但又不完全一样，下面的例子展示了这组新API里最重要的一些部分：
Clock 时钟
Clock类提供了访问当前日期和时间的方法，Clock是时区敏感的，可以用来取代 System.currentTimeMillis() 来获取当前的微秒数。某一个特定的时间点也可以使用Instant类来表示，Instant类也可以用来创建老的java.util.Date对象。
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date
Timezones 时区
在新API中时区使用ZoneId来表示。时区可以很方便的使用静态方法of来获取到。 时区定义了到UTS时间的时间差，在Instant时间点对象到本地日期对象之间转换的时候是极其重要的。
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());
System.out.println(zone2.getRules());
// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]
LocalTime 本地时间
LocalTime 定义了一个没有时区信息的时间，例如 晚上10点，或者 17:30:15。下面的例子使用前面代码创建的时区创建了两个本地时间。之后比较时间并以小时和分钟为单位计算两个时间的时间差：
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); // -3
System.out.println(minutesBetween); // -239
LocalTime 提供了多种工厂方法来简化对象的创建，包括解析时间字符串。
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 表示了一个确切的日期，比如 2014-03-11。该对象值是不可变的，用起来和LocalTime基本一致。下面的例子展示了如何给Date对象加减天/月/年。另外要注意的是这些对象是不可变的，操作返回的总是一个新实例。
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一样简单：
DateTimeFormatter 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 同时表示了时间和日期，相当于前两节内容合并到一个对象上了。LocalDateTime和LocalTime还有LocalDate一样，都是不可变的。LocalDateTime提供了一些能访问具体字段的方法。
LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
DayOfWeek 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 instant = sylvester
.atZone(ZoneId.systemDefault())
.toInstant();
Date legacyDate = Date.from(instant);
System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014
格式化LocalDateTime和格式化时间和日期一样的，除了使用预定义好的格式外，我们也可以自己定义格式：
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
和java.text.NumberFormat不一样的是新版的DateTimeFormatter是不可变的，所以它是线程安全的。
关于时间日期格式的详细信息：http://download.java.net/jdk8/docs/api/java/time/format/DateTimeFormatter.html
十、Annotation 注解
在Java 8中支持多重注解了，先看个例子来理解一下是什么意思。
首先定义一个包装类Hints注解用来放置一组具体的Hint注解：
@interface Hints {
Hint[] value();
}
@Repeatable(Hints.class)
@interface Hint {
String value();
}
Java 8允许我们把同一个类型的注解使用多次，只需要给该注解标注一下@Repeatable即可。
例 1: 使用包装类当容器来存多个注解（老方法）
@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
例 2：使用多重注解（新方法）
@Hint("hint1")
@Hint("hint2")
class Person {}
第二个例子里java编译器会隐性的帮你定义好@Hints注解，了解这一点有助于你用反射来获取这些信息：
Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint); // null
Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length); // 2
Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length); // 2
即便我们没有在Person类上定义@Hints注解，我们还是可以通过 getAnnotation(Hints.class) 来获取 @Hints注解，更加方便的方法是使用 getAnnotationsByType 可以直接获取到所有的@Hint注解。
另外Java 8的注解还增加到两种新的target上了：
@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}
关于Java 8的新特性就写到这了，肯定还有更多的特性等待发掘。JDK 1.8里还有很多很有用的东西，比如Arrays.parallelSort, StampedLock和CompletableFuture等等。
相关推荐
SOH-SVM算法：斑点鬣狗优化技术对支持向量机的改进与解析,优化算法助力机器学习：SOH-SVM改进及源码解析与参考,SOH-SVM：斑点鬣狗优化算法改进支持向量机：SOH-SVM。 代码有注释，附源码和参考文献，便于新手理解，～ ,SOH-SVM; 斑点鬣狗优化算法; 代码注释; 源码; 参考文献,SOH-SVM算法优化：附详解代码与参考
美赛教程&建模&数据分析&案例分析
GESPC++3级大纲
电动汽车充电负荷预测：基于出行链分析与OD矩阵的蒙特卡洛模拟研究,电动汽车充电负荷预测：基于出行链分析与OD矩阵的蒙特卡洛模拟方法,电动汽车充电负荷预测，出行链，OD矩阵，蒙特卡洛模拟 ,电动汽车充电负荷预测; 出行链; OD矩阵; 蒙特卡洛模拟,基于出行链的电动汽车充电负荷预测研究：蒙特卡洛模拟与OD矩阵分析
柯尼卡美能达Konica Minolta bizhub 205i 驱动
内容概要：本文全面介绍使用示波器进行一系列电学实验和项目的内容。从基础实验，如示波器的操作入门和常见波形的测量，再到进阶部分，比如电路故障排除与复杂项目设计，旨在帮助学生掌握示波器的各项技能。文中不仅提供了详尽的操作流程指导，还包括针对每个阶段的学习目标设定、预期成果评估和所需注意事项。最终通过对示波器的深入理解和熟练运用，在实际应用场景（如构造简单设备或是进行音频处理）达到创新解决问题的目的。 适用人群：面向有志于深入理解电工仪器及其应用的学生或者技术人员，尤其是刚开始接触或正在强化自己这方面能力的学习者。 使用场景及目标：①作为培训材料支持初学者快速上手专业级电工测试设备—示波器;②用于教学环节辅助讲解电学概念以及实际操作技巧;③鼓励用户参与更高层次的DIY工程任务从而培养解决问题的能力.
标题中的“ntc热敏电阻 MF52AT 10K 3950精度1%STM32采集带数字滤波”表明我们要讨论的是一个使用STM32微控制器进行数据采集的系统，该系统中包含NTC热敏电阻MF52AT作为温度传感器。NTC热敏电阻是一种负温度系数的电阻器，其阻值随温度升高而降低。MF52AT型号的热敏电阻具有10K欧姆的标称电阻和3950的B值，表示在特定温度下（通常为25℃）的阻值和温度特性曲线。精度1%意味着该电阻的阻值有1%的允许误差，这对于温度测量应用来说是相当高的精度。 描述中提到的“MF52AT热敏电阻STM32数据采集2路”，暗示我们有两个这样的热敏电阻连接到STM32微控制器的模拟输入端口，用于采集温度数据。STM32是一款基于ARM Cortex-M内核的微控制器，广泛应用于各种嵌入式系统中，包括温度监测等应用。由于STM32内部集成了多个ADC（模拟数字转换器），因此它可以同时处理多路模拟输入信号。 "带滤波，项目中实际运用，温差范围在±0.5度"，这表明在实际应用中，数据采集系统采用了某种数字滤波技术来提高信号质量，可能是低通滤波、滑动平均滤波或更复杂的数字信号处理算法。
SSM框架整合是Java开发中常见的技术栈，包括Spring、SpringMVC和Mybatis三个核心组件。这个压缩包提供了一个已经验证过的整合示例，帮助开发者理解和实践这三大框架的协同工作。 Spring框架是Java企业级应用的基石，它提供了一种依赖注入（Dependency Injection，DI）的方式，使得对象之间的依赖关系得以解耦，便于管理和服务。Spring还提供了AOP（面向切面编程）功能，用于实现如日志记录、事务管理等跨切面关注点的处理。 SpringMVC是Spring框架的一部分，专门用于构建Web应用程序。它采用了模型-视图-控制器（Model-View-Controller，MVC）设计模式，将业务逻辑、数据展示和用户交互分离，提高了代码的可维护性和可扩展性。在SpringMVC中，请求被DispatcherServlet接收，然后分发到相应的处理器，处理器执行业务逻辑后返回结果，最后由视图解析并展示给用户。 Mybatis是一个优秀的持久层框架，它简化了JDBC的繁琐操作，支持SQL语句的动态编写，使得开发者可以直接使用SQL来操作数据库，同时还能保持数
分割资源UE5.3.z25
Matlab 2021及以上版本：电气工程与自动化仿真实践——电力电子变换器微网建模与仿真研究，涵盖Boost、Buck整流逆变器闭环控制及光伏蓄电池电路等多重电气仿真,基于Matlab 2021及以上的电气工程与自动化仿真研究：电力电子变换器微网建模与Boost、Buck整流逆变器闭环控制及光伏蓄电池电路等多电气仿真分析,电气工程及其自动化仿真 Matlab simulink 电力电子变器微网建模仿真 仅限matlab版本2021及以上 Boost，Buck，整流逆变器闭环控制 光伏蓄电池电路等多种电气仿真 ,电气工程; Matlab simulink; 电力电子变换器; 微网建模仿真; Boost; Buck; 整流逆变器; 闭环控制; 光伏蓄电池电路; 电气仿真,Matlab 2021版电气工程自动化仿真研究：微网建模与控制策略
移动机器人路径规划，python入门程序
《DeepSeek从入门到精通》是清华大学推出的一套深度学习学习资源，内容涵盖基础知识、实用技巧和前沿应用，适合不同水平的学习者。通过系统化的学习路径，帮助你在深度学习领域快速成长。无论你是初学者还是
考虑新能源消纳的火电机组深度调峰策略：建立成本模型与经济调度，实现风电全额消纳的优化方案,考虑新能源消纳的火电机组深度调峰策略与经济调度模型研究,考虑新能源消纳的火电机组深度调峰策略 摘要：本代码主要做的是考虑新能源消纳的火电机组深度调峰策略，以常规调峰、不投油深度调峰、投油深度调峰三个阶段，建立了火电机组深度调峰成本模型，并以风电全额消纳为前提，建立了经济调度模型。 约束条件主要考虑煤燃烧约束、系统旋转备用功率约束、启停、爬坡、储热约束等等。 复现结果非常良好，结果图展示如下： 1、代码非常精品，有注释方便理解； ,核心关键词：新能源消纳；火电机组深度调峰策略；常规调峰；不投油深度调峰；投油深度调峰；成本模型；经济调度模型；煤燃烧约束；系统旋转备用功率约束；启停约束；爬坡约束；储热约束。,新能源优化调度策略：火电机组深度调峰及经济调度研究
"数字设计原理与实践" 数字设计是计算机科学和电子工程两个领域的交叉点，涉及到数字电路的设计和实现。本书籍《数字设计-原理与实践》旨在为读者提供一个系统的数字设计指南，从基本原理到实际应用，涵盖了数字设计的方方面面。 1. 数字设计的定义和目标 数字设计是指使用数字电路和系统来实现特定的功能目标的设计过程。在这个过程中，设计师需要考虑到各种因素，如电路的可靠性、功耗、面积等，以确保设计的数字电路能够满足实际应用的需求。 2. 数字设计的基本原理 数字设计的基本原理包括数字电路的基本元件，如逻辑门、 Flip-Flop、计数器、加法器等，以及数字电路的设计方法，如Combinational Logic、Sequential Logic和 Finite State Machine等。 3. 数字设计的设计流程 数字设计的设计流程通常包括以下几个步骤： * 需求分析：确定设计的目标和约束条件。 *电路设计：根据需求设计数字电路。 * 仿真验证：使用软件工具对设计的数字电路进行仿真和验证。 * 实现和测试：将设计的数字电路实现并进行测试。 4. 数字设计在实际应用中的应用 数字设计在实际应用中
基于Simulink仿真的直流电机双闭环控制系统设计与分析：转速电流双闭环PWM控制策略及7天报告研究,基于Simulink仿真的直流电机双闭环控制系统分析与设计报告：转速电流双闭环PWM控制策略的7天实践,直流电机双闭环控制系统仿真 simulink仿真 7d 转速电流双闭环 PWM 含有报告哈 ,直流电机; 双闭环控制系统; Simulink仿真; 7d; 转速电流双闭环; PWM; 报告,7天完成双闭环控制系统仿真报告：直流电机转速电流PWM管理与Simulink仿真研究
三目标微电网能量调度优化：经济、环境友好与高效能分配的协同策略研究,微粒群算法在三目标微电网能量调度中的应用：经济、环境友好与优化调度的综合研究,微电网 能量调度 三目标微网调度， 经济调度 环境友好调度 优化调度 微电网能量调度问题的求解 问题描述： - 微电网：包含多个能量源，包括DG（分布式发电设备，如太阳能光伏板、微型燃气轮机等）、MT（燃油发电机）和FC（燃料电池）。 - 目标：通过合理分配各种能源的发电功率，满足负荷需求，同时使得微电网的发电成本最小化。 解决方法： 微粒群算法（Particle Swarm Optimization, PSO）： - 步骤： - 初始化微粒群：根据给定的微电网问题约束，随机生成一定数量的微粒（粒子），每个粒子代表一种发电方案，包含DG、MT和FC的发电功率分配情况。 - 适应度函数：对每个粒子，计算其对应的发电成本，作为其适应度值。 - 更新速度和位置：根据当前适应度值和历史最优适应度值，通过PSO算法的公式，更新每个粒子的速度和位置，以寻找更优的发电功率分配。 - 约束处理：根据问题约束条件，
《无感滑膜技术：Microchip1078代码移植至ST芯片的实践指南》——新手必备的反正切算法与电子资料整合方案,《无感滑膜技术：Microchip1078代码移植至ST芯片的实践指南》——新手必备的反正切算法与电子资料全解析,无感滑膜，反正切，microchip1078代码移植到st芯片上，新手学习必备。 可以提供提供相应文档和keil工程，电子资料， ,无感滑膜; 反正切; microchip1078代码移植; ST芯片; 新手学习; 文档; Keil工程; 电子资料,无感滑膜算法移植至ST芯片的Microchip1078代码迁移指南
风光柴储混合微电网系统中的储能电池与互补能量管理技术研究及MATLAB模拟实现,风光柴储混合微电网系统中的储能电池与互补能量管理技术：基于MATLAB的智能调控体系,风光柴储+混合微电网+储能电池系统+互补能量管理+MATLA ,核心关键词：风光柴储; 混合微电网; 储能电池系统; 互补能量管理; MATLA;,风光柴储混合微网能量管理系统及储能电池应用
永磁同步电机PMSM无感FOC驱动与位置估算源码分享：跨平台兼容、高速动态响应、无需初始角度辨识,永磁同步电机PMSM无感FOC驱动与位置估算源码分享：跨平台兼容、高速动态响应、无需初始角度辨识,永磁同步电机pmsm无感foc驱动代码 位置估算源码 无刷直流电机无感foc源码，无感foc算法源码 若需要，可提供硬件 速度位置估算部分代码所使用变量全部使用国际标准单位，使用不到60行代码实现完整的位置速度观测器。 提供完整的观测器文档，供需要的朋友参考 程序使用自研观测器，代码全部是源码，不含任何库文件 送simulink仿真 代码可读性极好，关键变量注明单位 模块间完全解耦 高级工程师磁链法位置估算代码 跨平台兼容，提供ti平台或at32平台工程 电流环pi参数自动计算 效果如图 实现0速闭环启动 2hz以内转速角度收敛 动态响应性能好 无需初始角度辨识 电阻电感允许一定误差 ,核心关键词： 1. 永磁同步电机 (PMSM) 无感 FOC 驱动代码 2. 位置估算源码 3. 无刷直流电机无感 FOC 源码 4. 无感 FOC 算法源码 5. 硬件支持（可选） 6. 速度位置估算部分
模型可以通过管理器下载，一个sdxlbase一个sdxl refiner。 refiner的作用是先刷小图，满意了再提高分辨率，兼顾速度和质量。 导入ComfyUI可立即使用。