常见代码优化案例记录

1. 使用StringBuilder优化字符串拼接:

// 不优化的写法
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;
}

// 优化的写法
StringBuilder resultBuilder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    resultBuilder.append(i);
}
String result = resultBuilder.toString();

2. 避免在循环中重复计算数组长度:

// 不优化的写法
for (int i = 0; i < array.length; i++) {
    // 访问数组元素
}

// 优化的写法
int length = array.length;
for (int i = 0; i < length; i++) {
    // 访问数组元素
}

3. 使用局部变量替代重复调用方法:类似2

// 不优化的写法
for (int i = 0; i < list.size(); i++) {
    // 多次调用list.get(i)
}

// 优化的写法
int size = list.size();
for (int i = 0; i < size; i++) {
    // 多次使用size
    // 使用list.get(i)
}

4. 选择合适的集合类:

// 使用ArrayList而不是LinkedList,发明LinkedList都不用LinkedList,可想而知
List<String> arrayList = new ArrayList<>();

// 使用HashSet而不是TreeSet,TreeSet排序消耗性能,但大多数情况下都没必要排序
Set<String> hashSet = new HashSet<>();

5. 合理使用缓存:

// 缓存计算结果
Map<Integer, Integer> cache = new HashMap<>();
int result = cache.computeIfAbsent(input, key -> computeExpensiveOperation(key));

6. 避免过度同步:

// 避免过度同步(锁粒度要尽量最小)
private static final Object lock = new Object();

synchronized (lock) {
    // 一些同步操作
}

7. 使用适当的算法和数据结构:

// 使用Arrays.sort()进行排序
int[] array = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
Arrays.sort(array);

Arrays.sort() 使用了一种高效的排序算法(通常是基于快速排序的变体),在大多数情况下,它能够以较高的性能对数组进行排序。

8. 减少对象创建:

// 减少对象创建
StringBuilder resultBuilder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    resultBuilder.append(i);
}
String result = resultBuilder.toString();

9. 使用快速失败机制:

// 使用Iterator并快速失败机制
List<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    // 对element进行操作
}

如果在遍历集合的过程中,其他线程对集合进行了结构性的修改(比如添加或删除元素),快速失败机制会立即抛出ConcurrentModificationException,以通知集合已经被修改,避免在不一致的状态下继续操作。

10. 使用多线程:

// 使用多线程
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
    // 在线程中执行的代码
});
executor.shutdown();

11. 避免不必要的IO操作:

// 避免不必要的IO操作
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    // 读取文件内容
} catch (IOException e) {
    e.printStackTrace();
}

12. 使用位运算代替乘除法:

// 使用位运算代替乘法
int result = 5 << 2;  // 相当于 5 * 2^2 = 20

13. 避免不必要的装箱和拆箱:

// 不优化的写法
Integer sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i;  // 自动装箱和拆箱
}

// 优化的写法
int sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i;
}

14. 使用静态工厂方法创建对象:

// 不优化的写法
Date now = new Date();

// 优化的写法
Date now = Date.from(Instant.now());

15. 合理使用try-with-resources:

// 不优化的写法
BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("file.txt"));
    // 读取文件内容
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 优化的写法
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    // 读取文件内容
} catch (IOException e) {
    e.printStackTrace();
}

16. 使用Lambda表达式简化代码:

// 不优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
for (String name : names) {
    System.out.println(name);
}

// 优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);

17. 使用并发集合提高多线程性能:

// 不优化的写法
List<String> list = new ArrayList<>();
// 在多线程环境下可能会有并发问题

// 优化的写法
List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
// 或者使用并发集合类
List<String> concurrentList = new CopyOnWriteArrayList<>();

18. 使用Stream API进行集合操作:

// 不优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> uppercaseNames = new ArrayList<>();
for (String name : names) {
    uppercaseNames.add(name.toUpperCase());
}

// 优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> uppercaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

19. 使用局部变量替代字段访问:

// 不优化的写法
class MyClass {
    private int myField;

    public int calculate() {
        return myField * 2;
    }
}

// 优化的写法
class MyClass {
    private int myField;

    public int calculate() {
        int localVar = myField;
        return localVar * 2;
    }
}

使用局部变量替代直接访问字段的做法,是为了在方法内部使用字段的值时,提供更好的可读性和安全性。

20. 使用ConcurrentHashMap代替同步Map:

// 不优化的写法
Map<String, Integer> map = new HashMap<>();
// 在多线程环境下需要额外的同步机制

// 优化的写法
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();

21. 避免在循环中创建对象:

// 不优化的写法
List<String> myList = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    myList.add(new String("Element" + i));
}

// 优化的写法
List<String> myList = new ArrayList<>();
String elementPrefix = "Element";
for (int i = 0; i < 1000; i++) {
    myList.add(elementPrefix + i);
}

22. 使用接口代替继承:

// 不优化的写法
class MyList extends ArrayList<String> {
    // ...
}

// 优化的写法
List<String> myList = new ArrayList<>();

使用接口代替继承的原则是基于面向接口编程的设计理念,有几个原因支持这种优化方式:

  1. 松耦合(Loose Coupling): 使用接口使得类之间的关系更加灵活,降低了各个类之间的耦合度。在不使用具体实现类的情况下,通过接口可以更容易地替换具体的实现,使系统更加灵活和可维护。
  2. 多态性(Polymorphism): 通过使用接口,可以实现多态性。即一个类可以以多种形式存在,不同类的对象可以使用相同的接口进行引用,提高代码的灵活性。
  3. 遵循“合成优于继承”原则: 继承通常引入了额外的复杂性和依赖关系,而使用接口更加简单。合成是指通过组合现有的类和接口来创建新的类,而不是通过继承已有的类。这有助于更好地组织和维护代码。

23. 使用正则表达式进行字符串操作:

// 不优化的写法
String result = "Hello, World!".replace("Hello", "Hi");

// 优化的写法
Pattern pattern = Pattern.compile("Hello");
Matcher matcher = pattern.matcher("Hello, World!");
String result = matcher.replaceFirst("Hi");

通过使用正则表达式的方式,可以更好地应对一些更为复杂的字符串操作需求。然而,对于简单的字符串替换操作,直接使用 replace 方法可能更加简洁和易读。

24. 合理使用断言:

// 不优化的写法
if (condition) {
    throw new IllegalStateException("Condition not met");
}

// 优化的写法
assert condition : "Condition not met";

25. 合理使用enum代替常量:

// 不优化的写法
public static final int STATUS_PENDING = 1;
public static final int STATUS_PROCESSING = 2;
public static final int STATUS_COMPLETED = 3;

// 优化的写法
public enum Status {
    PENDING, PROCESSING, COMPLETED;
}

26. 使用连接池:

