自己总结优化代码写法

jdk1.7新特性详解

开发期间略知jdk1.7的一些特性，没有真正的一个一个得展开研究，而是需要说明再去查，导致最整个新特性不是特别的清楚，这种情况以后得需要改变了，否则就会变成代码的奴隶。现在正好有时间可以细细的研究研究了。文章主要参照oracle jdk1.7的官方地址：https://docs.oracle.com/javase/7/docs/technotes/guides/language/enhancements.html#javase7

• jdk17新特性详解
  • 二进制字面量
  • 在数字字面量使用下划线
  • switch可以使用string了
  • 实例创建的类型推断
  • 使用Varargs方法使用不可维护的形式参数时改进了编译器警告和错误
  • try-with-resources 资源的自动管理
  • 捕捉多个异常类型和对重新抛出异常的高级类型检查

try-with-resources 资源的自动管理

try-with-resources 声明是try 一个或多个资源的声明。一个资源作为一个对象在程序结束之后必须关闭它。try-with-resources声明保证每一个资源都会被关闭在声明结束的时候。任何实现了java.lang.AutoCloseable接口或者实现了java.io.Closeable，可以作为一个资源。
下面的例子从文件中读取第一行。用到了BufferedReader得实例去从文件中读取数据。BufferedReader是一个资源，在程序完成之后必须关闭。

static String readFirstLineFromFile(String path) throws IOException {
  try (BufferedReader br = new BufferedReader(new FileReader(path))) {
    return br.readLine();
  }
}

在这个例子中，在try-with-resources语句中声明的资源是BufferedReader。声明语句出现在try关键字后面的括号内。BufferedReaderJava SE 7及更高版本中的类实现了接口java.lang.AutoCloseable。由于BufferedReader实例是在try-with-resource语句中声明的，因此无论try语句是正常还是意外完成（由于方法BufferedReader.readLine抛出IOException），它都将被关闭。

在Java SE 7之前，无论try语句是正常还是意外完成，都可以使用finally块来确保资源已关闭。以下示例使用finally代替try-with-resources语句的块：

static String readFirstLineFromFileWithFinallyBlock(String path) throws IOException {
  BufferedReader br = new BufferedReader(new FileReader(path));
  try {
    return br.readLine();
  } finally {
    if (br != null) br.close();
  }
}

然而，在这个例子中，如果方法readLine和close都抛出异常，方法readFirstLineFromFileWithFinallyBlock则抛出由finally块抛出的异常，由try块排除的异常将会被抑制。相反，在例子readFirstLineFromFile中，如果try块和try-with-resources声明都抛出异常，方法readFirstLineFromFile则抛出由try块抛出的异常，由try-with-resources抛出的异常将会被抑制。

您可以在try-with-resources语句中声明一个或多个资源。以下示例将检索打包在zip文件zipFileName中的文件的名称，并创建一个包含这些文件名称的文本文件：

public static void writeToFileZipFileContents(String zipFileName, String outputFileName)
    throws java.io.IOException {

    java.nio.charset.Charset charset = java.nio.charset.Charset.forName("US-ASCII");
    java.nio.file.Path outputFilePath = java.nio.file.Paths.get(outputFileName);

    // Open zip file and create output file with try-with-resources statement

    try (
      java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);
      java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(outputFilePath, charset)
    ) {

      // Enumerate each entry

      for (java.util.Enumeration entries = zf.entries(); entries.hasMoreElements();) {

        // Get the entry name and write it to the output file

        String newLine = System.getProperty("line.separator");
        String zipEntryName = ((java.util.zip.ZipEntry)entries.nextElement()).getName() + newLine;
        writer.write(zipEntryName, 0, zipEntryName.length());
      }
    }
  }

在此示例中，try-with-resources语句包含两个用分号分隔的声明：ZipFile和BufferedWrite。当直接跟随它的代码块正常结束或由于异常而终止时，close这些BufferedWriter和ZipFile对象的方法将按此顺序自动调用。请注意，close资源的方法是按照与创建相反的顺序来调用的。

