如何写出优雅、高效、逼格高的Java代码（代码优化、Java新特性、代码规范）

目录

常见代码优化：

if/if-else语句优化

使用提前判断

使用枚举或映射

使用函数式编程

将判断逻辑封装

其他

循环类型代码优化

 Stream API

集合操作

数组操作

异常类型代码优化

tyr-with-resource

使用Java 8的函数式接口简化回调操作

字符串操作代码优化

字符格式化

字符串拼接

 Java 11的字符串方法

Java 14的新特性：多行文本块

多线程代码优化

使用并发集合简化

Java 8的CompletableFuture实现异步编程

其它类别代码优化

延迟计算

对象类型转换

Java 15的新特性：记录（Records）

Java 16的新特性：模式匹配的实例of操作符

Java 9的模块化系统

Java15引入特性：密封类型

Java14：Switch表达式

Java 11：嵌套的Lambda表达式

Java8新特性：自定义注解

Java代码规范

---

常见代码优化：

if/if-else语句优化

使用提前判断

如果某些条件更常见或更容易满足，将其放在前面判断，以减少不必要的判断。这样可以更快地结束整个条件分支。

eg：

    // 修改后：    
    @SneakyThrows
    @PostMapping("/saveFeedBackT")
    @ApiOperation("获用户取评价内容")
    public AjaxResult saveFeedBackT(@ApiParam("教师名称") @RequestParam String teacher,
                                    @ApiParam("评分") @RequestParam Integer rating,
                                    @ApiParam("评价内容") @RequestParam String comment) {
        Preconditions.checkArgument(rating!=null&&teacher!=null,"信息填写不完整");
        //或者  一个参数或者对象可以  Assert.notNull(rating,"信息填写不完整");
        return feedbackTeacherService.saveFeedBackT(teacher,rating,comment);
    }

机制	优点	缺点
Alerrt ：断言/警告机制	可读性高,可通过异常处理机制传播栈堆错误，方便找出原因	1）本身会消耗一些性能，开启Assert会产生额外能消耗（idea默认开启） 2）敏感信息被放入栈堆可能会被攻击者利用 3）处理的能力比较弱
PreCondition：前置条件机制	可读性高,内置方法多，处理能力较强	1）本身会消耗一些性能 2）不同方法使用了很多相同的判断，会导致代码冗余（Assert相同，但是Assert一般在生产环境要被禁用或移除）
if语句结合抛出异常	灵活性高，可适应特殊的处理	1）可读性较弱 2）需要手动实现异常处理机制，比较复杂（实现可能出错，如抛出了不相关异常），可维护性较弱

使用枚举或映射

如果有大量的条件和对应的操作，可以使用枚举或映射来简化代码。将条件作为枚举的值或映射的键，将对应的操作封装在枚举常量或映射值中。

       //创建测试数组
       List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        //列表元素中选择出1,2,5并进行打印
       list.forEach(f->{    // 不好的写法
           if (f==1){
               System.out.println("一");
           }
           if (f==2){
               System.out.println("二");
           }
           if (f==5){
               System.out.println("五");
           }
       });


        list.forEach(f->{    // 使用if-else减少判断次数
            if (f==1){
                System.out.println("一");
            }else if(f==2){
                System.out.println("二");
            }else if (f==5){
                System.out.println("五");
            }
        });

        list.forEach(f -> { //使用枚举简化（需要创建枚举类）
            Test t = Test.valueOf(String.valueOf(f));
            System.out.println(t.getI_CN());
        });
        
        list.forEach(f->{   //使用switch表达式 java14引入
            System.out.println(switch (f) {
                case 1 -> "一";
                case 2 -> "二";
                case 5 -> "五";
                default -> "";
            });
        });

使用函数式编程

Java 8 引入的函数式编程可以使代码更简洁和可读。可以使用Lambda表达式、函数接口以及Stream API等功能来处理条件判断。

eg:

        //用于存储大于3的元素
        List<Integer> A_gt3 = new ArrayList<>(5);   //一般的写法
        for (Integer i : list) {
            if (i>3){
                A_gt3.add(i);
            }
        }

        List<Integer> B_gt3 = new ArrayList<>(5);   //使用lambda表达式
        list.forEach(i->{
            if (i>3){
                A_gt3.add(i);
            }
        });

        List<Integer> C_gt3 = list.stream()     //使用stream()流
                .filter(i -> i > 3)
                .toList();
    }