// 不优化的写法
Connection connection = DriverManager.getConnection(url, username, password);
// 每次都创建新的数据库连接

// 优化的写法
DataSource dataSource = // 初始化数据源(比如 HikariCP)
try (Connection connection = dataSource.getConnection()) {
    // 使用连接
}

27. 使用并行流进行并行计算:

// 不优化的写法
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.stream()
                 .mapToInt(Integer::intValue)
                 .sum();

// 优化的写法
int sum = numbers.parallelStream()
                 .mapToInt(Integer::intValue)
                 .sum();

优势:

  1. 并行性: 使用并行流可以在多个线程上并行执行操作,加速对大型数据集的处理,特别是在现代多核处理器上。
  2. 简化并行计算: 并行流能够将并行计算的复杂性封装在底层框架中,使得无需手动管理线程。
  3. 适用于某些操作: 并行流在某些类型的操作(如大量数据的过滤、映射、聚合等)上表现得更好。

28. 使用异步编程提高并发性能:

// 不优化的写法
Future<Integer> future = executorService.submit(() -> {
    // 执行耗时操作
    return result;
});

// 优化的写法
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 执行耗时操作
    return result;
}, executorService);

29. 使用单例模式减少对象创建:

// 不优化的写法
class NonSingleton {
    // ...
}

NonSingleton instance = new NonSingleton();

// 优化的写法
class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
        // 私有构造函数
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

Singleton instance = Singleton.getInstance();

30. 使用String.contains检查字符串中是否包含子串:

// 不优化的写法
String text = "Hello, World!";
if (text.indexOf("World") != -1) {
    // 处理逻辑
}

// 优化的写法
String text = "Hello, World!";
if (text.contains("World")) {
    // 处理逻辑
}

31. 使用接口和抽象类进行代码设计:

// 不优化的写法
class Dog {
    void bark() {
        // 狗的吠叫逻辑
    }
}

class Cat {
    void meow() {
        // 猫的喵叫逻辑
    }
}

// 优化的写法
interface Animal {
    void makeSound();
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        // 狗的吠叫逻辑
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        // 猫的喵叫逻辑
    }

32. 使用lambda表达式简化匿名类:

// 不优化的写法
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
};

// 优化的写法
Runnable runnable = () -> System.out.println("Running");

33. 避免在循环中进行数据库查询:

// 不优化的写法
List<String> ids = // 获取一堆ID
for (String id : ids) {
    User user = userRepository.findById(id);
    // 处理用户对象
}

// 优化的写法
List<String> ids = // 获取一堆ID
List<User> users = userRepository.findAllById(ids);
for (User user : users) {
    // 处理用户对象
}

34. 使用适当的日志级别:

// 不优化的写法
if (logger.isDebugEnabled()) {
    logger.debug("Some debug information: " + expensiveOperation());
}

// 优化的写法
logger.debug("Some debug information: {}", expensiveOperation());

35. 减小方法的长度:

将大的方法拆分为小的方法,有助于提高代码的可读性和维护性。

拿阿里巴巴的开发手册来说,并没有明确规定一个方法的具体行数上限,而是提倡按照 Single Responsibility Principle(单一职责原则)和合理拆分的原则来组织代码。然而,根据阿里巴巴的《Java 开发手册》中的一些建议,可以总结一些编码规范和最佳实践,其中也包括关于方法长度的一些建议:

  1. Single Responsibility Principle: 一个方法应该只做一件事情。如果一个方法的功能变得复杂,可以考虑将其拆分为多个小方法,每个小方法负责一个明确的子任务。
  2. 规范注释: 阿里巴巴建议在方法前使用规范注释,明确方法的功能、输入参数、输出结果等信息。如果一个方法的功能需要过多的注释来解释,可能需要考虑拆分。
  3. 控制复杂度: 阿里巴巴建议控制单个方法的复杂度,尽量避免过多的嵌套结构和冗长的代码。这也暗示了一个方法不应该过长。

36. 使用延迟初始化:

// 不优化的写法
class MyClass {
    private ExpensiveObject expensiveObject = new ExpensiveObject();

    public ExpensiveObject getExpensiveObject() {
        return expensiveObject;
    }
}

// 优化的写法
class MyClass {
    private ExpensiveObject expensiveObject;

    public ExpensiveObject getExpensiveObject() {
        if (expensiveObject == null) {
            expensiveObject = new ExpensiveObject();
        }
        return expensiveObject;
    }
}

37. 使用异步IO:

// 不优化的写法
InputStream inputStream = new FileInputStream("file.txt");
// 读取文件操作,可能会阻塞线程

// 优化的写法
AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get("file.txt"));
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        // 异步读取完成后的处理逻辑
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        // 处理读取失败的逻辑
    }
});

38. 使用位集(BitSet)进行位操作:

// 不优化的写法
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);

// 优化的写法
BitSet bitSet = new BitSet();
bitSet.set(1);
bitSet.set(2);

39. 使用List.contains检查集合中是否存在元素:

// 不优化的写法
List<String> myList = Arrays.asList("Apple", "Banana", "Orange");
if (myList.indexOf("Banana") != -1) {
    // 处理逻辑
}

// 优化的写法
List<String> myList = Arrays.asList("Apple", "Banana", "Orange");
if (myList.contains("Banana")) {
    // 处理逻辑
}

40. 使用Files.exists检查文件是否存在:

// 不优化的写法
File file = new File("lfsun.txt");
if (file.exists()) {
    // 处理逻辑
}

// 优化的写法
Path path = Paths.get("lfsun.txt");
if (Files.exists(path)) {
    // 处理逻辑
}

41. 使用Math.min和Math.max获取两个数的最小和最大值:

// 不优化的写法
int a = 5;
int b = 10;
int minValue = (a < b) ? a : b;
int maxValue = (a > b) ? a : b;

// 优化的写法
int a = 5;
int b = 10;
int minValue = Math.min(a, b);
int maxValue = Math.max(a, b);

42. 使用File.separator构建跨平台的文件路径:

// 不优化的写法
String path = "dir\file.txt";

// 优化的写法
String path = "dir" + File.separator + "file.txt";

43. 使用String.trim去除字符串两端的空格:

// 不优化的写法
String text = "   Hello, World!   ";
String trimmedText = text.replaceAll("^\s+|\s+$", "");

// 优化的写法
String text = "   Hello, World!   ";
String trimmedText = text.trim();

44. 使用String.startsWith和String.endsWith检查字符串前缀和后缀:

// 不优化的写法
String text = "Hello, World!";
if (text.indexOf("Hello") == 0) {
    // 处理逻辑
}

// 优化的写法
String text = "Hello, World!";
if (text.startsWith("Hello")) {
    // 处理逻辑
}

