实用小知识点

xiao_wei_666

已于 2023-06-08 14:33:44 修改

阅读量429

点赞数

文章标签： java jvm servlet

于 2023-06-02 21:08:23 首次发布

本文链接：https://blog.csdn.net/xiao_wei_666/article/details/131003515

版权

1 封装一周的开始时间和结束时间

2 getOrDefault() 方法使用

3 stream流中 map() 和 collect() 方法

4 @PostConstruct @PreDestroy注解使用方法

5 StringBuilder和StringBuffer类

1 封装一周的开始时间和结束时间

可以将这两个方法封装在一个工具类中，例如DateUtil，具体实现如下:

import java.time.LocalDate;
import java.time.LocalDateTime;

public class DateUtil {
    /**
     * 获取本周开始时间，即本周一 00:00:00
     *
     * @param now 当前日期
     * @return 本周开始时间
     */
    public static LocalDateTime getWeekBeginTime(LocalDateTime now) {
        int daysBefore = now.getDayOfWeek().getValue() - 1;
        return now.minusDays(daysBefore).toLocalDate().atStartOfDay();
    }

    /**
     * 获取本周结束时间，即本周日 23:59:59
     *
     * @param now 当前日期
     * @return 本周结束时间
     */
    public static LocalDateTime getWeekEndTime(LocalDateTime now) {
        int daysAfter = 7 - now.getDayOfWeek().getValue();
        return now.plusDays(daysAfter).toLocalDate().atStartOfDay().plusHours(23).plusMinutes(59).plusSeconds(59);
    }
}
    /*
    now.plusDays(daysAfter)：计算出离当前日期 now 的本周日有多少天 (daysAfter)，然后加上这个                    
    天数得到本周日的日期时间。

    toLocalDate()：将日期时间转换为本地日期。

    atStartOfDay()：将日期转换为当天的开始时间，即00:00:00。

    plusHours(23).plusMinutes(59).plusSeconds(59)：在当天的开始时间基础上，加上23小时59分                    
     钟59秒，得到当天的结束时间，即23:59:59。

    综合起来，以上几个方法的调用就表示将当前日期 now 加上距离本周日还有多少天 daysAfter，得到 
    本周日的日期时间，然后将日期转换为本地日期，并设置为当天的开始时间，最后再加上23小时59分钟 
    59秒，得到当天的结束时间，即本周的结束时间。
    */

LocalDateTime now = LocalDateTime.now();
LocalDateTime weekBeginTime = DateUtil.getWeekBeginTime(now); // 本周开始时间
LocalDateTime weekEndTime = DateUtil.getWeekEndTime(now);   // 本周结束时间

2 getOrDefault() 方法使用

getOrDefault() 是 Map 接口中定义的一个方法，用于获取指定键对应的值。如果该键不存在，则返回默认值。

getOrDefault(Object key, V defaultValue) 方法接收两个参数：

key：要获取值的键。

defaultValue：默认值。当该键不存在时，将返回该默认值。

getOrDefault() 方法的作用是，当 Map 中存在指定键时，返回该键对应的值；否则返回指定的默认值。

下面是一个使用 getOrDefault() 方法的示例：

Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);

// 获取 "apple" 对应的值
Integer appleCount = map.getOrDefault("apple", 0); // 返回 1

// 获取 "orange" 对应的值
Integer orangeCount = map.getOrDefault("orange", 0); // 返回 0

在上述代码中，我们定义了一个 Map 对象 map，并向其中添加了两个键值对："apple" 对应的值为 1，"banana" 对应的值为 2。

接着，我们分别使用 getOrDefault() 方法获取了 "apple" 和 "orange" 对应的值。由于 "apple" 存在于 map 中，因此返回 1；而 "orange" 不存在于 map 中，因此返回 0（即指定的默认值）。

总之，getOrDefault() 方法为 Map 提供了一种方便的方式，用于获取指定键对应的值，并在键不存在时返回默认值。

3 stream流中 `map()` 和 `collect()` 方法

map() 方法是 Stream 中的一种中间操作方法，用于将集合中的元素进行转换并生成一个新的 Stream。具体来说，map() 方法接收一个函数式接口作为参数，该函数式接口用于对集合中的每个元素进行转换，转换后的结果会构成一个新的 Stream 对象。