for、foreach、stream效率比较：

    如果数据在1万以内的话，for循环效率高于foreach和stream；如果数据量在10万的时候，stream效率最高，其次是foreach,最后是for。另外需要注意的是如果数据达到100万的话，parallelStream异步并行处理效率最高，高于foreach和for。

将判断逻辑封装

//如果有很多给相同的判断 可以使用Predicate接口将判断逻辑封装成可复用的谓词
// 将一个是否为偶数的判断封装
Predicate<Integer> isEven = number -> number % 2 == 0;
boolean result = isEven.test(4);

其他

此外，还有的常用做法还有，使用三元表达式，对if判断进行逻辑优化，提出if语句作为公共方法等。

循环类型代码优化

 Stream API

集合操作

        Map<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 5);

        // 相加
        int sum = list.stream().mapToInt(Integer::intValue).sum();
        int sum2 = list.stream().reduce(0, Integer::sum);   //从基础值0的基础上累加
        int sum3 = list.parallelStream().reduce(0, Integer::sum);   //使用并行流相加
        // 获取最大值    //Optional类型可以包装结果为null的值
        Optional<Integer> max = list.stream().max(Integer::compareTo);
        // 获取最小值
        Optional<Integer> min = list.stream().min(Integer::compareTo);
        min.ifPresent(System.out::println);

        //直接使用Java 8的Stream API对集合进行统计操作
        IntSummaryStatistics i = list.stream()
                .mapToInt(Integer::intValue)
                .summaryStatistics();
        System.out.println("最大值: " + i.getMax());
        System.out.println("最小值: " + i.getMin());
        System.out.println("总和: " + i.getSum());
        System.out.println("平均值: " + i.getAverage());


        // 去重
        List<Integer> distinctNumbers = list.stream()
                .distinct()
                .toList();


        //利用lambda表达式 使用方法引用 打印输出
        list.forEach(System.out::println);
        // 遍历所有的键值对 使用Lambda表达式
        map.forEach((key, value) -> System.out.println(key + ": " + value));


        //筛选和映射
        List<String> names = Arrays.asList("aa", "bbb", "ccccc");
        List<String> filteredNames = names.stream()     // 遍历输出的结果为 CCCCC
                .filter(name -> name.length() > 4)
                .map(String::toUpperCase)
                .toList();


        // 分组和聚合
        List<Person> people = Arrays.asList(
                new Person("A", 10),
                new Person("B", 15),
                new Person("C", 20)
        );

        Map<Integer, List<Person>> personList = people.stream()     //会创建一个新的map
                .collect(Collectors.groupingBy(Person::getAge));

        int totalAge = people.stream()  //累加每个人的年龄
                .mapToInt(Person::getAge)
                .sum();


        // 分组和聚合
        List<Person> peoples = Arrays.asList(
                new Person("A", 10),
                new Person("B", 15),
                new Person("C", 20),
                new Person("D", 25)
        );

        // 使用Optional和Stream API链式操作处理嵌套对象
        Optional<Company> company = getCompany();
        String companyName = company.flatMap(Company::getDepartment)
                .flatMap(Department::getManager)
                .map(Manager::getName)
                .orElse("Unknown");

数组操作

int[] numbers = {1, 2, 3, 4, 5};
// 数组元素求和
int sum = Arrays.stream(numbers).sum();
// 数组排序
int[] sortedNumbers = Arrays.stream(numbers).sorted().toArray(); 

异常类型代码优化

tyr-with-resource

// 可同时处理多个资源
try (BufferedReader br = new BufferedReader(new FileReader("file1.txt"));
     BufferedWriter bw = new BufferedWriter(new FileWriter("file2.txt"))) {
    // 执行操作
} catch (IOException e) {
    // 处理异常
}

使用Java 8的函数式接口简化回调操作

//不使用lambda表达式
public interface Callback {
    void onSuccess(String result);
    void onFailure(Exception e);
}

public void fetchDataAsync(Callback callback) {
    // 异步获取数据
    try {
        String data = fetchData();
        callback.onSuccess(data);
    } catch (Exception e) {
        callback.onFailure(e);
    }
}