45. 使用LocalDateTime和DateTimeFormatter进行日期时间格式化:

// 不优化的写法
Date currentDate = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = sdf.format(currentDate);

// 优化的写法
LocalDateTime currentDateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = currentDateTime.format(formatter);

46. 使用String.substring截取子字符串:

// 不优化的写法
String text = "Hello, World";
String substring = text.substring(7, 12);

// 优化的写法
String text = "Hello, World";
String substring = text.substring(7);

47. 使用ThreadLocal减少线程间共享变量:

// 不优化的写法
class SharedResource {
    private int value;
    // ...
}

// 优化的写法
class SharedResource {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    // ...
}

48. 使用可变参数改善方法的灵活性:

// 不优化的写法
void process(int arg1, int arg2, int arg3) {
    // 处理逻辑
}

// 优化的写法
void process(int... args) {
    // 处理逻辑
}

49. 使用条件运算符(三元运算符)简化代码:

// 不优化的写法
int result;
if (condition) {
    result = 1;
} else {
    result = 2;
}

// 优化的写法
int result = condition ? 1 : 2;

50. 使用内部类减少包级别的类可见性:

// 不优化的写法
package com.lfsun;

class InternalClass {
    // 内部类
}

// 优化的写法
package com.lfsun;

public class OuterClass {
    private class InternalClass {
        // 内部类
    }
}

51. 使用Arrays.fill填充数组元素:

// 不优化的写法
int[] array = new int[5];
for (int i = 0; i < array.length; i++) {
    array[i] = 42;
}

// 优化的写法
int[] array = new int[5];
Arrays.fill(array, 42);

52. 使用System.arraycopy复制数组:

// 不优化的写法
int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];
for (int i = 0; i < sourceArray.length; i++) {
    targetArray[i] = sourceArray[i];
}

// 优化的写法
int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];
System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);

使用 System.arraycopy 复制数组是一种更为高效的方式,相较于手动使用循环遍历的方式,它具有以下优势:

  1. 性能优化: System.arraycopy 是由底层系统实现的本地方法,通常比手动的循环更为高效。这是因为底层系统可以针对具体的平台和硬件进行优化。
  2. 原子性: System.arraycopy 是原子性的操作,意味着在数组复制的整个过程中,不会被其他线程中断,确保了复制的一致性。
  3. 简洁性: 使用 System.arraycopy 代码更为简洁,不需要手动编写循环,提高了代码的可读性和可维护性。

53. 使用List.subList获取子列表:

// 不优化的写法
List<String> list = Arrays.asList("A", "B", "C", "D", "E");
List<String> sublist = new ArrayList<>(list.subList(1, 4));

// 优化的写法
List<String> list = Arrays.asList("A", "B", "C", "D", "E");
List<String> sublist = list.subList(1, 4);

54. 使用Optional类避免空指针异常:

// 不优化的写法
String name = // 获取可能为null的值
if (name != null) {
    System.out.println(name.length());
}

// 优化的写法
Optional<String> optionalName = Optional.ofNullable(name);
optionalName.ifPresent(n -> System.out.println(n.length()));

55. 使用ConcurrentHashMap提高并发性能:

// 不优化的写法
Map<String, Integer> myMap = new HashMap<>();
myMap.put("one", 1);

// 优化的写法
Map<String, Integer> myMap = new ConcurrentHashMap<>();
myMap.put("one", 1);

56. 使用Optional.orElseThrow替代自定义异常处理:

// 不优化的写法
Optional<String> value = Optional.ofNullable(getValue());
if (value.isPresent()) {
    return value.get();
} else {
    throw new CustomException("Value not found");
}

// 优化的写法
return Optional.ofNullable(getValue())
               .orElseThrow(() -> new CustomException("Value not found"));

57. 使用方法引用简化代码:

// 不优化的写法
list.forEach(item -> System.out.println(item));

// 优化的写法
list.forEach(System.out::println);

58. 使用ThreadLocalRandom获取随机数:

// 不优化的写法
Random random = new Random();
int randomNumber = random.nextInt(100);

// 优化的写法
int randomNumber = ThreadLocalRandom.current().nextInt(100);

59. 使用Set接口的contains方法进行集合成员检查:

// 不优化的写法
List<String> list = Arrays.asList("Apple", "Banana", "Orange");
if (list.contains("Banana")) {
    // 处理逻辑
}

// 优化的写法
Set<String> set = new HashSet<>(Arrays.asList("Apple", "Banana", "Orange"));
if (set.contains("Banana")) {
    // 处理逻辑
}

60. 使用反射和动态代理提高代码灵活性:

// 不优化的写法
if (obj instanceof MyClass) {
    ((MyClass) obj).doSomething();
}

// 优化的写法
Method method = obj.getClass().getMethod("doSomething");
method.invoke(obj);

61. 使用默认方法接口提供默认实现

// 不优化的写法
interface MyInterface {
    void doSomething();
}

class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        // 具体实现
    }
}

// 优化的写法
interface MyInterface {
    void doSomething();

    default void doSomethingElse() {
        // 默认实现
    }
}

class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        // 具体实现
    }
}

62. 使用新的日期和时间API:

// 不优化的写法
Date date = new Date();
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int year = calendar.get(Calendar.YEAR);

// 优化的写法
LocalDate currentDate = LocalDate.now();
int year = currentDate.getYear();

63. 使用Lambda表达式简化事件处理:

// 不优化的写法
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // 处理事件
    }
});

// 优化的写法
button.addActionListener(e -> {
    // 处理事件
});

64. 使用Files.newBufferedWriter写入文本文件:


// 不优化的写法
try (PrintWriter writer = new PrintWriter(new FileWriter("file.txt"))) {
    writer.println("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

// 优化的写法
try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("file.txt"))) {
    writer.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

65. 使用静态工厂方法代替构造函数:


// 不优化的写法
MyObject obj = new MyObject();

// 优化的写法
MyObject obj = MyObject.create();

66. 避免在循环中创建匿名内部类:


// 不优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(new Consumer<String>() {
    @Override
    public void accept(String name) {
        // 处理逻辑
    }
});

// 优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> {
    // 处理逻辑
});

67. 使用局部变量类型推断(var):


// 不优化的写法
Map<String, List<String>> myMap = new HashMap<String, List<String>>();

// 优化的写法
var myMap = new HashMap<String, List<String>>();

68. 使用线程池提高线程利用率:

// 不优化的写法
Thread thread = new Thread(() -> {
    // 线程执行的任务
});
thread.start();

// 优化的写法
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
    // 线程执行的任务
});

69. 使用ClassLoader延迟加载类:

// 不优化的写法
Class<?> myClass = Class.forName("com.lfsun.MyClass");
MyClass instance = (MyClass) myClass.newInstance();