捕捉多个异常类型和对重新抛出异常的高级类型检查

处理大于一种类型的异常
在JAVA SE 7 以及以后的版本中，一个简单的catch块可以处理大于一种类型的异常。这个功能可以减少代码重复并且减少了对捕获广泛异常的诱惑。
注意下面的例子，每一个catch块都包含重复代码

catch (IOException ex) {
     logger.log(ex);
     throw ex;
catch (SQLException ex) {
     logger.log(ex);
     throw ex;
}

在Java SE 7以前的版本中，创建一个通用的方法来消除重复的代码是很困难的，因为变量ex有不同的类型。
以下示例在Java SE 7及更高版本中有效，可消除重复的代码：

catch (IOException|SQLException ex) {
    logger.log(ex);
    throw ex;
}

该catch子句指定类型的块处理异常的，以及每个异常类型与竖线分割（|）。
注意：如果一个catch块处理多个异常类型，则该catch参数是隐式的final。在这个例子中，这个catch参数ex是final，所以你不能在这个catch块中赋值。
一个catch块处理多个异常编译生成的字节码要比多个catch块且每个只处理一个异常生成的字节码要小的多，并且优化。一个catch块处理多个异常的代码块通过编译器生成的字节码代码不重复，字节码没有对异常处理程序的复制。

JDK8

1、Lambda 演变过程
2、StreamAPI 详解
3、Date

StreamAPI 详解

功能

父类：BasicStream

子类：Stream、IntStream、LongStream、DoubleStream

包含两个类型，中间操作 (intermediate operations) 和结束操作 (terminal operations)

下面是所有方法的属于那一端操作的方法：

        //1.将集合转换成流
        list.stream();

        //2.forEach 遍历
        list.forEach(System.out::println);

        //3.filter过滤
        list.stream().filter((e) -> e.getStar().equals("天秤座")).forEach(System.out::println);
        Optional<Student> optionalStudent = list.stream().filter((e) -> e.getStar().equals("天秤座"))
                .findAny();
        Student student = optionalStudent.get();

        //4.map 转换集合
        List<String> names = list.stream().map(Student::getName).collect(Collectors.toList());
        names.stream().forEach(System.out::println);
        Map<String, Object> map = new HashMap<>();
        map.put("key1","1");
        map.put("key2","1");
        map.put("key3","1");
        map.put("key4","1");
        List<String> cidList = map.keySet().stream().map(String::toString).collect(Collectors.toList()); System.out.println(cidList);

        //5.mapToInt 转换数值流
        IntStream intStream = list.stream().mapToInt(Student::getAge);
        Stream<Integer> integerStream = intStream.boxed();
        Optional<Integer> max   = integerStream.max(Integer::compareTo);
        System.out.println(max.get());

        //6.flatMap 合并成一个流
        List<String> list2 = new ArrayList<>();
        list2.add("aaa bbb ccc");
        list2.add("ddd eee fff");
        list2.add("ggg hhh iii");
        list2.add("ggg hhh iii");
        list2 = list2.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(Collectors.toList());
        System.out.println(list2);

        //7.distinct 去重
        list2.stream().distinct().forEach(System.out::println)
        //复杂去重
//        List<RedPacketRecord> newList = records.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(RedPacketRecord::getRoomId))), ArrayList::new));

        //8、sorted 排序
        //asc排序
        list.stream().sorted(Comparator.comparingInt(Student::getAge)).forEach(System.out::println);
        System.out.println("------------------------------------------------------------------");
        //desc排序
        list.stream().sorted(Comparator.comparingInt(Student::getAge).reversed()).forEach(System.out::println);

        //9、skip 跳过前 n 个
        list.stream().skip(1).forEach(System.out::println);

        //10、limit 截取前 n 个
        list.stream().limit(1).forEach(System.out::println);

        //11、anyMatch
        boolean isHave = list.stream().anyMatch(student2 -> student2.getAge() == 16);
        System.out.println(isHave);

        //12、allMatch
        boolean isHave2= list.stream().allMatch(student2 -> student2.getAge() == 16);
        System.out.println(isHave2);

        //13、noneMatch
        boolean isHave3 = list.stream().noneMatch(student2 -> student2.getAge() == 16);
        System.out.println(isHave3);

        //14、findAny
        Optional<Student> student = list.stream().findAny();
        System.out.println(student.get());

        //15、findFirst
        Optional<Student> student = list.stream().findFirst();
        System.out.println(student.get());

        //17、count 计数
        long count = list.stream().count();
        System.out.println(count);

        //18、of
        Stream<String> stringStream = Stream.of("i","love","you");

        //19、empty
        Stream<String> stringStream2 = Stream.empty();

        //20、iterate
        List<String> list = Arrays.asList("a", "b", "c", "c", "d", "f", "a");
        Stream.iterate(0, i -> i + 1).limit(list.size()).forEach(i -> {
            System.out.println(String.valueOf(i) + list.get(i));
        });

        //21、collect：averagingLong
        // 求年龄平均值
        Collector<Student, ?, Double> studentDoubleCollector = Collectors.averagingLong(Student::getAge);
        Double average = list.stream().collect(studentDoubleCollector);

        //22、collect：collectingAndThen
        // 求年龄平均值
        String average2 = list.stream().collect(Collectors.collectingAndThen(Collectors.averagingInt(Student::getAge), a->"哈哈，平均年龄"+a));
        System.out.println(average2);

        //23、collect：counting
        // 求数量
        Long num = list.stream().collect(Collectors.counting());
        System.out.println(num);

        //24、collect: groupingBy(Function)
        Map<Integer,List<Student>> result = list.stream().collect(Collectors.groupingBy(Student::getAge));
        for (Integer age:result.keySet()){
            System.out.println(result.get(age));
				}

        //25、collect：groupingBy(Function,Collector)
        // 先分组，在计算每组的个数
        Map<Integer,Long> num = list.stream().collect(Collectors.groupingBy(Student::getAge,Collectors.counting()));
        System.out.println(num);


        //26、collect：groupingBy(Function, Supplier, Collector)
        // 先分组，在计算每组的个数,然后排序
        Map<Integer,Long> num = list.stream().collect(Collectors.groupingBy(Student::getAge, TreeMap::new,Collectors.counting()));
        System.out.println(num);


        //27、collect：groupingByConcurrent
//        同上，不过这个 Concurrent 是并发的，也有 3 个方法，和上面非并发一个效果
//        groupingByConcurrent(Function)
//        groupingByConcurrent(Function, Collector)
//        groupingByConcurrent(Function, Supplier, Collector)


        //28、collect：joining()
        // 名字拼接
        String result3 = list.stream().map(Student::getName).collect(Collectors.joining());
        System.out.println(result3);

        //29、collect：joining(str)
        // 名字拼接,用逗号隔开
        String result4 = list.stream().map(Student::getName).collect(Collectors.joining(","));
        System.out.println(result4);

        //30、collect：joining(str, prefix, suffix)
        // 名字拼接,包含前缀、后缀
        String result5 = list.stream().map(Student::getName).collect(Collectors.joining(",","hello","world"));
        System.out.println(result5);

        //31、collect：summarizingDouble
        // 求年龄的最大值、最小值、平均值、综合以及人数
        DoubleSummaryStatistics result6 = list.stream().collect(Collectors.summarizingDouble(Student::getAge));
        System.out.println(result6);

        //32、collect：toCollection

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

/**
 * @ClassName Student
 * @Author: c-wangjz02
 * @Description:
 */
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    //名字
    private String name;
    //性别
    private String sex;
    //薪水
    private int salary;
    //年龄
    private int age;
    //星座
    private String star;
}