// 使用匿名内部类调用
fetchDataAsync(new Callback() {
    @Override
    public void onSuccess(String result) {
        System.out.println("Success: " + result);
    }

    @Override
    public void onFailure(Exception e) {
        System.err.println("Error: " + e.getMessage());
    }
});


// 使用lambda表达式后
@FunctionalInterface //Java8引入的一个注解，用于标记该接口为函数式接口
public interface Callback {
    void onSuccess(String result);
    void onFailure(Exception e);
}

public void fetchDataAsync(Callback callback) {
    // 异步获取数据
    try {
        String data = fetchData();
        callback.onSuccess(data);
    } catch (Exception e) {
        callback.onFailure(e);
    }
}

// 使用Lambda表达式调用
fetchDataAsync(result -> System.out.println("Success: " + result),
               error -> System.err.println("Error: " + error.getMessage()));

字符串操作代码优化

字符格式化

// 类似于c语言的输出语句 阅读时可以知道传入值的类型（和'+'拼接相比）
String name = "LiMing";
int age = 18;
String message = String.format("My name is %s and I'm %d years old.", name, age);

字符串拼接

使用'+'进行拼接：每执行完一条拼接语句会创建一个新的String对象，在产生对象少时推荐使用

需要多次拼接时：
StringBuilder：线程不安全，效率高，不考虑线程安全时使用（如单线程环境），jdk1.5引入

StringBuffer：方法都是同步，线程安全，效率比StringBuilder低，jdk1.0引入

StringJoiner：适用于两字符串间要拼接相同的字符串，jdk8引入

//demo
StringBuilder s = new StringBuilder();
s.append("A");
s.append(", ");
s.append("B");
s.append(", ");
s.append("C");
String result = s.toString();


StringBuffer s = new StringBuffer();
s.append("A");
s.append(", ");
s.append("B");
s.append(", ");
s.append("C");
String result = s.toString();
                                                                                               

StringJoiner s = new StringJoiner(", ");
s.add("A");
s.add("B");
s.add("C");
String result = s.toString();

 Java 11的字符串方法

// isBlank()和lines()
String text = "Hello\nWorld";
System.out.println(text.isBlank()); // 检查字符串是否为空白
System.out.println(text.lines().count()); // 统计字符串中行的数量

Java 14的新特性：多行文本块

String html = """
              <html>
                  <body>
                      <h1>Hello, World!</h1>
                  </body>
              </html>
              """;
System.out.println(html);

多线程代码优化

使用并发集合简化

// 简化前代码 并发时要保证线程安全 所以使用hashtable  
// 这个代码是给一个key，key存在，它的值进行加一操作
 Hashtable<String, Integer> hashtable = new Hashtable<>();
        
        synchronized (hashtable) {
            if (!hashtable.containsKey("key")) {
                hashtable.put("key", 0);
            } else {
                hashtable.put("key", hashtable.get("key") + 1);
            }
        }

//简化后
ConcurrentMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.putIfAbsent("key", 0);
concurrentMap.computeIfPresent("key", (k, v) -> v + 1);

Java 8的CompletableFuture实现异步编程