// 优化的写法
Class<?> myClass = ClassLoader.getSystemClassLoader().loadClass("com.lfsun.MyClass");
MyClass instance = (MyClass) myClass.getDeclaredConstructor().new

70. 使用Stream.distinct去除重复元素:

// 不优化的写法
List<String> myList = Arrays.asList("Apple", "Banana", "Apple", "Orange");
List<String> distinctList = new ArrayList<>(new HashSet<>(myList));

// 优化的写法
List<String> myList = Arrays.asList("Apple", "Banana", "Apple", "Orange");
List<String> distinctList = myList.stream().distinct().collect(Collectors.toList());

71. 使用String.format代替字符串连接:

// 不优化的写法
String result = "Hello, " + name + "!";

// 优化的写法
String result = String.format("Hello, %s!", name);

72. 使用IntStream和DoubleStream代替传统的循环:

// 不优化的写法
int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}

// 优化的写法
int sum = IntStream.rangeClosed(1, 100).sum();

73. 使用Atomic类提高原子性操作:

// 不优化的写法
int counter = 0;
counter++;

// 优化的写法
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();

74. 使用StringJoiner拼接字符串:

// 不优化的写法
String result = "";
for (String s : list) {
    result += s + ", ";
}
result = result.substring(0, result.length() - 2);

// 优化的写法
StringJoiner joiner = new StringJoiner(", ");
for (String s : list) {
    joiner.add(s);
}
String result = joiner.toString();

75. 使用Arrays.copyOfRange代替手动数组复制:

// 不优化的写法
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[source.length];
System.arraycopy(source, 0, destination, 0, source.length);

// 优化的写法
int[] source = {1, 2, 3, 4, 5};
int[] destination = Arrays.copyOfRange(source, 0, source.length);

76. 使用Thread.join等待线程结束:

// 不优化的写法
Thread thread = new Thread(() -> {
    // 线程执行逻辑
});
thread.start();
// 等待线程结束
try {
    thread.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

// 优化的写法
Thread thread = new Thread(() -> {
    // 线程执行逻辑
});
thread.start();
// 等待线程结束
thread.join();

77. 使用Files.lines读取文件内容:

// 不优化的写法
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // 处理每行内容
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 优化的写法
try {
    Files.lines(Paths.get("file.txt")).forEach(line -> {
        // 处理每行内容
    });
} catch (IOException e) {
    e.printStackTrace();
}

78. 使用ReentrantLock进行显式的锁定:

// 不优化的写法
synchronized (myObject) {
    // 临界区
}

// 优化的写法
ReentrantLock lock = new ReentrantLock();
try {
    lock.lock();
    // 临界区
} finally {
    lock.unlock();
}

79. 使用Map.compute方法简化Map操作:


// 不优化的写法
Map<String, Integer> map = new HashMap<>();
String key = "myKey";
if (map.containsKey(key)) {
    map.put(key, map.get(key) + 1);
} else {
    map.put(key, 1);
}

// 优化的写法
map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);

80. 使用Objects.requireNonNull检查参数合法性:


// 不优化的写法
public void process(String data) {
    if (data == null) {
        throw new IllegalArgumentException("Data cannot be null");
    }
    // 处理逻辑
}

// 优化的写法
public void process(String data) {
    Objects.requireNonNull(data, "Data cannot be null");
    // 处理逻辑
}

81. 使用Files.walk遍历文件目录:


// 不优化的写法
File folder = new File("/folder");
for (File file : folder.listFiles()) {
    // 处理文件
}

// 优化的写法
Path folder = Paths.get("/folder");
try (Stream<Path> paths = Files.walk(folder)) {
    paths.forEach(path -> {
        // 处理文件
    });
} catch (IOException e) {
    e.printStackTrace();
}

82. 使用List的replaceAll方法更新所有元素:

// 不优化的写法
List<String> list = Arrays.asList("apple", "banana", "orange");
for (int i = 0; i < list.size(); i++) {
    list.set(i, list.get(i).toUpperCase());
}

// 优化的写法
List<String> list = Arrays.asList("apple", "banana", "orange");
list.replaceAll(String::toUpperCase);

83. 使用CopyOnWriteArrayList提高并发性能:

// 不优化的写法
List<String> myList = new ArrayList<>();
myList.add("Apple");
myList.add("Banana");
myList.add("Orange");

// 优化的写法
List<String> myList = new CopyOnWriteArrayList<>();
myList.add("Apple");
myList.add("Banana");
myList.add("Orange");

84. 使用Map.merge简化Map操作:


// 不优化的写法
Map<String, Integer> map = new HashMap<>();
String key = "myKey";
if (map.containsKey(key)) {
    map.put(key, map.get(key) + 1);
} else {
    map.put(key, 1);
}

// 优化的写法
map.merge(key, 1, Integer::sum);

85. 使用Lambda表达式和Collectors进行集合操作:


// 不优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> uppercaseNames = new ArrayList<>();
for (String name : names) {
    uppercaseNames.add(name.toUpperCase());
}

// 优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> uppercaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

86. 使用Optional解决嵌套的null检查:


// 不优化的写法
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        String city = address.getCity();
        if (city != null) {
            // 处理城市信息
        }
    }
}

// 优化的写法
Optional.ofNullable(user)
        .map(User::getAddress)
        .map(Address::getCity)
        .ifPresent(city -> {
            // 处理城市信息
        });

87. 使用java.time.Duration和Instant计算时间差:


// 不优化的写法
long startTime = System.currentTimeMillis();
// 执行一些操作
long endTime = System.currentTimeMillis();
long elapsedTime = endTime - startTime;

// 优化的写法
Instant start = Instant.now();
// 执行一些操作
Instant end = Instant.now();
Duration elapsedTime = Duration.between(start, end);

88. 使用java.nio.file.Path代替字符串操作路径:


// 不优化的写法
String filePath = "/file.txt";
File file = new File(filePath);

// 优化的写法
Path filePath = Paths.get("/file.txt");

89. 使用String.isBlank判断字符串是否为空或只包含空白字符:


// 不优化的写法
if (str != null && !str.trim().isEmpty()) {
    // 处理非空字符串逻辑
}

// 优化的写法
if (str != null && !str.isBlank()) {
    // 处理非空字符串逻辑
}

90. 使用Map.computeIfAbsent进行延迟初始化:

// 不优化的写法
Map<String, List<String>> map = new HashMap<>();
if (!map.containsKey("key")) {
    map.put("key", new ArrayList<>());
}
map.get("key").add("value");

// 优化的写法
Map<String, List<String>> map = new HashMap<>();
map.computeIfAbsent("key", k -> new ArrayList<>()).add("value");

91. 使用Objects.equals避免空指针异常:


