// 计数：字符串列表words中所有长度大于12的单词

    long count = 0;

// 1. 常规方式
    for (String w : words) {
        if (w.length() > 12) 
            count++;
    }

// 2. 流
    count = words.stream().filter(w -> w.length() > 5).count();

// 3. 并行流
    count = words.parallelStream().filter(w -> w.length() > 5).count();

Stream<String> words = Stream.of(contents.split("\\PL+")); // split("\\PL+") 以非字母（\\PL+）为分隔

// of 方法句有可变长参数
Stream<String> words = Stream.of("gently", "down", "the", "stream");

Stream<String> silence = Stream.empty();
// Generic type <String> is inferred; same as Stream.<String>empty()

// 获得一个常量值的流
Stream<String> echos = Stream.generate(() -> "Echo");

// 获取一个随机数的流
Stream<Double> randoms = Stream.generate(Math::random);

/** iterate方法 
  * 会接受一个“种子”值，
  * 以及一个函数，
  * 并且会反复地将该函数应用到之前的结果上。
  * 下例会生成一个 0 1 2 3...这样的序列。
  */
Stream<BigInteger> integers 
    = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE)

/** 生成一个有限序列
  * 添加一个谓词描述迭代应该何时结束。
  */
var limit = new BigInteger("1000000");
Stream<BigInteger> integers 
    = Stream.iterate(BigInteger.ZERO, 
    n -> n.compareTo(limit) < 0, 
    n -> n.add(BigInteger.ONE)
    
/** Pattern类的splitAsStream方法
  * 按照某个正则表达式来分割一个CharSequence对象。
  */
Stream<String> words = Pattern.compile("\\PL+").splitAsStream(contents);

/** Scanner.tokens方法
  * 会产生一个扫描器的符号流。
  */
Stream<String> words = new Scanner(contents).tokens();

/** 静态Files.lines方法
  * 会返回一个包含了文件中所有行的Stream。
try (Stream<String> lines = Files.lines(path)) {
    Process lines
}

/** 若持有的Iterable对象不是集合，
  * 则可以通过下面的方法将其转换为一个流。
  */
StreamSupport.stream(iterable.spliterator(), false);

/** 若持有的是Iterator对象，
  * 得到一个由它结果构成的流。
  */
StreamSupport.stream(Spliterators.spliteratorUnknownSize(
    iterator, Spliterator.ORDERED), false);

// 将一个字符串流转换为只包含长单词（长度大于12）的新流
List<String> words = ...;
Stream<String> longWords = words.stream().filter(w -> w.length() > 12);

// 函数 将所有单词转换成小写
Stream<String> lowercaseWords = words.stream().map(String::toLowerCase);
// lambda表达式 新流中包含所有单词的首字母
Stream<String> lowercaseWords = words.stream().map(s -> s.substring(0,1));

public static Stream<String> codePoints(String s) {
    var result = new ArrayList<String>();
    int i= 0;
    while (i < s.length()) {
        int j = s.offsetByCodePoints(i, 1);
        result.add(s.substring(i, j));
        i = j;
    }
    return result.stream();
}

/** codePoints("boat")的返回值是流["b", "o", "a", "t"]
  * 将codePoints方法映射到一个字符串流上
  */
Stream<Stream<String>> result = words.stream().map(w -> codePoints(w));
/** 上述代码会得到一个包含流的流
  * [...["y", "o", "u", "r"],["b", "o", "a", "t"],...]
  * 为了将其摊平为单个流
  * [..."y", "o", "u", "r", "b", "o", "a", "t",...]
  * 使用flatMap方法而不是map方法
  */
Stream<String> flatResult = words.stream().flatMap(w -> codePoints(w));

// 产生一个包含100个随机数的流
Stream<Double> randoms = Stream.generate(Math::random).limit(100);

// 跳过第一个元素
Stream<String> words = Stream.of(contents.split("\\PL+")).skip(1);

/** 上文codePoints方法将字符串分割为字符，然后收集所有的数字元素。
  * takeWhile方法可以实现此目标。
  */
Stream<String> initialDigits = codePoints(str).takeWhile(s -> "0123456789".contains(s));

Stream<String> withoutInitialWhiteSpace 
    = codePoints(str).dropWhile(s -> s.trim().length() == 0);

- Stream类的静态concat方法可以将两个流连接起来
Stream<String> combined = Stream.concat(codePoints("Hello"), codePoints("World");
// Yields the stream ["H", "e", "l", "l", "o", "W", "o", "r", "l", "d"]

Stream<String> uniqueWords = Stream.of("merrily", "merrily", "merrily", "gently").distinct();
// only one "merrily" is retained

// 使最长的字符串排在最前面
Stream<String> longestFirst = words.stream().sorted(Comparator.comparing(String::length).reversed());

Object[] powers 
    = Stream.iterate(1.0, p -> p * 2).peek(e -> System.out.println("Fetching " + e)).limit(20).toArray();

/** 1. count方法
  * 返回流中的元素的数量。
  */
Stream<String> example = Stream.of("merrily", "merrily", "merrily", "gently");
System.out.println(example.count()); // print 4

/** 2. max和min方法
  * 返回流中的元素的最大值和最小值。
  */
Optional<String> largest = words.max(String::compareToIgnoreCase);
System.out.println("largest: " + largest.orElse(""));

/** 3. findFirst方法
  * 返回非空集合中的第一个值。
  * 与filter组合使用时很有用。
  * 找到第一个以字母Q开头的单词。
  */
Optional<String> startsWithQ = words.filter(s -> startsWith("Q")).findFirst();

/** 4. findAny方法
  */
Optional<String> startsWithQ = words.filter(s -> startsWith("Q")).findAny();

/** 5. anyMatch方法
  * 检测是否存在匹配。
  * 接受一个断言引元，
  * 因此不需要使用filter。
  */
boolean aWordStartsWithQ = words.parallel().anyMatch(s -> startsWith("Q"));

/** 6. allMatch和noneMatch方法
  * 分别在所有元素
  * 和没有任何元素匹配谓词
  * 的情况下返回true。
  */

// 在没有任何匹配时，使用某种默认值，可能是空字符串。
String result = optionalString.orElse("");
    // The wrapped string, or "" if none

// 调用代码计算默认值
String result = optionalString.orElseGet(() -> System.getProperty("myapp.default"));
    // The function is only called when needed

// 或者在没有任何值时抛出异常
String result = optionalString.orElseThrow(IllegalStateException::new);
    // Supply a method that yield an exception object

/** 如果可选值存在，
  * 那么它会被传递给该函数。
  * 否则，不会发生任何事情。
  */
optionalValue.ifPresent(v -> Process v);

/** 例如，如果在该值存在的情况下，
  * 要将其添加到某个集中，
  * 那么可以调用：
  */
optionalValue.ifPresent(v -> results.add(v)); // or  optionalValue.ifPresent(results::add);

/** ifPresentOrElse方法
  * 可选值存在时执行一种动作，
  * 可选值不存在时执行另一种动作。
  */
optionalValue.ifPresentOrElse(v -> System.out.println("Found " + v), () -> logger.warning("No match"));

// 使用map方法来转换Optional内部的值。
Optional<String> transformed = optionalString.map(String::toUpperCase);
// 如果optionalString为空，则transformed也为空

// 将一个结果添加到列表中
optionalValue.map(results::add);
// 如果optionalValue为空，则什么也不会发生

public static Optional<Double> inverse(Double x) {
    return x == 0 ? Optional.empty() : Optional.of(1/x);
}

/** f方法可以产生Optional<T>对象，
  * 目标类型T具有一个可以产生Optional<U>对象的方法g。
  * 则可通过s.f().g()将它们组合起来。
  * 但是这种组合无法工作，
  * 因为s.f()的类型为Optional<T>，而不是T。
  * 故需要使用flatMap方法。
  */
Optional<T> result = s.f().flatMap(T::g);
// 若s.f()的值存在，那么g就可以应用到它上面。否则，就会返回一个空Optional<U>。

/** 有一个用户ID流和
  * 方法Optional<User> lookup(String id)
  */
  
Stream<String> ids = ...;
Stream<User> users = ids.map(Users::lookup).filter(Optional::isPresent).map(Optional::get);

/** 过滤掉无效ID，
  * 然后将get方法应用于剩余的ID。
  * 但是要慎用isPresent和get方法，
  * 故修改代码。
  */

Stream<User> users = ids.map(Users::lookup).flatMap(Optional::stream);

stream.forEach(System.out::println);

String[] result = stream.toArray(String[]::new);
    // stream.toArray() has type Object[]

// 将流的元素收集到一个列表中
List<String> result = stream.collect(Collectors.toList());

// 将流的元素收集到一个集中
Set<String> result = stream.collect(Collectors.toSet());

// 控制获得的集的种类
TreeSet<String> result = stream.collect(Collectors.toCollection(TreeSet::new));

// 通过连接操作来收集流中所有字符串
String result = stream.collect(Collectors.joining());

// 元素之间增加分隔符
String result = stream.collect(Collectors.joining(", "));

// 将流中非字符串对象转换为字符串
String result = stream.map(Object::toString).collect(Collectors.joining(", "));

/** 将一个流Stream<Person>的元素收集到映射表中，
  * 以便后续通过ID来查找人员。
  */
Map<Integer, String> idToName = people.collect(Collectors.toMap(Person::getId, Person::getName));

// 通常情况下，值应该是实际的元素，因此第二个函数可以使用Function.identity()。
Map<Integer, String> idToPerson = people.collect(Collectors.toMap(Person::getId, Function.identity()));

Map<String, List<Locale>> countryToLocales = locales.collect(Collectors.groupingBy(Locale::getCountry));

/** 函数Locale::getCountry是群组的分类函数，
  * 可以查找给定国家代码对应的所有地点。
  */
List<Locale> swissLocales = countryToLocales.get("CH");
    // Yields locales de_CH, fr_CH, it_CH and maybe more

// 将所有locale分成了使用英语和使用其他英语的两类
Map<Boolean, List<Locale>> englishAndOtherLocales 
    = locales.collect(Collectors.partitioningBy(l -> l.getLanguage.equals("en")));
List<Locale> englishLocales = englishAndOtherLocales.get(true);

Map<String, Set<Locale>> countryToLocaleSet = locales.collect(groupingBy(Locale::getCountry, toSet()));

/** 1. counting
  *会产生收集到的元素的个数。
  */
Map<String, Long> countryToLocaleCounts = locales.collect(groupingBy(Locale::getCountry, counting()));

/** 2. summing(Int|Long|Double)
  * 会接受一个函数作为引元，
  * 将该函数应用到下游元素中，
  * 并产生它们的和。
  */
Map<String, Integer> stateToCityPopulation 
    = cities.collect(groupingBy(City::getState, summingInt(City::getPopulation)));
    
/** 3. maxBy和minBy
  * 会接受一个比较器，
  * 并分别产生下游元素中的最大值和最小值。
  */
Map<String, Optional<City>> stateToLargestCity 
    = cities.collect(groupingBy(City::getState, maxBy(Comparator.comparing(City::getPopulation))));
    // 可以产生每个州中最大的城市。

List<Integer> values = ...;
Optional<Integer> sum = values.stream().reduce((x, y) -> x + y);
    /** reduce方法会计算v0+v1+v2+...，其中vi是流中的元素。
      * 若流为空，则该方法会返回一个Optional。
      */

IntStream stream = IntStream.of(1, 1, 2, 3, 5);
stream = Arrays.stream(values, from, to); // values is an int[] array

Stream<String> parallelWords = words.parallerStream();

Stream<String> parallelWords = Stream.of(wordArray).parallel();

abstract int read()
/** 该方法将读入一个字节，
  * 并返回读入的字节，
  * 或者在遇到输入源结尾时返回-1。

// 从Java 9开始，读取流中所有字节的方法
byte[] bytes = in.readAllBytes();

// 向某个输出位置写出一个字节
abstract void write(int b)

// 一次性写出一个字节数组
byte[] values = ...;
out.write(values);

// transferTo方法可以将所有字节从一个输入流传递到输出流
in.transferTo(out);

var fin = new FileInputStream("employee.dat");
// 这行代码可以查看用户目录下名为“employee.dat”的文件。

var fin = new FileInputStream("employee.dat");
var din = new DataInputStream(fin);
double x = din.readDouble();

var out = new PrintWriter("employee.txt", StandardCharsets.UTF_8);
String name = "Lam";
double salary = 75000;
out.print(name);
out.print(' ');
out.println(salary);
// employee.txt文件中有 Lam 75000.0

// 最简单 Scanner类
Scanner in = new Scanner(Path.of("inputfile.txt"),StandardCharsets.UTF_8);
String s1=in.nextLine();

// 将短小的文本文件读入到一个字符串中
var content = (Files.read String path, charset);

// 一行一行地读入
List<String> lines = Files.readAllLines(path, charset);

// 较大文件，将行惰性处理为一个Stream<String>对象
try (Stream<String> lines = Files.lines(path, charset)) {
    ...
}

// 使用扫描器来读入符号（token），即由分隔符分隔的字符串，默认的分隔符是空白字符
Scanner in = ...;
in.useDelimiter("\\PL+"); // 将分隔符修改为任意的正则表达式

// 调用next方法可以产生下一个符号
while (in.hasNext()) {
    String word = in.next();
    ...
}

// 获取一个包含所有符号的流
Stream<String> words = in.tokens();

InputStream inputStream = ...;
try (var in = new BufferedReader(new InputStreamReader(inputStream, charset))) {
    String line;
    while ((line = in.readLine()) != null) {
        do something with line
    }
}

public static void writeEmployee(PrintWriter out, Employee e) {
    out.println(e.getName() + "|" + e.getSalary + "|" + e.getHireDay());
}
//在调用该方法之后 切记使用out.close()关闭文件

// 调用该方法打印到文本文件中
    Harry Hacker|35500|1989-10-01
    Carl Cracker|75000|1987-12-15
    Tony Tester|38000|1990-03-15

/** 每次读入一行，
  * 然后分离所有字段。
  * 用扫描器来读入每一行，
  * 然后用String.split方法将这一行断开成一组标记。
  */
public static Employee readEmployee(Scanner in) {
    String line = in.nextLine();
    String[] tokens = line.split("\\|");
    String name = tokens[0];
    double salary = Double.parseDouble(tokens[1]);
    LocalDate hireDate = LocalDate.parse(tokens[2]);
    int year = hireDate.getYear();
    int month = hireDate.getMonthValue();
    int day = hireDate.getDayOfMonth();
    return new Employee(name, salary, year, month, day);
}
/** split方法的参数是一个描述分隔符的正则表达式，
  * 碰巧的是，
  * 竖线（|）在正则表达式中具有特殊的含义，
  * 因此需要用\字符来表示转义，
  * 而这个\又需要另一个\来转义，
  * 因此产生了“\\|”表达式。
  */

Charset shiftJIS = Charset.forName("Shift-JIS");

var str = new String(bytes, StandardCharsets.UTF_8);
// 将一个字节数组转换为字符串

  writeInt    writeDouble
  writeShort  writeChar
  writeLong   writeBoolean
  writeFloat  writeUTF
  writeChars  writeByte  
  // 例如，writeInt总是将一个整数写出为4字节的二进制数量值，而不管它有多少位。

  readInt    readDouble
  readShort  readChar
  readLong   readBoolean
  readFloat  readUTF

/** DataInputStream类实现了DataInput接口，
  * 为了从文件中读入二进制数据，
  * 可以将DataInputStream与某个字节源相组合，
  * 例如FileInputStream：
  */
var in = new DataInputStream(new FileInputStream("employee.dat"));

/** 类似地，
  * 要写出二进制数据，
  * 可以使用实现了DataOutput接口的DataOutputStream类：
  */
var out = new DataOutputStream(new FileOutputStream("employee.dat"));

var in = new RandomAccessFile("employee.dat", "r");
var inOut = new RandomAccessFile("employee.dat", "rw");
// r表示只读(read)，rw表示读写(read and write)

var zin = new ZipInputStream(new FileInputStream(zipname));
ZipEntry entry;
while ((entry = zin.getNextEntry()) != null) {
    read the contents of zin
    zin.closeEntry();
}
zin.close();

var fout = new FileOutputStream("test.zip");
var zout = new ZipOutputStream(fout);
for all files
{
    var ze = new ZipEntry(filename);
    zout.putNextEntry(ze);
    send data to zout
    zout.closeEntry();
}
zout.close();

// 创建一个ObjectOutputStream对象
var out = new ObjectOutputStream(new FileOutputStream("employee.dat");
// 使用writeObject方法保存对象
var harry = new Employee("Harry Hacker", 50000, 1989, 10, 1);
var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);

out.writeObject(harry);
out.writeObject(boss);

// 创建一个ObjectInputStream对象
var in = new ObjectInputStream(new FileInputStream("employee.dat"));
// 使用readObject方法获得对象
var e1 = (Employee) in.readObject();
var e2 = (Employee) in.readObject();

Path absolute = Paths.get("/home", "harry");
Path relative = Paths.get("myprog", "conf", "user.properties");

/** 1. resolve方法
  * 调用p.resolve(q)将按照下列规则返回一个路径：
  * 若q是绝对路径，则结果就是q。
  * 否则，根据文件系统的规则，将“p后面跟着q”作为结果。
  */
Path workRelative = Paths.get("work");
Path workPath = basePath.resolve(workRelative);
  // resolve方法有一种快捷方式，它接受一个字符串而不是路径。
Path workPath = basePath.resolve("work");

/** 2. resolveSibling方法
  * 若workPath是 /opt/myapp/wokr ，
  * 下面的调用，
  * 将创建 /opt/myapp/temp 。
  */
Path tempPath = workPath.resolveSibling("temp");

/** 3. relativize方法
  * 以“/home/harry”为目标对“/home/fred/input.txt”进行相对化操作，
  * 会产生“../fred/input.txt”，
  * 其中，假设..表示文件系统中的父目录。
  **/
  
/** 4. normalize方法
  * 该方法会移除所有冗余的.和.. ，
  * 规范化 /home/harry/../fred/./input.txt ，
  * 将产生 /home/fred/input.txt 。
  */
  
/** 5. toAbsolutePath方法
  * 将产生给定路径的绝对路径。
  */

// 读取文件的所有内容
byte[] bytes = Files.readAllBytes(path);

// 从文本文件中读取内容
var content = Files.readString(path, charset);

// 将文件当作行序列读入
List<String> lines = Files.readAllLines(path, charset);

// 写出一个字符串到文件中
Files.writeString(path, content.charset);

// 向指定文件追加内容
Filse.write(path, content.getBytes(charset), StandardOpenOption.APPEND);

// 将一个行的集合写出到文件中
Files.write(path, lines, charset);

/** 以上简便方法适用于处理中等长度的文本文件，
  * 若要处理文件长度比较大，
  * 或者是二进制文件，
  * 那么还是应该使用输入/输出流或者读入器/写出器：
  */
InputStream in = Files.newInputStream(path);
OutputStream out = Files.newOutputStream(paht);

Reader in = Files.newBufferedReader(path, charset);
Writer out = Files.newBufferedWriter(path, charset);

// 1. 创建新目录
/** createDirecoty方法
  * F:\\IDEAWORKSPACE\\TestDemo文件夹已经存在 \\newDir不存在
  ***************************************************************
  * String pathstr = "F:\\IDEAWORKSPACE\\TestDemo\\newDir";
  * Path path = Paths.get(pathstr);
  */
Files.createDirecoty(path);

/** createDirecoties方法
  * F:\\IDEAWORKSPACE\\TestDemo路径已经存在 \\midDir\\newDir不存在
  ***************************************************************
  * String pathstr = "F:\\IDEAWORKSPACE\\TestDemo\\midDir\\newDir";
  * Path path = Paths.get(pathstr);
  */
Files.createDirecoties(path);  

// 2. 创建文件
/** createFile方法
  * F:\\IDEAWORKSPACE\\TestDemo路径已经存在 myfile.txt不存在
  ***************************************************************
  * String pathstr = "F:\\IDEAWORKSPACE\\TestDemo\\myfile.txt";
  * Path path = Paths.get(pathstr);
  */
Files.createFile(path);
// 会在指定路径下创建myfile.txt空文件

Path newPath = Files.createTempFile(dir, prefix, suffix);
Path newPath = Files.createTempFile(prefix, suffix);
Path newPath = Files.createTempDirectory(dir, prefix);
Path newPath = Files.createTempDirectory(prefix);
/** dir是一个Path对象，prefix和suffix是可以为null的字符串。
  * 例如，调用Files.createTempFile(null, ".txt")
  * 可能会返回一个像 /temp/1234405522364837194.txt 这样的路径。
  */

// 1. 复制
Files.copy(fromPath, toPath);

// 2. 移动
Files.move(fromPath, toPath);

/** 若目标路径已经存在，
  * 则复制或移动将失败。
  * 若要覆盖已有的目标路径，
  * 可以使用REPLACE_EXISTING选项。
  * 若要复制所有的文件属性，
  * 可以使用COPY_ATTRIBUTES选项。
  */
Files.copy(fromPath, toPath, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES);

/** 将操作定义为原子性的，
  * 以此保证要么移动操作成功完成，
  * 要么源文件继续保持在原来位置。
  * 使用ATOMIC_MOVE实现。
  */
Files.move(fromPath, toPath, StandardCopyOption.ATOMIC_MOVE);

/** 将一个输入流复制到Path中，
  * 表示想要将该输入流存储到硬盘上。
  * 类似地，可以将一个Path复制到输出流中。
  */
Files.copy(inputStream, toPath);
Files.copy(fromPath, outputStream);

// 3. 删除
Files.delete(path); // 文件不存在会报错
// 使用deleteIfExists方法
boolean deleted = Files.deleteIfExists(path);

/** 1.
  * 以下静态方法都将返回一个boolean值，
  * 表示检查路径的某个属性的结果。
  */
exists
isHidden
isReadablle，isWritable，isExecutable
isRegularFile，isDirectory，isSymbolicLink

/** 2. size方法
  * 返回文件的字节数。
  */
long fileSize = Files.size(path);

/** 3. getOwner方法
  * 将文件拥有者作为java.nio.file.attribute.UserPrincipal的一个实例返回。
  */

// 获取这些属性，可以调用
BasicFileAttributes attributes = Files.readAttributes(path, BasicFileAttributes.class);
// 若文件系统兼容POSIX，那么可以获得一个PosixFileAttributes实例
PosixFileAttributes attributes = Files.readAttributes(path, PosixFileAttributes.class);

/** 静态的Files.list方法
  * 返回一个可以读取目录中各个项的Stream<Path>对象
  */
try (Stream<Path> entries = Files.list(pathToDirectory)) {
    ...
}

// list方法不会进入子目录。

/** Files.walk方法
  * 处理目录中的所有子目录
  */
try (Stream<Path> entries = Files.walk(pathToRoot)) {
    // Contains all descendants, visited in depth-first order
}

try (DirectoryStream<Path> entries = Files.newDirectorySystem(dir)) {
    for (Path entry : entries)
        Process entries
}

// 可以用glob模式来过滤文件
try (DirectoryStream<Path> entries = Files.newDirectorySystem(dir, "*.java"))

FileSystem fs = FileSystems.newFileSystem(Paths.get(zipname), null);
/** 以上调用将建立一个文件系统，
  * 它包含ZIP文档中的所有文件。
  * 其中zipname是某个ZIP文件的名字。
  */

// 已知文件名，从ZIP文档中复制出这个文件
Files.copy(fs.getPath(sourceName), targetPath);
// 其中的fs.getPath对于任意文件系统来说都与Paths.get类似

/** 首先，从文件中获得一个通道（channel），
  * 通道是用于磁盘文件的一种抽象，
  * 可以访问诸如内存映射、文件加锁机制以及文件间快速数据传递等操作系统特性。
  */
FileChannel channel = FileChannel.open(path, options);

/** 然后，通过调用FileChannel类的map方法从这个通道中获得一个ByteBuffer。
  * 可以指定映射的文件区域和映射模式，
  * 支持的模式有三种：
  * 1. FileChannel.MapMode.READ_ONLY：所产生的缓冲区是只读的，任何对该缓冲区写入的尝试都会导致ReadOnlyBufferException异常。
  * 2. FileChannel.MapMode.READ_WRITE：所产生的缓冲区是可写的，任何修改都会在某个时段写回到文件中。
  * 3. FileChannel.MapMode.PRIVATE：所产生的缓冲区是可写的，但是任何修改对这个缓冲区来说都是私有的，不会传播到文件中。
  * 一旦有了缓冲区，就可以使用ByteBuffer类和Buffer超类的方法读写数据了。
  */

// 顺序遍历缓冲区中的所有字节
while (buffer.hasRemaining()) {
    byte b = buffer.get();
    ...
}

// 随机访问
for (int i = 0; i < buffer.limit(); i++) {
    byte b = buffer.get(i);
    ...
}

/** 1. 锁定文件
  * 可以调用FileChannel类的lock或tryLock方法
  */
// A. 阻塞直至可获得锁
FileChannel = FileChannel.open(path);
FileLock lock = channel.lock();

// B. 立即返回  要么返回锁 要么在锁不可获得的情况下返回null
FileLock lock = channel.lock();

/** 2. 锁定文件的一部分
  */
FileLock lock(long start, long size, boolean shared);
// or 
FileLock trylock(long start, long size, boolean shared);
/** 如果shared标志为false，
  * 则锁定文件的目的是读写。
  * 而如果为true，
  * 则这是一个共享锁，
  * 允许多个进程从文件中读入，
  * 并阻止任何进程获得独占的锁。
  */

/** 首先用表示正则表达式的字符串构建一个Pattern对象。
  * 然后从这个模式中获得一个Matcher，
  * 并调用它的mathes方法。
  */
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(input);
if (matcher.matchers()) ...

Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE);
// 或者可以在模式中指定它们
String regex = "(?iU:expression)";

Stream<String> strings = ...;
Stream<String> result = strings.filtter(pattern.asPredicate());

/** 使用Matcher类的find方法来查找匹配内容，
  * 如果返回true，
  * 再使用start和end方法来查找匹配内容，
  * 或使用不带引元的group方法来获取匹配的字符串。
  */
while(matcher.find()) {
    int start = matcher.start();
    int end = matcher.end();
    String match = input.group();
    ...
}

/** Pattern.split方法可以自动完成这项任务。
  * 调用此方法后可以获得一个剔除分隔符之后的字符串数组：
  */
String input = ...;
Pattern commas = Pattern.compile("\\s*,\\s*");
String[] tokens = commas.split(input)
    // "1, 2, 3" turns into ["1", "2", "3"]
    
// 若有多个标记，那么可以惰性地获取它们：
Stream<String> tokens = commas.splitAsStream(input);

// 若不关心预编译模式和惰性获取，那么可以使用String.split方法：
String[] tokens = input.split("\\s*,\\s*");

// 若输入数据在文件中，那么要使用扫描器：
var in = new Scanner(path, StandardCharsets.UTF_8);
in.useDelimiter("\\s*,\\s*");
Stream<String> tokens = in.tokens();

/** 例如，
  * 将所有的数字序列都替换成#字符
  */
Pattern pattern = Pattern.compile("[0-9]+");
Matcher matcher = pattern.matcher(input);
String output = matcher.replaceAll("#");

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

// 现在，可以从文件中读入某个文档：
File f = ...;
Document doc = builder.parse(f);

// 或者，可以用一个URL：
URL u = ...;
Document doc = builder.parse(u);

// 甚至可以指定任意的输入流：
InputStream in = ...;
Document doc = builder.parse(in);

import java.io.IOException;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class SocketTest {
    public static void main(String[] args) throws IOException {
        try (var s = new Socket("time-a.nist.gov", 13);
                var in = new Scanner(s.getInputStream(), StandardCharsets.UTF_8))
        {
            while(in.hasNextLine()) {
                String line = in.nextLine();
                System.out.println(line);
            }
        }
    }
}

var s = new Socket("time-a.nist.gov", 13);
InputStream inStream = s.getInputStream();
/** 第一行代码用于打开一个套接字，
  * 它是网络软件中的一个抽象概念，
  * 负责启动该程序内部和外部之间的通信。
  */

var s = new Socket(...);
s.setSoTimeout(10000); // time out after 10 seconds

/** 1. 静态的getByName方法
  * 将返回一个InetAdress对象，
  * 该对象封装了一个4字节的序列：14.215.177.38
  * （14.215.177.38为百度的IP地址）
  */
InetAddress address = InetAddress.getByNmae("www.baidu.com");

/** 2. getAddress方法
  * 访问这些字节。
  */
byte[] addressBytes = address.getAddress();

/** 3. 一些访问量较大的主机名通常会对应多个因特网地址，
  * 以实现负载均衡。
  * 当访问主机时，
  * 会随机选取几种的一个。
  * getAllByName方法
  * 获得所有主机。
InetAddress[] addresses = InetAddress.getAllByName(host);

/** 4. 静态的getLocalHost方法
  * 得到本地主机的地址。
  */
InetAddress address = InetAddress.getLocalHost();

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class EchoServer {
    public static void main(String[] args) throws IOException {
        // establish server socket
        try (var s = new ServerSocket(8189)) {
            // wait for client connection
            try (Socket incoming = s.accept()) {
                InputStream inStream = incoming.getInputStream();
                OutputStream outStream = incoming.getOutputStream();

                try (var in = new Scanner(inStream, StandardCharsets.UTF_8)) {
                    var out = new PrintWriter(new OutputStreamWriter(outStream, StandardCharsets.UTF_8), true);

                    out.println("Hello! Enter BYE to exit");

                    // echo client input
                    var done = false;
                    while (!done&&in.hasNextLine()){
                        String line = in.nextLine();
                        out.println("Echo: " + line);
                        if (line.trim().equals("BYE"))
                            done = true;
                    }
                }
            }
        }
    }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class ThreadedEchoServer {
    public static void main(String[] args) throws IOException {
        try (var s = new ServerSocket(8189)) {
            int i = 1;

            while (true) {
                Socket incoming = s.accept();
                System.out.println("Spawning " + i);
                Runnable r = new ThreadedEchoHandler(incoming);
                var t = new Thread(r);
                t.start();
                i++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class ThreadedEchoHandler implements Runnable {
    private Socket incoming;

    public ThreadedEchoHandler(Socket incoming) {
        this.incoming = incoming;
    }

    @Override
    public void run() {
        try (InputStream inStream = incoming.getInputStream();
             OutputStream outStream = incoming.getOutputStream();
             var in = new Scanner(inStream, StandardCharsets.UTF_8);
             var out = new PrintWriter(new OutputStreamWriter(outStream, StandardCharsets.UTF_8), true)) {
            out.println("Hello! Enter BYE to exit.");

            // echo client input
            var done = false;
            while (!done && in.hasNextLine()) {
                String line = in.nextLine();
                out.println("Echo: " + line);
                if (line.trim().equals("BYE"))
                    done = true;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

try (var socket = new Socket(host, port)) {
    var in = new Scanner(socket.getInputStream(), StandardCharsets.UTF_8);
    var writer = new PrintWriter(socket.getOutputStream());
    // send request data
    writer.print(...);
    writer.flush();
    socket.shutdownOutput();
    // now socket is half-closed
    // read response data
    while (in.hasNextLine() != null) {
        String line = in.nextLine();
        ...
    }
}

SocketChannel channel = SocketChannel.open(new InetSocketAddress(host, port);

/** 若不想处理缓冲区，可以使用Scanner类从SocketChannel中读取信息，
  * 因为Scanner有一个带ReadableByteChannel参数的构造器：
  */
var in = new Scanner(channel, StandardCharsets.UTF_8);

/** 通过调用静态方法Channels.newOutputStream，
  * 可以将通道转换成输出流。
  */
OutputStream outStream = Channels.newOutputStream(channel);

/** 自字符串构建一个URL对象：
  */
var url = new URL(urlString);

/** URL类中的openStream方法
  * 该方法产生一个InputStream对象，
  * 如可以用它构建一个Scanner对象。
  */
InputStream inStream = url.openStream();
var in = new Scanner(inStream, StandardCharsets.UTF_8);

/** 1. 调用URL类中的openConnection方法获得URLConnection对象：
  */
URLConnection connection = url.openConnection();

/** 2. 使用以下方法来设置任意的请求属性：
  */
setDoInput
setDoOutput
setIfModifiedSince
setUseCaches
setAllowUserInteraction
setRequestProperty
setConnectTimeout
setReadTimeout

/** 3. 调用connect方法连接远程资源：
  * 除了与服务器建立套接字连接外，
  * 该方法还可用于向服务器查询头信息（header information）。
  */
connection.connect();

/** 4. 与服务器建立连接后，
  * 可以查询头信息。
  * getHeaderFiledKey和getHeaderField这两个方法枚举了消息头的所有字段。
  */
getContentType
getContentLength
getContentEncoding
getDate
getExpiration
getLastModified

/** 5. 最后，访问资源数据。
  */

/** 1. 在提交数据给服务器端程序之前，首先需要创建一个URLConnection对象。
  */
var url = new URL("http://host/path");
URLConnection connection = url.openConnection();

/** 2. 然后调用setDoOutput方法建立一个用于输出的连接。
  */
connection.setDoOutput(true);

/** 3. 接着调用getOutputStream方法获得一个流，
  * 可以通过这个流向服务器发送数据。
  * 如果要向服务器发送文本信息，
  * 那么可以非常方便地将流包装在PrintWriter对象中。
  */
var out = new PrintWriter(connection.getOutputStream(), StandardCharsets.UTF_8);

/** 4. 现在，可以向服务器发送数据了。
out.print(name1 + "=" + URLEncoder.encode(value1, StandardCharsets.UTF_8) + "&");
out.print(name2 + "=" + URLEncoder.encode(value2, StandardCharsets.UTF_8);

/** 5. 之后关闭输出流。
  */
out.close();

/** 6. 最后，调用getInputStream方法读取服务器的响应。
  */

/** HttpClient对象可以发出请求并接收响应。
  * 可以通过下面的调用获取客户端：
  */
HttpClient client = HttpClient.newHttpClient();

/** 或者，如果需要配置客户端，
  * 可以使用像下面这样的构建器API：
  */
HttpClient client = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.ALWAYS)
            .build();

// 将要执行的SQL语句放入字符串中
String command = "UPDATE Books" 
    + " SET Price = Price - 5.00 "
    + " WHERE Title NOT LIKE '%Introduction%'";
    
// 调用Statement接口中的executeUpdate方法
stat.executeUpdate(conmmand);

/** executeQuery方法会返回一个ResultSet类型的对象，
  * 可以通过它来每次一行地迭代遍历所有查询结果。
  */
ResultSet rs = stat.executeQuery("SELECT * FROM Books");

/** 分析结果集时，
  * 通常可以使用类似如下的循环语句代码：
  */
while (rs.next()) {
    look at a row of the result set
}

/** 结果集中行的顺序是任意排列的。
  * 可以使用ORDER BY子句指定行的顺序。
  */
  
/** 查看每一行时，
  * 可能希望知道每一列的内容，
  * 可以使用访问器。
  */
String isbn = rs.getString(1);
double price = rs.getDouble("Price");
// 与数组的索引不同，数据库的序列号是从1开始计算的。

String publisherQuery
    = "SELECT Books.Price, Books"
    + "FROM Books, Publishers"
    + "WHERE Books.Publisher_Id = Publishers.Publisher_Id AND Publisher.Name = ?";
PreparedStatement stat = conn.prepareStatement(publisherQuery);

/** 在执行预备语句之前，
  * 必须使用set方法将变量绑定到实际的值上。
  * 第一个参数指的是需要设置的宿主变量的位置，
  * 位置1表示第一个“ ? ”，
  * 第二个参数指的是赋予宿主变量的值。
  */
stat.setString(1, publisher);

/** 例如，有一张保存图书封面图像的表，
  * 那么，就可以像下面这样获取一种图像。
  */
PreparedStatement stat = conn.prepareStatement("SELECT Cover FROM BookCovers WHERE ISBN=?");
...
stat.set(1, isbn);
try (ResultSet result = stat.executeQuery()) {
    if (result.next()) {
        Blob coverBlob = result.getBlob(1);
        Image coverImage = ImageIO.read(coverBlob.getBinaryStream());
    }
}

/** 例如，存入一张图像。
  */
Blob coverBlob = connection.createBlob();
int offset = 0;
OutputStream out = coverBlob.setBinaryStream(offset);
ImageIO.write(coverImage, "PNG", out);
PreparedStatement stat = conn.prepareStatement("INSERT INTO Cover VALUES (?,?)");
stat.set(1, isbn);
stat.set(2, coverBlob);
stat.executeUpdate();

boolean isResult = stat.execute(command);
boolean done = false;
while (!done) {
    if (isResult) {
        ResultSet result = stat.getResultSet();
        do something with result
    }
    else {
    int updateCount = stat.getUpdateCount();
    if (updateCount >= 0)
        do something with updateCount
    else
        done = true;
    }
    if (!done) isResult = stat.getMoreResults();
}

stat.executeUpdate(insertStatement, Statement.RETURN_GENERATED_KEYS);
ResultSet rs = stat.getGeneratedKeys();
if (rs.next()) {
    int key = rs.getInt(1);
    ...
}

conn.setAutoCommit(false);

/** 按照通常的方式创建一个语句对象：
  */
Statement stat = conn.createStatement();

/** 然后任意多次地调用executeUpdate方法：
  */
stat.executeUpdate(command1);
stat.executeUpdate(command2);
stat.executeUpdate(command3);
...

/** 如果执行了所有命令之后没有出错，
  * 则调用commit方法：
  */
conn.commit();

/** 如果出现错误，则调用：
  */
conn.rollback();

Statement stat = conn.createStatement(); // start transaction; rollback() goes here
stat.executeUpdate(command1);
SavePoint svpt = conn.setSavepoint(); // set savepoint; rollback() goes here
stat.executeUpdate(command2);

if (...) conn.rollback(svpt); // undo effect of command2
...
conn.commit();

// 当不再需要保存点时，应该释放它：
conn.releaseSavepoint(svpt);

/** 为了执行批量处理，
  * 首先必须使用通常的办法创建一个Statement对象：
  */
Statement stat = conn.createStatement();

/** 现在，应该调用addBatch方法，
  * 而非executeUpdate方法：
  */
String command = "CREATE TABLE ..."
stat.addBatch(command);

while (...) {
    command = "INSERT INTO ... VALUES (" + ... + ")";
    stat.addBatch(command);
}

/** 最后，提交整个批量更新语句：
  */ 
int[] counts = stat.executeBatch();

/** 静态方法调用Instant.now()会给出当前的时刻。
  * 为了得到两个时刻之间的时间差，
  * 可以使用静态方法Duration.between。
  * 例如，以下代码可以度量算法运行的时间：
  */
Instant start = Instant.now();
runAlgorithm();
Instant end = Instant.now();
Duration timeElapsed = Duration.between(start, end);
long millis = timeElapsed.toMillis();

/** Duration是两个时刻之间的时间量。
  * 可以调用toNanos、toMillis、getSeconds、toMinutes、toHour和toDay
  * 来获得Duration按照传统单位度量的时间长度。
  * tips： 在Java 8中，必须调用getSeconds而不是toSeconds。
  */

/** Duration接口包含了大量的用于执行算术运算的方法。 
  * 例如，
  * 检测某个算法是否至少比另一个算法快10倍。
  */
Duration timeElapsed2 = Duration.between(start2, end2);
boolean overTenTimesFaster
    = timeElapsed.multipliedBy(10).minus(timeElapsed2).isNegative();

/** 以上代码仅为展示语法。
  * 实际上可以直接调用：
  */
boolean overTenTimesFaster = timeElapsed.toNanos() * 10 < timeElapsed2.toNanos();

LocalDate today = LocalDate.now(); // Today's date

LocalDate alonzosBirthday = LocalDate.of(1903, 6, 14);
alonzosBirthday = LocalDate.of(1903, Month.JUNE, 14);
    // Uses the Month enumeration

birthday.plus(Period.ofYears(1)); // 获得下一年的生日
birthday.plusYears(1); // 获得下一年的生日

birthday.plus(Duration.ofDay(365)); // 在闰年不会产生正确的结果

/** until方法会产生两个本地日期之间的时长。
  */
  
LocalDate independenceDay = LocalDate.of(2020, 07, 20);
LocalDate christmas = LocalDate.of(2020, 12, 25);

independenceDay.until(christmas); // 会产生5个月5天的一段时长

independenceDay.unitl(christmas, ChronoUnit.DAYS) // 158 days

LocalDate start = LocalDate.of(2020, 1, 1);
LocalDate endExclusive = LocalDate.now();
Stream<LocalDate> allDays = start.datesUntil(endExclusive);
Stream<LocalDate> firstDaysInMonth = start.datesUntil(endExclusive, Perod.ofMonths(1));

/** 可以将调整方法的结构传递给with方法。
  * 例如，
  * 某个月的第一个星期二：
  */
LocalDate firstTuesday = LocalDate.of(year, month, 1).with(
    TemporalAdjusters.nextOrSame(DaysOfWeek.TUESDAY));

TemporalAdjuster NEXT_WORKDAY = w -> {
    var result = (LocalDate) w;
    do {
        result = result.plusDays(1);
    } while (result.getDayOfWeek().getValue() >= 6);
    return result;
};

LocalDate backToWork = today.with(NEXT_WORKDAY);

/** lambda表达式的参数类型为Temporal，
  * 它必须被强制转型为LocalDate。
  */

TemporalAdjuster NEXT_WORKDAY = TemporalAdjusters.ofDateAdjuster(w -> 
 {
     LocalDate result = w; // No cast
     do {
         result = result.plusDays(1);
     } while (result.getDayOfWeek().getValue >= 6);
     return result;
 });

LocalTime rightNow = LocalTime.now();
LocalTime bedtime = LocalTime.of(22, 30); // or LocalTime.of(22, 30, 0);

/** plus和minus操作是按照一天24小时循环操作的。
  */
LocalTime wakeup = bedtime.plusHours(8); // wakeup is 6:30:00

/** 给定一个时区ID，
  * 1. 静态方法ZoneId.of(id)可以产生一个ZoneId对象。
  * 2. 调用local.atZone(zoneId)将LocalDateTime对象转换为ZonedDateTime对象，
  * 3. 调用静态方法
  * ZonedDateTime.of(year, month, day, hour, minute, second, nano, zoneId)
  * 来构造一个ZonedDateTime对象。
  */
ZonedDateTime apollo11lauch = ZonedDateTime.of(1969, 7, 16, 9, 32, 0, 0,
    ZoneId.of(America/New_York));
    // 1969-07-16T09:32-04:00[America/New_York]

/** 这是一个具体的时刻，
  * 调用apollo11lauch.toInstant可以获得对于的Instant对象。
  * 反过来
  * 若有一个时刻对象，
  * 调用instant.atZone(ZoneId.of("UTC"))可以获得格林尼治皇家天文台的ZonedDateTime对象。
  */

/** 当夏令时开始时，
  * 时钟要向前拨快一小时。
  * 例如，
  * 在2013年，中欧地区在3月31日2:00切换到夏令时，
  * 若视图构建的时间是不存在的3月31日 2:30，
  * 那么实际上得到的是3:30。
  */
ZonedDateTime skipped = ZonedDateTime.of(
    LocalDate.of(2013, 3, 31),
    LocalTime.of(2, 30),
    ZonedId.of("Europe/Berlin"));
    // Constructs March 31 3:30

/** 返过来，
  * 当夏令时结束时，
  * 时钟要向回拨慢一小时，
  * 同一个本地时间就会出现两次。
  * 当构建位于这个时间段内的时间对象时，
  * 就会得到这个两个时刻中较早的一个。
  */
ZonedDateTime ambiguous = ZonedDateTime.of(
    LocalDate.of(2013, 10, 27), // End of daylight savings time
    LocalTime.of(2, 30),
    ZoneId.of("Europe/Berlin"));
    // 2013-10-27T02:30+02:00[Europe/Berlin]
ZonedDateTime anHourLater = ambiguous.plusHours(1);
    // 2013-10-27T02:30+01:00[Europe/Berlin]

/** 在调整跨越夏令时边界的日期时需要特别注意。
  * 例如，
  * 如果将会议设置在下个星期，
  * 不要直接加上一个7天的Duration：
  */
ZonedDateTime nextMeeting = meeting.plus(Duration.ofDays(7));
    // Caution! Won't work with daylight savings time
    
/** 而应该使用Period类
  */
ZonedDateTime nextMeeting = meeting.plus(Period.ofDays(7)); // OK

/** 要使用标准的格式器，
  * 可以直接调用其format方法：
  */
String formatted = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(appllo11lauch);
    // 1969-07-16T09:32:00-04:00

/** 静态方法ofLocalizedDate、ofLocalizedTime和ofLocalizedDateTime可以创建这种格式器。
  */
DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
String fromatted = formatter.format(appllo11lauch);
    // July 16, 1969 9:32:00 AM EDT

/** 这些方法使用了默认的locale。
  * 为了切换到不同的locale，
  * 可以直接使用withLocale方法。
formatted = formatter.withLocale(Locale.FRENCH).format(apollo11lauch);
    // 16 juillet 1969 09:32:00 EDT
    
/** DayOfWeek和Month枚举都有getDisplayName方法，
  * 可以按照不同的locale和格式给出星期日期和月份的名字。
  */
for (DayOfWeek w : DayOfWeek.values())
    System.out.print(w.getDisplayName(TextStyle.SHORT, Locale.ENGLISH) + " ");
    // Prints Mon Tue Wed Thu Fri Sat Sun

formatter = DateTimeFormatter.ofPattern("E yyyy-MM-dd HH:mm");

// 用标签字符串来构建Locale对象
Locale usEnglish = Locale.forLanguageTag("en-US");

// toLanguageTag方法可以生成给定locale的语言标签
Local.US.toLanguageTag();  // 生成字符串"en-US"

// 获取这些偏好，可以调用
Locale displayLocale = Locale.getDefault(Locale.Category.DISPLAY);
Locale formatLocale = Locale.getDefault(Locale.Category.FORMAT);

/** 工厂方法是NumberFormat类的静态方法，
  * 它们接受一个Locale类型的参数。
  * 总共有3个工厂方法getNumberInstance、
  * getCurrencyInstance和getPercentInstance，
  * 这些方法返回的对象可以分别对
  * 数字、货币量和百分比进行格式化和解析。
  */
Locale loc = Locale.GERMAN;
NumberFormat currFmt = NumberFormat.getCurrencyInstance(loc);
double amt = 123456.78;
String result = currFmt.format(amt);
// 结果是 123.456,78 €

/** 相反，
  * 如果想读取一个按照某个locale的惯用法而输入或存储的数字，
  * 那么就需要使用parse方法。
  */
TextField inputField;
...
NumberFormat fmt = NumberFormat.getNumberInstance();
// get the number formatter for default locale
Number input = fmt.parse(inputField.getText().trim());
double x = input.doubleValue();

/** 假设为一个美国客户准备了一张货物单，
  * 货物单中有些货物的金额是用美元表示的，
  * 有些是用欧元表示的，此时，
  * 你不能只是使用两种格式器：
  */
NumberFormat dollarFormatter = NumberFormat.getCurrencyInstance(Locale.US);
NumberFormat euroFormatter = NumberFormat.getCurrencyInstance(Locale.GERMANY);
/** 这会导致发票看起来非常奇怪，
  * 有些金额的格式像 $ 100，000，
  * 另一些则像100.000 €（注意：欧元值使用小数点而不是逗号作为分隔符）。
  */

/** 应当使用Currency类来控制被格式器处理的货币。
  * 为美国客户设置欧元格式：
  */
NumberFormat euroFormatter = NumberFormat.getCurrencyInstance(Locale.US);
euroFormatter.setCurrency(Currency.getInstance("EUR"));

FormatStyle style = ...; // One of FormatStyle.SHORT, FormatStyle.MEDIUM, ...
DateTimeFormatter dateFormatter = DateTimeFormatter.ofLocalizedDate(style);
DateTimeFormatter timeFormatter = DateTimeFormatter.ofLocalizedTime(style);

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(style);
    // or DateTimeFormatter.ofLocalizedDateTime(style1, style2)
    
/** 以上格式器都会使用当前的locale。
  * 为了使用不同的locale，
  * 需要使用withLocale方法：
  */
DateTimeFormatter dateFormatter =
    DateTimeFormatter.ofLocalizedDate(style).withLocale(locale);

/** 获得locale敏感的比较器，
  * 可以调用静态的Collator.getInstance方法：
  */
Collator coll = Collator.getInstance(locale);
words.sort(coll); // Collator implements Comparator<Object>

/** 括号中的数字是占位符，
  * 可以用实际的名字和值来替换它们。
  * 使用静态方法MessageFormat.format
  * 可以用实际的值来替换这些占位符。
  */
String msg =
    MessageFormat.format("On {2}, a {0} destroyed {1} houses and caused {3} of damage.",
        "hurricane", 99, new GregorianCalendar(1999, 0, 1).getTime(), 10.0E8);
/** 结果是下面的字符串：
  * On 1/1/99 12:00 AM, a hurricane destroyed 99 houses and caused 100,000,000 of damage.
  */
  
  
/** 还可以为占位符提供可选的格式。
  */
String msg =
    MessageFormat.format("On {2,date,long}, a {0} destroyed {1} houses and caused {3,number,currency} of damage.", 
        "hurricane", 99, new GregorianCalendar(1999, 0, 1).getTime(), 10.0E8);
/** 结果是下面的字符串：
  * On January 1, 1999 12:00 AM, a hurricane destroyed 99 houses and caused $100,000,000 of damage.
  */

/** 若知道遗留文件所希望使用的字符编码机制，
  * 可在读写文本文件时指定它：
  */
var out = new PrintWriter(filename, "Windows-1252");

/** 获得可用的最佳编码机制，
  * 可以通过下面的调用来获得“平台的编码机制”：
  */
Charset platformEncoding = Charset.defaultCharset();

/** 与在字符串中使用\n不同，
  * 可以使用printf和%n格式说明符来产生平台相关的行结束符。
  */
out.printf("Hello%nWorld%n");

/** 在Windows上产生
  * Hello\r\nWorld\r\n
  * ***
  * 在其他所有平台上产生
  * Hello\nWorld\n
  */

// 加载一个包：
ResourceBundle currentResources = ReourceBundle.getBundle(baseName, currentLocale);

/** 可以像上一节描述的那样命名属性文件，
  * 例如，
  * MyProgramStrings.properties
  * MyProgramStrings_en.properties
  * MyProgramStrings_de_DE.properties
  */
ResourceBundle currentResources = ReourceBundle.getBundle("MyProgramStrings", locale);

/** 要查找一个集体的字符串，
  * 可以调用
  */
String computeButtonLabel = bundle.getString("computeButton");

/** 知道所需要的引擎，
  * 可以直接通过名字、MIME类型或文件扩展来请求它：
  */
ScriptEngine engine = manager.getEngineByName("nashorn");

/** 一旦拥有了引擎，
  * 就可以通过下面的调用来直接调用脚本：
  */
Object result = engine.eval(scriptString);

/** 如果脚本存储在文件中，
  * 那么需要先打开一个Reader，
  * 然后调用：
  */
Object result = engine.eval(reader);

/** 可以在同一个引擎上调用多个脚本。
  * 如果一个脚本定义了变量、函数或类，
  * 那么大多数引擎都会保留这些定义，
  * 以供将来使用。
  */
engine.eval("n = 1728");
Object result = engine.eval("n + 1"); // 将返回 1729

/** 任何用JavaScript的print和println函数产生的输出都会被发送到writer。
  */
var writer = new StringWriter();
engine.getContext().setWriter(new PrintWriter(writer, true));

/** setReader和setWriter方法只会影响脚本引擎的标准输入和输出源。
  * 执行下面的JavaScript代码，
  * 只有第一个输出会被重定向。
  */
println("Hello");
java.lang.System.out.println("World");

/** 要调用一个函数，
  * 需要用函数名来调用invokeFunction方法，
  * 函数名后面是函数的参数：
  */
// Define greet function in JavaScript
engine.eval("functionn greet(how, whom) { return how + ', ' + whom + '!' }");

// Call the function with arguments "Hello", "World"
result = ((Invocable) engine).invokeFunction("greet", "Hello", "World");

/** 如果脚本语言是面向对象的，
  * 那就可以调用invokeMethod：
  */
// Define Greeter class in JavaScript
engine.eval("function Greeter(how) { this.how = how }");
engine.eval("Greeter.prototype.welcome = "
    + " function(whom) { return this.how + ', ' + whom + '!'}");
    
// Construct an instance
Object yo = engine.eval("new Greeter('Yo')");

// Call the welcome method on the instance
result = ((Invocable) engine).invokeMethod(yo, "welcome", "World");

// 接口
public interface Greeter {
    String welcome(String whom);
}

/** 如果在Nashorn中定义了具有相同名字的函数，
  * 那么可通过这个接口来调用它：
  */
// Define welcome function in JavaScript
engine.eval("function welcome(whom) { return 'Hello, ' + whom + '!'}");

// Get a Java object and call a Java method
Greeter g = ((Invocable) engine).getInterface(Greeter.class);
result = g.welcome("World");

/** 在面对对象的脚本语言中，
  * 可以通过相匹配的Java接口来访问一个脚本类。
  * 例如，
  * 使用Java的语法来调用JavaScript的SimpleGreeter类：
  */
Greeter g = ((Invocable) engine).getInterface(yo, Greeter.class);
result = g.welcome("World");

/** 编译和计算包含在脚本文件中的代码：
  */
var reader = new FileReader("myscript.js");
CompiledScript script = null;
if (engine implements Compilable)
    script = ((Compilable) engine).compile(reader);
    
/** 下面的代码会在编译成功的情况下执行编译后的脚本，
  * 如果引擎不支持编译，
  * 则执行原始的脚本。
  */
if (script != null)
    script.eval();
else
    engine.eval(reader);

/** 调用编译器非常简单，
  * 下面是一个示范调用：
  */
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
OutputStream outStream = ...;
OutputStream errStream = ...;
int result = compiler.run(null, outStream, errStream, 
    "-sourcepath", "src", "Test.java");
// 返回值为0表示编译成功

/** 要想获取CompilationTask对象，
  * 需要以前一节中描述的compiler对象开始，
  * 然后按照下面的方式调用：
  */
JavaCompiler.CompilationTask task = compiler.getTask(
    errorWriter, // Uses System.err if null
    fileManager, // Uses the standard file manager if null
    diagnostics, // Uses System.err if null
    options, // null if no options
    classes, // For annotation processing; null if none
    sources);

/** 最后三个参数是Iterable的实例。
  * 例如，选定序列可以像下面这样指定：
  */
Iterable<String> options = List.of("-d", "bin");

/** sources参数是JavaFileObject实例的Iterable。
  * 如果想要编译磁盘文件，
  * 需要获取一个StandardJavaFileManager对象，
  * 并调用其getJavaFileObject方法：
  */
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable<JavaFileObject> sources
    = fileManager.getJavaFileObjectsFromStrings(List.of("File1.java", "File2.java"));
JavaCompiler.CompilationTask task = compiler.getTask(
    null, null, null, options, null, sources);