//直接使用这个类 目的是为了不用手动创建、启动和管理线程
//实现多个任务并行执行
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> task1());
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> task2());
CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + ", " + result2);
//实现超时处理
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> task());
try {
    String result = future.get(1, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    // 处理超时情况
}

其它类别代码优化

延迟计算

它能够节省资源，避免重复计算
如在电商网站推迟商品推荐的计算，直到用户进入推荐页面时才进行

Supplier<String> lazyValue = () -> {
    // 执行一些复杂的计算
    return "Hello World!";
};

String value = lazyValue.get(); // 在需要时计算值

对象类型转换

class Student {
    private String name;
    private int age;
    private double score;

    // 省略构造方法和其他方法
    // ...
}
class StudentDTO {
    private String name;
    private int age;

    // 省略构造方法和其他方法
    // ...
}

// 1、可以使用Function类进行类型装换 可适用于复杂场景，比较符合函数式编程代码风格
Function<Student, StudentDTO> studentToDtoConverter = student -> new StudentDTO(student.getName(), student.getAge());
StudentDTO studentDTO = studentToDtoConverter.apply(student);

// 2、使用BeanUtils.copyProperties(source, target)方法进行类型转换 使用简单明了
StudentDTO studentDTO = new StudentDTO();
BeanUtils.copyProperties(student, studentDTO)

Java 15的新特性：记录（Records）

Records对象：不可变（相当于final修饰），会自动为数据成员生成字段、构造函数、equals()、hashCode() 和 toString() 方法
使用目的：简洁、可减少代码书写  且Records支持模式匹配（instanceof 或 switch检查对象是否与某个类型或模式匹配，并且可以直接获取匹配后的对象属性）
 

//demo
record Person(String name, int age) {}
Person person = new Person("LiMing", 18);
System.out.println(person.name());
System.out.println(person.age());

//模式匹配demo
public void processPerson(Person person) {
    if (person instanceof Person adult && adult.age() >= 18) {
        System.out.println(adult.name() + " 是成人，");
        System.out.println("年龄: " + adult.age());
    }
}

Java 16的新特性：模式匹配的实例of操作符

Object obj = 10;
if (obj instanceof Integer integer) {
    System.out.println("Integer: " + integer);
} else if (obj instanceof String str) {
    System.out.println("String: " + str);
} else {
    System.out.println("Unknown");
}

Java 9的模块化系统

它的目的是提供一种更好的方式来组织和管理 Java 应用程序的代码。通过模块化，可以显式地声明模块之间的依赖关系，增强了代码的可维护性和可扩展性

// module-info.java
//这个文件要放到项目中的模块根目录中
module com.example.myapp {
    requires java.base;
    requires org.apache.commons.lang3;
}

Java15引入特性：密封类型

sealed 关键字：用于修饰类、接口或枚举，将其声明为密封类型。密封类型表示该类型只能被指定的子类继承或实现。使用 sealed 可以限制对密封类型的扩展，从而更好地控制类型的继承结构
permits 关键字：用于在密封类型的声明中列出允许继承或实现的具体子类。只有在 permits 子句中明确列出的类才能继承或实现密封类型。这样，您可以明确指定哪些类允许扩展或实现密封类型，提供更加可控的类型继承关系

//demo
public sealed interface Shape permits Circle, Rectangle {
    double calculateArea();
}

public final class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public final class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double calculateArea() {
        return width * height;
    }
}

Java14：Switch表达式

//传统写法
int day = 2;
String dayOfWeek;

switch (day) {
    case 1:
        dayOfWeek = "星期一";
        break;
    case 2:
        dayOfWeek = "星期二";
        break;
    case 3:
        dayOfWeek = "星期三";
        break;
    // 其他...
    default:
        dayOfWeek = "无法识别";
        break;
}
//Switch表达式 switch表达式不需要break关键字
int day = 2;
String dayOfWeek = switch (day) {
    case 1 -> "星期一";
    case 2 -> "星期二";
    case 3 -> "星期三";
    // 其他箭头标签...
    default -> "无法识别";
};

Java 11：嵌套的Lambda表达式

在Java 8中，Lambda表达式不能直接包含嵌套的Lambda表达式。只能通过传递已存在的Lambda表达式作为参数来实现类似的效果。

但是从Java 11开始，嵌套的Lambda表达式被引入，允许在Lambda表达式的主体中包含其他Lambda表达式。这种语法使得编写更复杂的函数式代码变得更加方便。

//demo
Function<Integer, Function<Integer, Integer>> add = x -> y -> x + y;

int result = add.apply(1).apply(2);
System.out.println(result); // 输出 3

Java8新特性：自定义注解

//demo
// 自定义的注解 @Color 和 @Colors
@Repeatable(Colors.class)
@Retention(RetentionPolicy.RUNTIME)
public @interface Color {
    String value();
}

public @interface Colors {
    Color[] value();
}

//调用
@Color("Red")
@Color("Blue")
public class MyClass {

    public static void main(String[] args) {
        // 获取 MyClass 类上的 @Color 注解
        Color[] colors = MyClass.class.getAnnotationsByType(Color.class);
        for (Color color : colors) {
            System.out.print(color.value());    //输出RedBlue
        }
    }
}

Java代码规范

阿里巴巴java开发手册2020.pdf

链接：

百度网盘 请输入提取码

提取码：8700

最后，

        希望文章对你有所帮助！