// 不优化的写法
boolean isEqual = (obj1 != null) ? obj1.equals(obj2) : (obj2 == null);

// 优化的写法
boolean isEqual = Objects.equals(obj1, obj2);

92. 使用Math.floorDiv和Math.floorMod代替传统除法和取模运算:


// 不优化的写法
int quotient = a / b;
int remainder = a % b;

// 优化的写法
int quotient = Math.floorDiv(a, b);
int remainder = Math.floorMod(a, b);

93. 使用ClassLoader.getSystemResourceAsStream加载类路径下的资源文件:


// 不优化的写法
InputStream stream = getClass().getClassLoader().getResourceAsStream("config.properties");

// 优化的写法
InputStream stream = ClassLoader.getSystemResourceAsStream("config.properties");

使用 ClassLoader.getSystemResourceAsStream 加载类路径下的资源文件是一种更为推荐的做法,相较于 getClass().getClassLoader().getResourceAsStream,它具有以下优势:

  1. 更简洁: ClassLoader.getSystemResourceAsStream 的调用更为简洁,不需要通过获取类加载器再获取资源流。
  2. 避免空指针异常: ClassLoader.getSystemResourceAsStream 不会返回 null,而是会抛出 NullPointerException,这有助于在资源不存在时更早地发现问题。
  3. 全局资源访问: ClassLoader.getSystemResourceAsStream 使用系统类加载器,可以用于访问应用程序类路径下的资源,而不仅限于当前类的类路径。

94. 使用String.repeat重复字符串:

// 不优化的写法
String repeated = "";
for (int i = 0; i < n; i++) {
    repeated += "abc";
}

// 优化的写法
String repeated = "abc".repeat(n);

95. 使用List.copyOf创建不可变集合:


// 不优化的写法
List<String> originalList = Arrays.asList("a", "b", "c");
List<String> immutableList = Collections.unmodifiableList(new ArrayList<>(originalList));

// 优化的写法
List<String> immutableList = List.copyOf(originalList);

96. 使用Stream的anyMatch和noneMatch简化集合元素匹配:


// 不优化的写法
boolean contains = false;
for (String element : list) {
    if (element.equals("target")) {
        contains = true;
        break;
    }
}

// 优化的写法
boolean contains = list.stream().anyMatch(element -> element.equals("target"));

97. 使用File.toPath将File对象转换为Path对象:


// 不优化的写法
File file = new File("lfsun.txt");
Path path = file.toPath();

// 优化的写法
Path path = Paths.get("lfsun.txt");

98. 使用FileSystems.getDefault获取默认文件系统:


// 不优化的写法
Path path = Paths.get("lfsun.txt");

// 优化的写法
Path path = FileSystems.getDefault().getPath("lfsun.txt");

使用 FileSystems.getDefault().getPath 获取默认文件系统的路径是一种更为推荐的做法,相较于 Paths.get,它具有以下优势:

  1. 更灵活: FileSystems.getDefault().getPath 可以提供更多的灵活性,允许在获取路径时指定文件系统的一些属性。例如,可以使用不同的文件系统,提供自定义的文件系统属性等。
  2. 统一风格: 使用 FileSystems.getDefault().getPath 统一了获取路径的方式,使得代码更具一致性。这有助于提高代码的可读性和可维护性。

99. 使用Collections.newSetFromMap创建基于Map的Set:


// 不优化的写法
Map<String, Boolean> map = new ConcurrentHashMap<>();
Set<String> set = map.keySet();

// 优化的写法
Set<String> set = Collections.newSetFromMap(new ConcurrentHashMap<>());

使用 Collections.newSetFromMap 创建基于 MapSet 是一种更为推荐的做法,相较于直接使用 map.keySet(),它具有以下优势:

  1. 线程安全性: 使用 Collections.newSetFromMap 创建的 Set 是线程安全的,底层使用的是传入的 ConcurrentMap,因此适用于多线程环境。
  2. 不可变性: 通过 Collections.newSetFromMap 创建的 Set 是不可变的,不能通过 addremove 等方法修改其内容。这有助于确保数据的一致性。
  3. 灵活性: 可以通过传入不同类型的 Map 实现,以创建不同类型的 Set。例如,可以传入 HashMapTreeMap 等。

100. 使用List.sort进行列表排序:


// 不优化的写法
List<String> list = Arrays.asList("c", "a", "b");
Collections.sort(list);

// 优化的写法
List<String> list = Arrays.asList("c", "a", "b");
list.sort(Comparator.naturalOrder());

使用 List.sort 进行列表排序是一种更为推荐的做法,相较于 Collections.sort,它具有以下优势:

  1. 更直接: list.sort() 方法是 List 接口的默认方法,使得排序操作更加直接和一致。不需要通过 Collections 类来调用排序方法。
  2. 更灵活: list.sort() 方法可以接受一个 Comparator 参数,使得排序更加灵活。通过 Comparator,可以实现自定义的排序规则,而不仅限于自然排序。
  3. 支持流式操作: list.sort() 方法可以很方便地与流式操作一起使用,如使用 ComparatorthenComparing 进行复杂排序。

101. 使用Path.resolve解析路径:


// 不优化的写法
Path path1 = Paths.get("");
Path path2 = Paths.get("file.txt");
Path fullPath = Paths.get(path1.toString(), path2.toString());

// 优化的写法
Path path1 = Paths.get("");
Path path2 = Paths.get("file.txt");
Path fullPath = path1.resolve(path2);

102. 使用Stream.collect(Collectors.joining)拼接字符串:

// 不优化的写法
List<String> words = Arrays.asList("Hello", "World", "Java");
String result = words.stream().reduce("", (s1, s2) -> s1 + s2);

// 优化的写法
List<String> words = Arrays.asList("Hello", "World", "Java");
String result = words.stream().collect(Collectors.joining());

103. 使用Pattern和Matcher进行正则表达式匹配:

// 不优化的写法
String text = "The quick brown fox";
boolean containsFox = text.matches(".*fox.*");

// 优化的写法
Pattern pattern = Pattern.compile(".*fox.*");
Matcher matcher = pattern.matcher("The quick brown fox");
boolean containsFox = matcher.matches();

104. 使用Files.isRegularFile检查文件是否为普通文件:


// 不优化的写法
Path path = Paths.get("file.txt");
if (Files.exists(path) && Files.isRegularFile(path)) {
    // 处理文件逻辑
}

// 优化的写法
Path path = Paths.get("file.txt");
if (Files.isRegularFile(path)) {
    // 处理文件逻辑
}

105. 使用Optional避免空指针异常:

// 不优化的写法
String result = null;
if (value != null) {
    result = value.toString();
}

// 优化的写法
String result = Optional.ofNullable(value)
                        .map(Object::toString)
                        .orElse(null);

