自己总结优化代码写法

news2024/10/1 19:22:06

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;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/338165.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SpringCloud第二讲 Ribbon负载均衡源码分析

SpringCloud第二讲 Ribbon负载均衡源码分析

前言介绍&#xff1a; 这一讲我们将依据Eureka的负载均衡规则&#xff0c;Eureka的具体服务搭建以及服务注册和服务发现可以参考基于Eureka实现服务注册和服务发现_热爱Java的编程小白的博客-CSDN博客 Eureka的服务搭建之后便可以在这上面进行服务注册&#xff0c;如果存在两个…
阅读更多...
产品权限分析与设计

产品权限分析与设计

目前我们使用的访问控制授权方案&#xff0c;主要有以下4种&#xff1a;DAC自主访问控制ACL 访问控制列表MAC强制访问控制RBAC 基于角色的访问控制笔者将拆解和分析这4种权限管理方案的逻辑&#xff0c;并告诉你&#xff0c;这4种权限分别可以运用在什么样的场景中&#xff0c;…
阅读更多...
不能注册？让小白也能使用【ChatGPT】

不能注册？让小白也能使用【ChatGPT】

ChatGPT介绍最近ChatGPT可谓是非常火爆&#xff0c;使得互联网各界人士都备受关注&#xff0c;如果你还不了解ChatGPT,那你真的有点落后了哈。 简单介绍一下ChatGPTChatGPT是由美国人工智能OpenAI研究开发的一种全新聊天机器人模型&#xff0c;它能够通过学习和理解人类的语言跟…
阅读更多...
研一寒假C++复习笔记--左值和右值的理解和使用

研一寒假C++复习笔记--左值和右值的理解和使用

目录 1--左值和右值的定义 2--简单理解左值和右值的代码 3--非const引用只能接受左值 1--左值和右值的定义 左值&#xff1a;L-Value&#xff0c;L理解为 Location&#xff0c;表示可寻&#xff1b; 右值&#xff1a;R-Value&#xff0c;R理解为 Read&#xff0c;表示可读&a…
阅读更多...
Windows 安装appium环境

Windows 安装appium环境

1 windows Appium环境 1.1 安装Node.js Node.js的安装相对简单,下载安装包安装&#xff08;安装包node-v19.6.0-x64.msi&#xff09;, nodejs 安装 然后一路狂点下一步就可以了 安装完成后,在终端中输入node -v,显示版本号则表示安装成功 node-v16.13.1 1.2 JDK安装及环境变…
阅读更多...
路由器刷固件

路由器刷固件

前言 我希望可以远程访问我的电脑。但&#xff0c;我不希望电脑总是处于运行状态&#xff0c;因为那样比较费电。所以需要一个方案&#xff0c;能将睡眠/关机中的电脑唤醒。 方案一&#xff1a;选用智能插座&#xff0c;远程给电脑上电。电脑设置上电自启。但&#xff0c;这存…
阅读更多...
试题 算法训练 N皇后问题(明确清晰)

试题 算法训练 N皇后问题(明确清晰)

试题 算法训练 N皇后问题 提交此题 评测记录 资源限制 内存限制&#xff1a;256.0MB C/C时间限制&#xff1a;100ms Java时间限制&#xff1a;300ms Python时间限制&#xff1a;500ms 问题描述 　　在N*N的方格棋盘放置了N个皇后&#xff0c;使得它们不相互攻击&#xff08;即…
阅读更多...
色彩-基础理论

色彩-基础理论

颜色三大指标 色相 色相是颜色的一个属性&#xff0c;只有黑白灰没有色相这个属性(那银灰色是什么&#xff1f;) 颜色的相貌&#xff0c;指的也是给颜色一个名字 例如&#xff1a;暗红、酒红、土黄、墨绿 饱和度 颜色的鲜艳程度 纯度 饱和度主要取决于含色成分和消色成分&a…
阅读更多...
IDE2022源码编译tomcat

IDE2022源码编译tomcat

因为学习需要&#xff0c;我需要源码编译运行tomcat对其源码进行一个简单的追踪分析。由于先前并未接触过java相关的知识&#xff0c;安装阻力巨大。最后请教我的开发朋友才解决了最后的问题。将其整理出来&#xff0c;让大家能够快速完成相关的部署。本文仅解决tomcat-8.5.46版…
阅读更多...
tensorflow.js 视频图片多目标检测

tensorflow.js 视频图片多目标检测

前言&#xff1a;Tensorflow.js 官方提供了很多常用模型库&#xff0c;涵盖了平时开发中大部分场景的模型。例如&#xff0c;前面提到的图片识别&#xff0c;除此之外还有人体姿态识别&#xff0c;目标物体识别&#xff0c;语音文字等识别。其中一些可能是 Python 转换而来&…
阅读更多...
前后端RSA互相加解密、加签验签、密钥对生成(Java)