以下是 map() 方法的基本用法示例：

List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> stream = list.stream().map(s -> s.toUpperCase());

上面先定义了一个字符串列表 list，包含了三个元素："apple"、"banana"、"orange"。接着，通过 list.stream() 方法将其转换为一个 Stream 对象。然后，通过 map() 方法将 Stream 中的所有字符串转换成大写字母，并返回一个新的 Stream 对象。

需要注意的是，map() 方法不会改变原集合的元素，而是返回一个新的 Stream 对象。

collect() 方法也是 Stream 中的一种终止操作方法，用于将 Stream 中的元素收集到一个容器中，例如 List、Set、Map 等。

除了将元素收集到容器中之外，collect() 方法还可以对收集后的结果进行操作和处理，例如去重、排序、计数等。

以下是 collect() 方法的基本用法示例：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> resultList = list.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());

上面先定义了一个字符串列表 list，包含了三个元素："apple"、"banana"、"orange"。接着，通过 list.stream() 方法将其转换为一个 Stream 对象。然后，通过 map() 方法将 Stream 中的所有字符串转换成大写字母，并通过 Collectors.toList() 方法将所有元素收集到一个新的 List 对象 resultList 中。

需要注意的是，collect() 方法不会改变原集合或 Stream 中的元素，而是将其收集到一个新的容器中。同时，collect() 方法还可以接收一个 Collector 参数，该参数用于对收集后的结果进行进一步处理和操作，例如去重、排序、计数等。

4 `@PostConstruct` `@PreDestroy注解使用方法`

@PostConstruct 用来标记一个方法，在该类被实例化并且所有依赖关系被注入后自动调用该方法。该注解被放置在需要调用初始化方法的方法上，通常是一个无参数的方法。该方法可以用来进行一些初始化操作，如建立数据库连接、加载配置文件等。Spring 容器对使用了 @PostConstruct 注解的方法进行封装，以确保这个方法在其他依赖注入完成后被调用。例如：

java
public class MyClass {
    @PostConstruct
    public void init() {
        // 初始化操作
    }
}

在上面的示例中，当 MyClass 被实例化并且所有依赖注入完成之后，Spring 容器会自动调用 init() 方法来执行初始化操作。

@PreDestroy 注解可以用来标记一个方法，在 Bean 销毁之前自动调用该方法。该注解被放置在需要调用销毁方法的方法上，通常是一个无参数的方法。这个方法可以用来进行一些清理操作，例如关闭数据库连接、停止线程等。Spring 容器对使用了 @PreDestroy 注解的方法进行封装，以确保在销毁 Bean 之前该方法被调用。例如：

public class MyClass {
    @PreDestroy
    public void destroy() {
        // 清理操作
    }
}

在上面的示例中，当 MyClass Bean 销毁之前，Spring 容器会自动调用 destroy() 方法来执行清理操作。

需要注意的是，@PostConstruct 和 @PreDestroy 注解只能应用于 Bean 的方法上，而不能应用于字段上、构造函数上或其他地方。同时，这两个注解在使用时需要导入相应的依赖包，例如：


<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

@PostConstruct 和 @PreDestroy 注解是 JavaEE 规范中提供的两个注解，用于标记需要被 Spring 容器封装的初始化方法和销毁方法。这两个注解可以用于进行各种初始化和清理操作，从而确保应用程序的正确运行和退出。

5 StringBuilder和StringBuffer类

在Java编程中，若要操作字符串并且频繁改变字符串内容，建议使用StringBuilder或StringBuffer类，而不直接使用String类型。

String类型是不可变的（immutable），也就是说，一旦一个String对象被创建后，其值就不能再次修改。因此，每当对String类型进行修改时，都会创建一个新的对象来存储修改后的内容，这对内存和性能造成了很大的影响。而StringBuilder和StringBuffer类则可以动态地修改字符串，避免了反复创建新的对象。所以在循环中执行字符串拼接操作会产生大量临时对象，增加了垃圾回收压力和性能开销。为了避免这种情况，我们可以使用 StringBuilder 类来优化字符串拼接操作。