106. 使用Lambda表达式简化Comparator的创建:

// 不优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.sort(new Comparator<String>() {
    @Override
    public int compare(String name1, String name2) {
        return name1.compareTo(name2);
    }
});

// 优化的写法
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.sort((name1, name2) -> name1.compareTo(name2));

107. 使用Optional.map和Optional.filter链式操作:

// 不优化的写法
Optional<String> result = Optional.ofNullable(getValue());
if (result.isPresent()) {
    String uppercased = result.get().toUpperCase();
    if (uppercased.length() > 5) {
        System.out.println(uppercased);
    }
}

// 优化的写法
Optional.ofNullable(getValue())
        .map(String::toUpperCase)
        .filter(s -> s.length() > 5)
        .ifPresent(System.out::println);

108. 使用Collectors.joining拼接字符串:

// 不优化的写法
List<String> list = Arrays.asList("Apple", "Banana", "Orange");
String result = "";
for (String item : list) {
    result += item + ", ";
}
result = result.isEmpty() ? result : result.substring(0, result.length() - 2);

// 优化的写法
List<String> list = Arrays.asList("Apple", "Banana", "Orange");
String result = list.stream().collect(Collectors.joining(", "));

109. 使用Arrays.asList创建不可变集合:

// 不优化的写法
List<String> myList = new ArrayList<>();
myList.add("Apple");
myList.add("Banana");
myList.add("Orange");
myList = Collections.unmodifiableList(myList);

// 优化的写法
List<String> myList = Arrays.asList("Apple", "Banana", "Orange");

110. 使用Comparator.comparing简化比较器的创建:

// 不优化的写法
List<Person> people = Arrays.asList(new Person("Alice", 25), new Person("Bob", 30));
people.sort(new Comparator<Person>() {
    @Override
    public int compare(Person person1, Person person2) {
        return Integer.compare(person1.getAge(), person2.getAge());
    }
});

// 优化的写法
List<Person> people = Arrays.asList(new Person("Alice", 25), new Person("Bob", 30));
people.sort(Comparator.comparing(Person::getAge));

111. 使用StringTokenizer代替String的split方法:


// 不优化的写法
String[] tokens = "apple,orange,banana".split(",");

// 优化的写法
StringTokenizer tokenizer = new StringTokenizer("apple,orange,banana", ",");
while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();
    // 处理每个token
}

使用 StringTokenizer 代替 Stringsplit 方法是一种优化的方式,尤其是在需要逐个处理分隔符分割的字符串时。StringTokenizer 提供了更多的灵活性和控制,相较于 split 方法,它具有以下优势:

  1. 逐个处理: StringTokenizer 允许逐个处理每个分隔符分割的字符串。这对于在处理每个 token 时执行特定操作的情况非常有用。
  2. 更多控制选项: StringTokenizer 允许你指定多个分隔符,并且提供了更多的控制选项,例如是否返回分隔符。
  3. 不使用正则表达式: StringTokenizer 不依赖于正则表达式,因此在某些情况下可能比 split 更快。

112. 使用Runtime.getRuntime().availableProcessors()获取处理器核心数:

int processors = Runtime.getRuntime().availableProcessors();

113. 使用Arrays.copyOf代替手动数组复制:


// 不优化的写法
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[source.length];
System.arraycopy(source, 0, destination, 0, source.length);

// 优化的写法
int[] source = {1, 2, 3, 4, 5};
int[] destination = Arrays.copyOf(source, source.length);

114. 使用LinkedHashMap保持插入顺序:


// 不优化的写法
Map<String, Integer> map = new HashMap<>();
map.put("one", 1);
map.put("three", 3);
map.put("two", 2);

// 优化的写法
Map<String, Integer> map = new LinkedHashMap<>();
map.put("one", 1);
map.put("three", 3);
map.put("two", 2);

115. 使用System.arraycopy进行数组复制:


// 不优化的写法
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[source.length];
for (int i = 0; i < source.length; i++) {
    destination[i] = source[i];
}

// 优化的写法
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[source.length];
System.arraycopy(source, 0, destination, 0, source.length);

116. 使用Files.newInputStream和Files.newOutputStream操作文件流:


// 不优化的写法
InputStream inputStream = new FileInputStream("input.txt");
OutputStream outputStream = new FileOutputStream("output.txt");

// 优化的写法
InputStream inputStream = Files.newInputStream(Paths.get("input.txt"));
OutputStream outputStream = Files.newOutputStream(Paths.get("output.txt"));

使用 Files.newInputStreamFiles.newOutputStream 操作文件流是一种更为现代、灵活且推荐的方式,相较于传统的 FileInputStreamFileOutputStream,它具有以下优势:

  1. 更直观的路径处理: 使用 Paths.get("input.txt") 来构建路径更为直观和灵活,可以处理相对路径和绝对路径。
  2. 更丰富的异常处理: Files.newInputStreamFiles.newOutputStream 可以抛出更丰富的异常,使得对文件操作的错误更容易排查。
  3. 更灵活的配置选项: Files.newInputStreamFiles.newOutputStream 支持一些配置选项,例如 StandardOpenOption,可以更灵活地配置文件的打开方式。

117. 使用Files.exists判断文件是否存在:


// 不优化的写法
File file = new File("lfsun.txt");
if (file.exists()) {
    // 文件存在逻辑
}

// 优化的写法
if (Files.exists(Paths.get("lfsun.txt"))) {
    // 文件存在逻辑
}

118. 使用Files.createFile创建文件:


// 不优化的写法
File file = new File("lfsun.txt");
if (!file.exists()) {
    file.createNewFile();
}

// 优化的写法
Files.createFile(Paths.get("lfsun.txt"));

使用 Files.createFile 创建文件是一种更为现代和推荐的方式,相较于传统的 File 类的方式,它具有以下优势:

  1. 更直观的路径处理: 使用 Paths.get("lfsun.txt") 来构建路径更为直观和灵活,可以处理相对路径和绝对路径。
  2. 更丰富的异常处理: Files.createFile 可以抛出更丰富的异常,使得对文件创建的错误更容易排查。
  3. 原子性操作: Files.createFile 是一个原子性的操作,如果文件已经存在,则会抛出 FileAlreadyExistsException,避免了在检查文件存在性和创建文件之间的竞态条件。

119. 使用Files.delete删除文件:


// 不优化的写法
File file = new File("lfsun.txt");
if (file.exists()) {
    file.delete();
}

// 优化的写法
Files.deleteIfExists(Paths.get("lfsun.txt"));

120. 使用Files.walkFileTree遍历文件树:


// 不优化的写法
FileVisitor<Path> fileVisitor = new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        // 处理文件逻辑
        return FileVisitResult.CONTINUE;
    }
};