前后端RSA互相加解密、加签验签、密钥对生成(Java)

目录一、序言二、关于PKCS#1和PKCS#8格式密钥1、简介2、区别二、关于JSEncrypt三、关于jsrsasign四、前端RSA加解密、加验签示例1、相关依赖2、cryptoUtils工具类封装3、测试用例五、Java后端RSA加解密、加验签1、CryptoUtils工具类封装2、测试用例六、前后端加解密、加验签交互…
阅读更多...
导数与微分总复习——“高等数学”

导数与微分总复习——“高等数学”

各位CSDN的uu们你们好呀&#xff0c;今天&#xff0c;小雅兰来复习一下之前学过的知识点&#xff0c;也就是导数与微分的总复习&#xff0c;依旧是高等数学的内容&#xff0c;主要是明天就要考高等数学了&#xff0c;哈哈哈&#xff0c;下面&#xff0c;让我们一起进入高等数学…
阅读更多...
取电芯片全协议都可兼容

取电芯片全协议都可兼容

乐得瑞PD协议芯片/PD取电芯片/PD受电端协议芯片 支持5/9/12/15/20v定制 1、概述 LDR6328S 是乐得瑞科技有限公司开发的一款兼容 USB PD、QC 和 AFC 协议的 Sink 控制器。 LDR6328S 从支持 USB PD、QC 和 AFC 协议的适配器取电&#xff0c;然后供电给设备。比如可以配置适配器输…
阅读更多...
二十九、异常处理

二十九、异常处理

目录 ①前言: ②常见的运行时异常 ③常见的编译时异常 ④异常的处理机制 ⑤自定义异常 ①前言: 1.什么是异常&#xff1f; 异常是程序在“编译”或者“执行”的过程中可能出现的问题&#xff0c;注意&#xff1a;语法错误不算在异常体系中。 比如: 数据索引越界异常&…
阅读更多...
C语言的程序环境和预处理详解

C语言的程序环境和预处理详解

目录 一、程序的翻译环境和执行环境 二、编译和链接详解 2、1 翻译环境 2、2 编译过程详解 2、3 执行环境 三、预处理详解 3、1 预定义符号 3、2 #define 3、2、1 #define定义的符号 3、2、2 #define 定义宏 3、2、3 #define 替换规则 3、3 宏和函数的对比 3、4 条件编译 3、5…
阅读更多...
CUDA中的底层驱动API

CUDA中的底层驱动API

文章目录CUDA底层驱动API1. Context2. Module3. Kernel Execution4. Interoperability between Runtime and Driver APIs5. Driver Entry Point Access5.1. Introduction5.2. Driver Function Typedefs5.3. Driver Function Retrieval5.3.1. Using the driver API5.3.2. Using …
阅读更多...
Springboot扩展点之BeanPostProcessor

Springboot扩展点之BeanPostProcessor

前言 Springboot&#xff08;Spring&#xff09;的扩展点其实有很多&#xff0c;但是都有一个共同点&#xff0c;都是围绕着Bean和BeanFactory&#xff08;容器&#xff09;展开的&#xff0c;其实这也很好理解&#xff0c;Spring的核心是控制反转、依赖注入、面向切面编程&…
阅读更多...
西湖论剑 2023 比赛复现

西湖论剑 2023 比赛复现

WEB real_ez_node 在 route/index.js 中&#xff1a; router.post(/copy,(req,res)>{res.setHeader(Content-type,text/html;charsetutf-8)var ip req.connection.remoteAddress;console.log(ip);var obj {msg: ,}if (!ip.includes(127.0.0.1)) {obj.msg"only for…
阅读更多...
【设计模式之美 设计原则与思想：面向对象】13丨实战二（上）：如何对接口鉴权这样一个功能开发做面向对象分析？

【设计模式之美 设计原则与思想：面向对象】13丨实战二（上）：如何对接口鉴权这样一个功能开发做面向对象分析？

面向对象分析&#xff08;OOA&#xff09;、面向对象设计&#xff08;OOD&#xff09;、面向对象编程&#xff08;OOP&#xff09;&#xff0c;是面向对象开发的三个主要环节。在前面的章节中&#xff0c;我对三者的讲解比较偏理论、偏概括性&#xff0c;目的是让你先有一个宏观…
阅读更多...
电脑重装系统注册表恢复方法

电脑重装系统注册表恢复方法

​今天讲关于大家的电脑在遇到一些故障的时候&#xff0c;以及电脑用久了之后会卡顿&#xff0c;那么这时候大家一般都会给电脑重装系统。重装系统之后却发现自己电脑里的注册表不见了&#xff0c;重装系统后怎么恢复注册表?小编就带着大家一起学习重装系统注册表恢复到底是怎…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023