StringBuilder和StringBuffer类的实现非常相似，都提供了append()、insert()等方法来进行字符串的拼接和插入操作。唯一的区别在于，StringBuffer是线程安全的，而StringBuilder是非线程安全的。如果在多线程环境下进行操作，应该使用StringBuffer；否则，应该使用StringBuilder。

5.1 append()

append() 用于将指定的字符串添加到当前 StringBuilder 对象的末尾，并返回当前对象的引用。

StringBuilder sb = new StringBuilder("Hello");
sb.append(" world");
System.out.println(sb.toString()); // "Hello world"

5.2 insert()

insert() 方法用于将指定字符串出入到当前StringBuilder对象的指定位置,并返回当前对象的引用。

StringBuilder sb = new StringBuilder("Hello world");
sb.insert(5, ", ");
System.out.println(sb.toString()); // "Hello, world"

5.3 delete()

delete() 方法用于删除从 start 开始到 end 结束（不包括 end）的字符，并返回当前对象的引用。

StringBuilder sb = new StringBuilder("Hello, world");
sb.delete(5, 7);
System.out.println(sb.toString()); // "Hello world"

5.4 reverse()

reverse() 方法用于将当前 StringBuilder 对象中的字符序列反转，并返回当前对象的引用。

StringBuilder sb = new StringBuilder("Hello, world");
sb.reverse();
System.out.println(sb.toString()); // "dlrow ,olleH"

5.5 capacity()

capacity() 方法用于获取当前 StringBuilder 对象的容量，即可以存储的最大字符数。

StringBuilder sb = new StringBuilder(16);
System.out.println(sb.capacity()); // 16

5.6 length()

length() 方法用于获取当前 StringBuilder 对象中的字符数。

StringBuilder sb = new StringBuilder("Hello, world");
System.out.println(sb.length()); // 12

5.7 charAt()

charAt() 方法用于获取当前 StringBuilder 对象中指定位置的字符。

StringBuilder sb = new StringBuilder("Hello, world");
System.out.println(sb.charAt(0)); // 'H'

6 常用的判断非空的工具类方法

判断字符串是否为空：StringUtils.isEmpty(str)，如果 str 为 null 或空字符串则返回 true，否则返回 false。
判断集合是否为空：CollectionUtils.isEmpty(coll)，如果 coll 为 null 或空集合则返回 true，否则返回 false。
判断数组是否为空：ArrayUtils.isEmpty(array)，如果 array 为 null 或空数组则返回 true，否则返回 false。
判断对象是否为 null：ObjectUtils.isNull(obj)，如果 obj 为 null 则返回 true，否则返回 false。
判断对象是否非 null：ObjectUtils.nonNull(obj)，如果 obj 非 null 则返回 true，否则返回 false。

判断非空则使用ObjectUtils.isNotEmpty(obj) 方法。该方法接收一个 Object 类型的参数，如果参数不为 null 且非空（对于字符串判断非空是指既不为 null 也不是空字符串），则返回 true；否则返回 false。例如:

java
String str = "foo";
if (ObjectUtils.isNotEmpty(str)) {
    System.out.println("str is not null and not empty");
} else {
    System.out.println("str is null or empty");
}

List<String> list = new ArrayList<>();
if (ObjectUtils.isNotEmpty(list)) {
    System.out.println("list is not null and not empty");
} else {
    System.out.println("list is null or empty");
}

在上述代码中，第一个 if 语句会输出 str is not null and not empty，因为变量 str 的值为 "foo"，即非空字符串。而第二个 if 语句会输出 list is null or empty，因为变量 list 的值为一个空列表，即既为 null 也为空集合。

xiao_wei_666

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
实用小知识点

该注解被放置在需要调用初始化方法的方法上，通常是一个无参数的方法。该注解被放置在需要调用销毁方法的方法上，通常是一个无参数的方法。方法接收一个函数式接口作为参数，该函数式接口用于对集合中的每个元素进行转换，转换后的结果会构成一个新的。，并向其中添加了两个键值对："apple" 对应的值为 1，"banana" 对应的值为 2。，包含了三个元素："apple"、"banana"、"orange"。，包含了三个元素："apple"、"banana"、"orange"。中存在指定键时，返回该键对应的值；
复制链接

扫一扫