Files.walkFileTree(Paths.get("/directory"), fileVisitor);

// 优化的写法
Files.walkFileTree(Paths.get("/directory"), new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        // 处理文件逻辑
        return FileVisitResult.CONTINUE;
    }
});

121. 使用Files.createDirectory创建单级目录:


// 不优化的写法
File file = new File("/directory");
if (!file.exists()) {
    file.mkdirs();
}

// 优化的写法
Files.createDirectory(Paths.get("/directory"));

122. 使用Files.createDirectories创建多级目录:


// 不优化的写法
File file = new File("/multiple/levels");
if (!file.exists()) {
    file.mkdirs();
}

// 优化的写法
Files.createDirectories(Paths.get("/multiple/levels"));

123. 使用Files.copy复制文件:


// 不优化的写法
Path source = Paths.get("source.txt");
Path target = Paths.get("target.txt");
Files.write(target, Files.readAllBytes(source));

// 优化的写法
Path source = Paths.get("source.txt");
Path target = Paths.get("target.txt");
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

124. 使用Files.isSameFile检查两个文件是否相同:


// 不优化的写法
Path file1 = Paths.get("file1.txt");
Path file2 = Paths.get("file2.txt");
if (Files.exists(file1) && Files.exists(file2) && Files.isRegularFile(file1) && Files.isRegularFile(file2)) {
    boolean areSame = Files.isSameFile(file1, file2);
    // 处理相同文件逻辑
}

// 优化的写法
Path file1 = Paths.get("file1.txt");
Path file2 = Paths.get("file2.txt");
if (Files.isRegularFile(file1) && Files.isRegularFile(file2)) {
    boolean areSame = Files.isSameFile(file1, file2);
    // 处理相同文件逻辑
}

125. 使用Files.getLastModifiedTime获取文件最后修改时间:

Path filePath = Paths.get("file.txt");
if (Files.exists(filePath)) {
    long lastModifiedTime = Files.getLastModifiedTime(filePath).toMillis();
    // 处理最后修改时间逻辑
}

126. 使用Files.size获取文件大小:


Path filePath = Paths.get("file.txt");
if (Files.exists(filePath)) {
    long fileSize = Files.size(filePath);
    // 处理文件大小逻辑
}

127. 使用Files.readAttributes获取文件属性:

Path filePath = Paths.get("file.txt");
if (Files.exists(filePath)) {
    BasicFileAttributes attributes = Files.readAttributes(filePath, BasicFileAttributes.class);
    FileTime creationTime = attributes.creationTime();
    // 处理文件属性逻辑
}

128. 使用Files.probeContentType获取文件内容类型:

Path filePath = Paths.get("file.txt");
String contentType = Files.probeContentType(filePath);

129. 使用Files.isSymbolicLink检查文件是否为符号链接:


// 不优化的写法
Path filePath = Paths.get("file.txt");
if (Files.exists(filePath) && Files.isSymbolicLink(filePath)) {
    // 处理符号链接逻辑
}

// 优化的写法
Path filePath = Paths.get("file.txt");
if (Files.isSymbolicLink(filePath)) {
    // 处理符号链接逻辑
}

130. 使用Files.isReadable检查文件是否可读:


// 不优化的写法
Path filePath = Paths.get("file.txt");
if (Files.exists(filePath) && Files.isReadable(filePath)) {
    // 处理可读文件逻辑
}

// 优化的写法
Path filePath = Paths.get("file.txt");
if (Files.isReadable(filePath)) {
    // 处理可读文件逻辑
}

131. 使用Files.isWritable检查文件是否可写:


// 不优化的写法
Path filePath = Paths.get("file.txt");
if (Files.exists(filePath) && Files.isWritable(filePath)) {
    // 处理可写文件逻辑
}

// 优化的写法
Path filePath = Paths.get("file.txt");
if (Files.isWritable(filePath)) {
    // 处理可写文件逻辑
}

132. 使用Files.getAttribute获取文件属性:

Path filePath = Paths.get("file.txt");
if (Files.exists(filePath)) {
    Object attribute = Files.getAttribute(filePath, "basic:creationTime");
    // 处理文件属性逻辑
}

133. 使用Files.setAttribute设置文件属性:


Path filePath = Paths.get("file.txt");
if (Files.exists(filePath)) {
    Files.setAttribute(filePath, "basic:creationTime", FileTime.from(Instant.now()));
}

134. 使用Files.isExecutable检查文件是否可执行:


// 不优化的写法
Path filePath = Paths.get("script.sh");
if (Files.exists(filePath) && Files.isExecutable(filePath)) {
    // 处理可执行文件逻辑
}

// 优化的写法
Path filePath = Paths.get("script.sh");
if (Files.isExecutable(filePath)) {
    // 处理可执行文件逻辑
}

135. 使用Files.newBufferedReader读取文本文件:

try (BufferedReader reader = Files.newBufferedReader(Paths.get("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // 处理每行内容
    }
} catch (IOException e) {
    e.printStackTrace();
}

136.使用DateTimeFormatter替代SimpleDateFormat:


// 不优化的写法
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = sdf.format(new Date());

// 优化的写法
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDate = LocalDateTime.now().format(formatter);

137. 使用LocalDate和LocalTime代替Date和Calendar:

// 不优化的写法
Date currentDate = new Date();
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);

// 优化的写法
LocalDate currentDate = LocalDate.now();
int year = currentDate.getYear();

138. 使用Optional的map和flatMap进行链式操作:

// 不优化的写法
Optional<String> result = Optional.of("Hello");
if (result.isPresent()) {
    String uppercased = result.get().toUpperCase();
    Optional<String> finalResult = Optional.of(uppercased);
}

// 优化的写法
Optional<String> result = Optional.of("Hello");
Optional<String> finalResult = result.map(String::toUpperCase);

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

家用小型洗衣机哪款性价比高?内衣洗衣机品牌推荐

近日&#xff0c;国内著名的电子商务平台公布了“内衣洗衣机产业趋势”的研究报告。该报告指出&#xff0c;由于消费者对生活质量的要求越来越高&#xff0c;内衣洗衣机的行业也有了长足的发展&#xff0c;特别是在今年以来&#xff0c;内衣洗衣机的销售额同比上涨了830%&#…

ESP32 freeRTOS笔记 参数传递、任务优先级

一、四种参数传递方式 1.1 整数传递 使用 (void *) 任何类型传递参数&#xff0c;通过地址传递给任务。 #include <stdio.h> #include "sdkconfig.h" #include "freertos/FreeRTOS.h" #include "freertos/task.h"void myTask(void *pvP…

【每日一题】从二叉搜索树到更大和树

文章目录 Tag题目来源题目解读解题思路方法一&#xff1a;中序遍历的反序方法二&#xff1a;后缀数组 写在最后 Tag 【中序遍历】【二叉树】【2023-12-04】 题目来源 1038. 从二叉搜索树到更大和树 题目解读 在二叉搜索树中&#xff0c;将每一个节点的值替换成树中大于等于该…

仅 CSS 阅读进度条

为了构建一个阅读进度条&#xff0c;即显示用户向下滚动时阅读文章的进度&#xff0c;很难不考虑 JavaScript。但是&#xff0c;事实证明&#xff0c;您也可以使用纯 CSS 构建阅读进度条。 从本质上讲&#xff0c;一个名为 animation-timeline 的新实验性 CSS 属性可以让你指定…

【23-24 秋学期】NNDL 作业12 优化算法2D可视化

简要介绍图中的优化算法&#xff0c;编程实现并2D可视化 1. 被优化函数 2. 被优化函数 3. 解释不同轨迹的形成原因 分析各个算法的优缺点 REF&#xff1a;图灵社区-图书 (ituring.com.cn) 深度学习入门&#xff1a;基于Python的理论与实现 NNDL 作业11&#xff1a;优化算…

【蓝桥杯软件赛 零基础备赛20周】第5周——高精度大数运算与队列

文章目录 1. 数组的应用–高精度大数运算1.1 Java和Python计算大数1.2 C/C高精度计算大数1.2.1 高精度加法1.2.2 高精度减法 2. 队列2.1 手写队列2.1.1 C/C手写队列2.1.2 Java手写队列2.1.3 Python手写队列 2.2 C STL队列queue2.3 Java队列Queue2.4 Python队列Queue和deque2.5 …

HostHunter虚拟主机发现

HostHunter虚拟主机发现 1.HostHunter2.安装3.参数解释4.实例1.HostHunter HostHunter 一种工具,用于有效发现和提取提供大量目标 IPv4 或 IPv6 地址的主机名。HostHunter 利用简单的 OSINT 和主动协调技术将 IP 目标与虚拟主机名进行映射。这对于发现组织的真正攻击面特别有…

12、pytest上下文友好的输出

官方实例 # content of test_assert2.py import pytestdef test_set_comparison():set1 set("1308")set2 set("8035")assert set1 set2def test_dict_comparison():dict_1 {name:陈畅,sex:男}dict_2 {name:赵宁,sex:女}assert dict_1 dict_2def tes…

YoloV5改进策略:Swift Parameter-free Attention,无参注意力机制,超分模型的完美迁移

摘要 https://arxiv.org/pdf/2311.12770.pdf https://github.com/hongyuanyu/SPAN SPAN是一种超分网络模型。SPAN模型通过使用参数自由的注意力机制来提高SISR的性能。这种注意力机制能够增强重要信息并减少冗余,从而在图像超分辨率过程中提高图像质量。 具体来说,SPAN模…

VSCode Vue 开发环境配置

Vue是前端开发中的重要工具与框架&#xff0c;可以保住开发者高效构建用户界面。 Vue2官方文档&#xff1a;https://v2.cn.vuejs.org/ Vue3官方文档&#xff1a;https://cn.vuejs.org/ Vue的安装和引用 Vue2的官方安装指南&#xff1a;https://v2.cn.vuejs.org/v2/guide/ins…

clip-path,css裁剪函数

https://www.cnblogs.com/dzyany/p/13985939.html clip-path - CSS&#xff1a;层叠样式表 | MDN 我们看下这个例子 polygon里有四个值分别代表这四个点相对于原图左上方的偏移量。 裁剪个五角星

C语言碎片知识

sizeof 1.sizeof是C语言中的一个操作符&#xff0c;同时也是关键字&#xff01;&#xff01;&#xff01;&#xff01; 2.sizeof的操作数可以是类型&#xff0c;变量或表达式 如图&#xff0c;第一个为什么是6&#xff1f;&#xff0c;因为先计算了3的大小&#xff0c;占4个字…

陀螺仪LSM6DSV16X与AI集成(2)----姿态解算

陀螺仪LSM6DSV16X与AI集成.2--姿态解算 概述视频教学样品申请完整代码下载欧拉角万向节死锁四元数法姿态解算双环PI控制器偏航角陀螺仪解析代码上位机通讯加速度演示陀螺仪工作方式主程序演示 概述 LSM6DSV16X包含三轴陀螺仪与三轴加速度计。 姿态有多种数学表示方式&#xff…

数据结构-栈和队列

文章目录 栈什么是栈栈的操作栈的特点栈的实现栈的时间复杂度栈的应用 队列队列的概念队列的操作队列的实现队列的时间复杂度 栈 什么是栈 堆栈又名栈&#xff08;stack&#xff09;&#xff0c;它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。 栈的操作…

一键式紧急报警柱系统

随着科技的不断发展&#xff0c;一键式紧急报警柱在我们的生活和工作中扮演着越来越重要的角色。在这篇文章中&#xff0c;我们将一起探究与一键式紧急报警柱有关的知识。 一键式紧急报警柱是一种常见的安全防护设备&#xff0c;能够在紧急情况下快速发出警报&#xff0c;保护…

剑指 Offer(第2版)面试题 16:数值的整数次方

剑指 Offer&#xff08;第2版&#xff09;面试题 16&#xff1a;数值的整数次方 剑指 Offer&#xff08;第2版&#xff09;面试题 16&#xff1a;数值的整数次方解法1&#xff1a;快速幂 - 递归写法解法2&#xff1a;快速幂 - 非递归写法 剑指 Offer&#xff08;第2版&#xff…

JAVA-作业7-画一个笑脸

要求如题 代码如下&#xff1a; SmileFace01: import java.awt.Color; import java.awt.Graphics;import javax.swing.JPanel;public class SmileFace01 extends JPanel {Overrideprotected void paintComponent(Graphics g) {super.paintComponent(g);int width getWidth(…

【算法】算法题-20231205

这里写目录标题 一、LCS 01. 下载插件二、已知一个由数字组成的列表&#xff0c;请将列表中的所有0移到右侧三、实现一个trim()函数&#xff0c;去除字符串首尾的空格&#xff08;不能使用strip()方法&#xff09; 一、LCS 01. 下载插件 简单 小扣打算给自己的 VS code 安装使…

【C++】树型结构关联式容器:map/multimap/set/multisetの使用指南(27)

前言 大家好吖&#xff0c;欢迎来到 YY 滴C系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过C的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; 目录 一.键值对二.关联式容器&#xff06;序列…

canvas绘制小丑

说明&#xff1a; 借鉴博主基于canvas绘制一个爱心(10行代码就够了) - 掘金 (juejin.cn) 代码实现 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content&quo…
最新文章