可以提高 Java 代码开发效率的工具类（持续更新）

news2024/10/4 18:24:58

        文中并没有给出工具类所有的方法，只是抛砖引玉，提出几个比较常用的方法。

Collections

        Collections 类是 Java 中的一个工具类，它包含了一系列静态方法，用于对集合进行操作。这个类位于 java.util 包中。以下是一些常用的 Collections 类方法：

  1. 排序:

    • sort(List<?> list): 对指定的列表按自然顺序进行排序。
    • sort(List<?> list, Comparator<? super T> c): 按指定的比较器对列表进行排序。

  2. 洗牌:

    • shuffle(List<?> list): 使用默认的随机源对列表进行随机洗牌。
    • shuffle(List<?> list, Random rnd): 使用指定的随机源对列表进行随机洗牌。

  3. 反转:

    • reverse(List<?> list): 反转列表的顺序。

  4. 二分搜索:

    • binarySearch(List<? extends T> list, T key): 在自然排序的列表中进行二分查找。
    • binarySearch(List<? extends T> list, T key, Comparator<? super T> c): 在按比较器排序的列表中进行二分查找。

  5. 最大/最小值:

    • max(Collection<? extends T> coll): 返回集合中的最大元素。
    • min(Collection<? extends T> coll): 返回集合中的最小元素。

  6. 替换元素:

    • replaceAll(List<?> list, Object oldVal, Object newVal): 将列表中所有旧值替换为新值。

  7. 同步控制:

    • synchronizedList(List<T> list): 返回一个线程安全的列表。
    • synchronizedMap(Map<K,V> m): 返回一个线程安全的映射。
    • synchronizedSet(Set<T> s): 返回一个线程安全的集合。

  8. 不可变视图:

    • unmodifiableList(List<? extends T> list): 返回一个不可修改的列表视图。
    • unmodifiableMap(Map<? extends K,? extends V> m): 返回一个不可修改的映射视图。
    • unmodifiableSet(Set<? extends T> s): 返回一个不可修改的集合视图。

  9. 空集合:

    • emptyList(): 返回一个空的不可修改的列表。
    • emptyMap(): 返回一个空的不可修改的映射。
    • emptySet(): 返回一个空的不可修改的集合。

  10. 频率统计:

    • frequency(Collection<?> c, Object o): 返回指定元素在集合中出现的次数。

这些方法可以用于各种集合操作，使得集合的使用更加方便和强大。以下是一些示例代码：

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("B", "C", "A", "D", "E"));

        // 排序
        Collections.sort(list);
        System.out.println("Sorted List: " + list);

        // 洗牌
        Collections.shuffle(list);
        System.out.println("Shuffled List: " + list);

        // 反转
        Collections.reverse(list);
        System.out.println("Reversed List: " + list);

        // 二分搜索
        int index = Collections.binarySearch(list, "C");
        System.out.println("Index of 'C': " + index);

        // 最大值
        String max = Collections.max(list);
        System.out.println("Max element: " + max);

        // 替换元素
        Collections.replaceAll(list, "C", "Z");
        System.out.println("List after replacing 'C' with 'Z': " + list);

        // 同步控制
        List<String> syncList = Collections.synchronizedList(list);
        
        // 不可变视图
        List<String> unmodifiableList = Collections.unmodifiableList(new ArrayList<>(Arrays.asList("A", "B", "C")));
        System.out.println("Unmodifiable List: " + unmodifiableList);

        // 空集合
        List<String> emptyList = Collections.emptyList();
        System.out.println("Empty List: " + emptyList);

        // 频率统计
        int frequency = Collections.frequency(list, "Z");
        System.out.println("Frequency of 'Z': " + frequency);
    }
}

CollectionUtils

        对集合操作，除了前面说的 Collections工具类之后，CollectionUtils 工具类也非常常用。目前比较主流的是spring的org.springframework.util包下的CollectionUtils工具类和apache的org.apache.commons.collections包下的CollectionUtils 工具类。

        我个人更推荐使用apache的包下的CollectionUtils工具类，因为它的工具更多更全面。

以下是一些常用的 CollectionUtils 方法：

1.isEmpty 和 isNotEmpty：用于检查集合是否为空。

if (CollectionUtils.isEmpty(collection)) {
    // 集合为空的处理逻辑
}
if (CollectionUtils.isNotEmpty(collection)) {
    // 集合不为空的处理逻辑
}

2.union：获取两个集合的并集

Collection<?> unionCollection = CollectionUtils.union(collection1, collection2);

3.intersection：获取两个集合的交集。

Collection<?> intersectionCollection = CollectionUtils.intersection(collection1, collection2);

4.disjunction：获取两个集合的交集的补集

Collection<?> disjunctionCollection = CollectionUtils.disjunction(collection1, collection2);

5.subtract：获取两个集合的差集。

Collection<?> subtractCollection = CollectionUtils.subtract(collection1, collection2);

6.containsAny：判断一个集合是否包含另一个集合中的任意元素。

boolean containsAny = CollectionUtils.containsAny(collection1, collection2);

7.transform：对集合中的每个元素应用转换函数。

List<String> transformedList = CollectionUtils.transform(list, new Transformer<String, Object>() {
    public String transform(Object input) {
        return input.toString();
    }
});

8.find：查找集合中满足特定条件的第一个元素。

T foundElement = CollectionUtils.find(collection, new Predicate<T>() {
    public boolean evaluate(T item) {
        return item.equals(targetElement);
    }
});

        在使用 CollectionUtils 时，需要注意它并不是 Java 标准库的一部分，因此需要确保相应的库已经添加到项目的依赖中。例如，如果是使用 Apache Commons Collections 的 CollectionUtils，则需要添加相应的 Maven 依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

Lists

        Guava 库中的 Lists 工具类是一个非常有用的工具，它提供了很多静态方法来操作  List 对象。

        Guava 是 Google 开源的一个 Java 工具库，里面有很多工具类，这里要讲的是里面的 Lists工具类。

添加依赖

注意，使用 Guava 工具类库，必须先添加依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>28.0</version>
</dependency>

以下是一些常见的 Lists 类的使用方式：

  1. 创建新的ArrayList

    • Lists.newArrayList(): 创建一个空的 ArrayList。
    • Lists.newArrayList(E... elements): 根据给定的元素创建一个 ArrayList。
    • Lists.newArrayList(Iterable<? extends E> elements): 从 Iterable 创建一个 ArrayList。
    • Lists.newArrayList(Iterator<? extends E> elements): 从 Iterator 创建一个 ArrayList。
    • Lists.newArrayListWithCapacity(int initialArraySize): 创建一个具有指定初始容量的 ArrayList。
    • Lists.newArrayListWithExpectedSize(int estimatedSize): 创建一个预计大小的 ArrayList。

  2. 分区列表

    • Lists.partition(List list, int size): 将一个列表均匀地划分为多个子列表。

  3. 反转列表

    • Lists.reverse(List list): 反转列表的顺序。

  4. 转换列表

    • Lists.transform(List list, Function function): 对列表中的每个元素应用一个函数，并返回一个新的列表。

  5. 字符列表

    • Lists.charactersOf(String string): 将字符串转换为字符的列表。

  6. 创建不可变列表

    • Lists.asList(E first, E[] rest): 创建一个不可变的列表，包含第一个元素和数组中的元素。
    • Lists.asList(E first, E second, E[] rest): 创建一个不可变的列表，包含前两个元素和数组中的元素。

  7. 创建线程安全的列表

    • Lists.newCopyOnWriteArrayList(): 创建一个空的线程安全的 CopyOnWriteArrayList。
    • Lists.newCopyOnWriteArrayList(Iterable<? extends E> elements): 根据给定的元素创建一个线程安全的 CopyOnWriteArrayList。

  8. 创建链表

    • Lists.newLinkedList(): 创建一个空的 LinkedList。
    • Lists.newLinkedList(Iterable<? extends E> elements): 根据给定的元素创建一个 LinkedList。

  9. 列表差集

    • Lists.setDifference(List<?> list1, List<?> list2): 返回两个列表的差集。

  10. 列表子集

    • Lists.subList(List<?> list, int fromIndex, int toIndex): 返回列表的子集（注意这是 List 接口的方法，不是 Guava 特有的）。

Objects

        Java标准库中的java.util.Objects类是在Java 7中引入的，它提供了一些实用的方法来操作和比较对象。以下是一些常用的Objects类方法：

  1. equals

    • Objects.equals(Object a, Object b): 比较两个对象是否相等。这个方法是equals方法的简化形式，可以替代(a == b) || (a != null && a.equals(b))。

  2. hashCode

    • Objects.hashCode(Object o): 返回对象的hashCode值，如果对象为null，则返回0。

  3. toString

    • Objects.toString(Object o): 返回对象的String表示，如果对象为null，则返回字符串"null"。
    • Objects.toString(Object o, String nullDefault): 返回对象的String表示，如果对象为null，则返回提供的默认值。

  4. 比较

    • Objects.compare(T a, T b): 使用自然顺序比较两个对象，如果a小于b返回负数，如果a等于b返回0，如果a大于b返回正数。
    • Objects.compare(T a, T b, Comparator<? super T> cmp): 使用提供的Comparator比较两个对象。

  5. 非空检查

    • Objects.requireNonNull(Object obj): 如果对象不是null，则返回对象；如果是null，则抛出NullPointerException。
    • Objects.requireNonNull(Object obj, String message): 如果对象不是null，则返回对象；如果是null，则抛出带有自定义消息的NullPointerException。

  6. 检查元素索引

    • Objects.checkIndex(int index, int size): 检查索引是否在有效范围内，如果不在，则抛出IndexOutOfBoundsException。
    • Objects.checkFromToIndex(int fromIndex, int toIndex, int size): 检查从索引到索引的范围是否有效。

  7. 类型检查

    • Objects.requireNonNullElse(T obj, T defaultObj): 如果对象不是null，则返回对象；如果是null，则返回默认对象。
    • Objects.requireNonNullElseGet(T obj, Supplier<? extends T> defaultSupplier): 如果对象不是null，则返回对象；如果是null，则返回由供应商提供的默认对象。

  8. 组合哈希码

    • Objects.hash(Object... values): 根据一组对象计算出一个哈希码，这个哈希码可以用于hashCode方法的实现。

         java.util.Objects 类的方法通常用于简化常见的对象操作，如比较、哈希码计算和非空检查，使得代码更加简洁和易于维护。

BooleanUtils

        在java中布尔值，随处可见。如果你使用了布尔的包装类：Boolean，总感觉有点麻烦，因为它有三种值：null、true、false。我们在处理 Boolean 对象时，需要经常判空。

        头疼！！！

        但如果使用BooleanUtils类处理布尔值，心情一下子就愉悦起来了。

        Apache Commons Lang库中的BooleanUtils类提供了许多用于处理布尔值的实用方法。以下是一些常用的方法：

  1. 逻辑运算

    • and(boolean... array): 对一组布尔值进行逻辑与运算。
    • or(boolean... array): 对一组布尔值进行逻辑或运算。
    • xor(boolean... array): 对一组布尔值进行逻辑异或运算。

  2. 布尔值判断

    • isTrue(Boolean bool): 判断布尔值是否为true。
    • isFalse(Boolean bool): 判断布尔值是否为false。
    • isNotTrue(Boolean bool): 判断布尔值是否不是true（即为null或false）。
    • isNotFalse(Boolean bool): 判断布尔值是否不是false（即为null或true）。

  3. 布尔值转换

    • toBoolean(Boolean bool): 将Boolean对象转换为基本数据类型的boolean值。
    • toBooleanObject(int value): 将int值转换为Boolean对象。
    • toBooleanObject(Integer value): 将Integer对象转换为Boolean对象。

  4. 字符串转换

    • toBoolean(String str): 将字符串转换为布尔值。

  5. 整数转换

    • toInteger(boolean bool): 将布尔值转换为整数（true为1，false为0）。

  6. 字符串表示

    • toStringOnOff(boolean bool): 将布尔值转换为"on"或"off"字符串。
    • toStringTrueFalse(Boolean bool): 将布尔值转换为"true"或"false"字符串。
    • toStringYesNo(boolean bool): 将布尔值转换为"yes"或"no"字符串。

  7. 比较

    • compare(boolean x, boolean y): 比较两个布尔值并返回整数值。

  8. 默认值

    • toBooleanDefaultIfNull(Boolean bool, boolean valueIfNull): 如果布尔值为null，则返回默认值。

StringUtils

        StringUtils 是 Apache Commons Lang 库中的一个非常强大的工具类，它提供了一系列用于操作字符串的方法。以下是一些常用的 StringUtils 方法：

    • 空值检查：

      • isEmpty(String str): 检查字符串是否为空（null或空字符串）。
      • isNotEmpty(String str): 检查字符串是否非空。
      • isBlank(String str): 检查字符串是否为空或仅包含空白字符。
      • isNotBlank(String str): 检查字符串是否非空且不只包含空白字符。

    • 修剪字符串：

      • trim(String str): 去除字符串首尾的空白字符。
      • trimToEmpty(String str): 去除字符串首尾的空白字符，如果结果为null或空字符串，则返回空字符串。
      • trimToNull(String str): 去除字符串首尾的空白字符，如果结果为空字符串，则返回null。

    • 字符串转换：

      • capitalize(String str): 将字符串的第一个字符转换为大写。
      • uncapitalize(String str): 将字符串的第一个字符转换为小写。
      • upperCase(String str): 将字符串转换为大写。
      • lowerCase(String str): 将字符串转换为小写。

    • 字符串比较：

      • equals(String str1, String str2): 比较两个字符串是否相等。
      • equalsIgnoreCase(String str1, String str2): 比较两个字符串是否相等，忽略大小写。

    • 子串操作：

      • substring(String str, int start): 从指定位置开始截取子串。
      • substring(String str, int start, int end): 从指定开始位置到结束位置截取子串。

    • 字符串连接：

      • join(Iterable<?> iterable, String separator): 使用指定的分隔符将可迭代对象中的元素连接成一个字符串。

    • 字符串分割：

      • split(String str, String separator): 使用指定的分隔符将字符串分割成数组。

    • 字符串替换：

      • replace(String str, String searchString, String replacement): 替换字符串中所有出现的搜索字符串为指定的替换字符串。

    • 字符串查找：

      • indexOf(String str, CharSequence seq): 返回指定字符序列在字符串中首次出现的索引。

    • 其他：

      • deleteWhitespace(String str): 删除字符串中的所有空白字符。

Assert

        很多时候，我们需要在代码中做判断：如果不满足条件，则抛异常。有没有统一的封装呢?其实spring给我们提供了Assert类，它表示断言。

断言参数是否为空

        断言参数是否空，如果不满足条件，则直接抛异常。

String str = null;
Assert.isNull(str, "str必须为空");
Assert.notNull(str, "str不能为空");

  • 如果不满足条件就会抛出IllegalArgumentException异常。

断言集合是否为空

        断言集合是否空，如果不满足条件，则直接抛异常。

List<String> list = null;
Map<String, String> map = null;
Assert.notEmpty(list, "list不能为空");
Assert.notEmpty(map, "map不能为空");

断言条件是否为空

        断言是否满足某个条件，如果不满足条件，则直接抛异常。

List<String> list = null;
Assert.isTrue(CollectionUtils.isNotEmpty(list), "list不能为空");
Assert.isTrue(CollectionUtils.isNotEmpty(list), () -> "list不能为空");

IOUtils

        IOUtils 类是 Apache Commons IO 库中的一个工具类，它提供了一系列静态方法来简化 Java I/O 编程。以下是一些 IOUtils 类的常用方法及其详解：

        可以通过 new FileInputStream("/temp/a.txt")  和 new FileOutputStream("/temp/b.txt") 来获取输入流和输出流对象

关闭对象

closeQuietly(Closeable closeable)

  • 无条件地关闭一个可关闭的对象，即使关闭时抛出异常，也不会向外抛出。这个方法是处理资源关闭的常用方法，可以避免资源泄漏。

比较文件内容

contentEquals(InputStream input1, InputStream input2)：

  • 比较两个输入流的内容是否相同。如果两个流的内容完全一致，返回 true，否则返回 false。

拷贝文件内容

copy(InputStream input, OutputStream output)：

  • 将内容从 InputStream 复制到 OutputStream，并返回复制的字节数。这个方法内部使用了缓冲区，通常比手动循环复制效率更高。

行迭代器

lineIterator(InputStream input, String encoding)：

  • 从 InputStream 中返回一个行迭代器，可以逐行读取流中的数据。这个迭代器会持有一个打开的 InputStream 的引用，因此在使用完毕后应该关闭流以释放资源。

将数据转换为流

toInputStream(CharSequence input, String encoding)：

  • 将字符序列（如字符串）转换为 InputStream。这个操作经常用于将内存中的数据转换为流，以便进一步处理。

将流转换为数据

toString(InputStream input)

  • 将 InputStream 转换为字符串。默认使用平台的字符编码。如果需要指定编码，可以使用 toString(InputStream input, String encoding)。

将数据写入文件

write(String data, Writer output)：

  • 将字符串写入 Writer。如果 data 为 null，则不执行任何操作。

将多行文本写入文件

writeLines(Collection lines, String lineEnding, Writer output)：

  • 将字符串集合写入 Writer，每个元素占一行，并使用指定的行结尾符。这个方法常用于将多行文本写入文件。

读取行（将文件中的内容一行一行读出来）

readLines(InputStream input, String encoding)：

  • 从 InputStream 中读取行并返回字符串列表。每个流中的行都是列表中的一个元素。默认使用平台的字符编码，也可以指定编码。

读取文件中的二进制数据（图片或文件）

        toByteArray(InputStream input)

  • 从 InputStream 中读取数据并转换为字节数组。这个方法常用于读取二进制数据，如图片或文件。

读取指定长度的二进制数据

readFully(InputStream input, byte[] buffer)：

  • 从 InputStream 中读取数据并填充到字节数组中。这个方法确保读取了指定长度的数据，如果数据不足，会抛出 EOFException。

跳过输入流中的指定数量的字节

skipFully(InputStream input, long skipAmount)：

        跳过输入流中的指定数量的字节。如果跳过的字节数不足，会抛出 EOFException。

        这些方法的实现细节和使用场景各有不同，但它们共同的目标是简化 I/O 操作，提高代码的可读性和可维护性。在使用 IOUtils 类时，应该注意异常处理和资源管理，确保在操作完成后释放所有资源。

ClassUtils

        ClassUtils是 Apache Commons Lang 库中的一个工具类，它提供了一系列静态方法来操作和获取类的信息。以下是一些 ClassUtils 类的常用方法及其详解：

返回指定类的包名

getPackageName(Class<?> clazz)：

  • 返回指定类的包名。如果类位于默认包中，则返回空字符串。
  • 示例：ClassUtils.getPackageName(String.class) 返回 "java.lang"。

返回类的简单名称（不包括包名）

getSimpleName(Class<?> clazz)：

  • 返回类的简单名称（不包括包名）。
  • 示例：ClassUtils.getSimpleName(String.class) 返回 "String"。

返回类的规范化全名（包括包名和简单类名）

getShortCanonicalName(Class<?> clazz)：

  • 返回类的规范化全名（包括包名和简单类名）。
  • 示例：ClassUtils.getShortCanonicalName(String.class) 返回 "java.lang.String"。

返回类的简单名称

getShortClassName(Class<?> clazz)：

  • 返回类的简单名称，对于数组类型，会返回数组的组件类型的简单名称，后面跟上相应的维度信息。
  • 示例：ClassUtils.getShortClassName(int[].class) 返回 "int[]"。

检查类是否是 Java 基本数据类型

isPrimitive(Class<?> cls)：

  • 检查指定的类是否是 Java 基本数据类型。
  • 示例：ClassUtils.isPrimitive(int.class) 返回 true。

检查类是否是 Java 基本数据类型的包装类

isPrimitiveWrapper(Class<?> cls)：

  • 检查指定的类是否是 Java 基本数据类型的包装类。
  • 示例：ClassUtils.isPrimitiveWrapper(Integer.class) 返回 true。

检查是否可以将一个类的对象分配给另一个类的引用

isAssignable(Class<?> cls, Class<?> toClass)：

  • 检查是否可以将一个类的对象分配给另一个类的引用，考虑自动装箱和拆箱。
  • 示例：ClassUtils.isAssignable(Number.class, Integer.class) 返回 true。

检查是否可以将一个值赋给指定类型的引用

isAssignableValue(Class<?> cls, Object value)：

  • 检查是否可以将一个值赋给指定类型的引用，考虑自动装箱和拆箱。
  • 示例：ClassUtils.isAssignableValue(Number.class, 10) 返回 true。

将类名的列表转换为 Class 对象的列表

convertClassNamesToClasses(List<String> classNames)：

  • 将类名的列表转换为 Class 对象的列表。
  • 示例：ClassUtils.convertClassNamesToClasses(Arrays.asList("java.lang.Integer", "java.lang.String"))。

将 Class 对象的集合转换为类名的列表

convertClassesToClassNames(Collection<Class<?>> classes)：

  • 将 Class 对象的集合转换为类名的列表。
  • 示例：ClassUtils.convertClassesToClassNames(Arrays.asList(Integer.class, String.class))。

返回指定类的所有父类

getAllSuperclasses(Class<?> cls)：

  • 返回一个列表，包含指定类的所有父类，从最近的父类开始，不包括接口。
  • 示例：ClassUtils.getAllSuperclasses(Number.class) 返回一个列表，包括 Number 的所有父类。

返回类及其父类实现的所有接口

getAllInterfaces(Class<?> cls)：

  • 返回一个列表，包含指定类及其父类实现的所有接口。
  • 示例：ClassUtils.getAllInterfaces(List.class) 返回 List 及其父接口的列表。

检查指定的类是否是内部类

isInnerClass(Class<?> cls)：

  • 检查指定的类是否是内部类。
  • 示例：ClassUtils.isInnerClass(Map.Entry.class) 返回 true。

返回类的缩写名称

getAbbreviatedName(Class<?> cls, int abbreviateLen)：

  • 返回类的缩写名称，通常用于日志和错误消息。
  • 示例：ClassUtils.getAbbreviatedName(String.class, 5) 返回 "j.l.Str"。

        这些方法通常用于反射操作、类型检查、类名和类对象之间的转换等场景。在使用 ClassUtils 类时，应该注意异常处理和资源管理，确保在操作完成后释放所有资源。

BeanUtils

        BeanUtils 是一个用于操作 JavaBean 的工具类库，它在 org.springframework.beans 包下面，提供了一些实用的方法来简化 JavaBean 对象之间的属性复制、设置和获取等操作。

拷贝对象的属性值

        copyProperties(Object orig, Object dest): 将源对象 orig 的属性值复制到目标对象 dest 中。如果属性名相同，它会进行属性值的复制。

Person source = new Person();
source.setName("John");
source.setAge(30);
Person destination = new Person();
BeanUtils.copyProperties(source, destination);
System.out.println("Destination Name: " + destination.getName());
System.out.println("Destination Age: " + destination.getAge());

设置对象的属性值

        setProperty(Object bean, String name, Object value): 动态设置对象的属性值。如果属性存在并且可写，此方法会设置属性值。

Person person = new Person();
BeanUtils.setProperty(person, "name", "Alice");
BeanUtils.setProperty(person, "age", 25);

获取对象的属性值

        getProperty(Object bean, String name): 动态获取对象的属性值。如果属性存在并且有 getter 方法，此方法会返回属性值。

String name = BeanUtils.getProperty(person, "name");
System.out.println("Name: " + name);

浅拷贝对象

        cloneBean(Object bean): 创建并返回原始 JavaBean 的副本。这是一个浅拷贝操作，即只复制对象的引用而不复制对象本身。

Person original = new Person("Bob", 40);
Person clone = (Person) BeanUtils.cloneBean(original);
System.out.println("Original: " + original);
System.out.println("Clone: " + clone);

将 Map 数据封装到指定的 JavaBean

        populate(Object bean, Map properties): 将 Map 数据封装到指定的 JavaBean 中，一般用于将表单数据封装到 JavaBean 中。

MutablePropertyValues pvs = new MutablePropertyValues();
pvs.add("name", "John");
pvs.add("age", 30);
Person person = new Person();
BeanUtils.populate(person, pvs);
System.out.println(person.getName()); // 输出：John

返回对象的 JavaBean 属性描述符的 Map

Person person = new Person();
person.setName("John");
Map<String, PropertyDescriptor> descriptors = BeanUtils.describe(person);
for (Map.Entry<String, PropertyDescriptor> entry : descriptors.entrySet()) {
    System.out.println(entry.getKey());
}

返回类的 JavaBean 属性描述符数组

        findPropertyDescriptors(Class clazz, String... excluded): 返回指定类的 JavaBean 属性描述符数组，可以排除指定的属性描述符。

PropertyDescriptor[] descriptors = BeanUtils.findPropertyDescriptors(Person.class, "id");

判断类是否是一个简单的 JavaBean 属性类型

        isSimpleProperty(Class<?> type): 判断给定的类是否是一个简单的 JavaBean 属性类型（如基本类型、String 等）。

boolean isSimple = BeanUtils.isSimpleProperty(String.class); // 返回 true

获取指定属性描述符所描述的属性的简单类型

        getSimplePropertyType(PropertyDescriptor descriptor): 获取指定属性描述符所描述的属性的简单类型。

PropertyDescriptor descriptor = new PropertyDescriptor("name", Person.class);
Class<?> simpleType = BeanUtils.getSimplePropertyType(descriptor);
System.out.println(simpleType.getName()); // 输出：java.lang.String

获取对象的属性值

        getPropertyValue(Object bean, String name): 获取指定 Java Bean 对象的属性值。

User user = new User();
user.setName("John");
Object value = BeanUtils.getPropertyValue(user, "name");
System.out.println(value); // 输出：John

设置对象的属性值

        setPropertyValue(Object bean, String name, Object value): 设置指定 Java Bean 对象的属性值。

User user = new User();
BeanUtils.setPropertyValue(user, "name", "John");
System.out.println(user.getName()); // 输出：John

ImageIO

        ImageIO 是 Java 中 javax.imageio 包下的一个类，它提供了一个用于读取和写入图片的简单接口。ImageIO 利用了服务提供者接口（SPI）来支持多种图片格式，如 JPEG、PNG、GIF 等。

以下是 ImageIO 类的一些常用方法：

读取图片

  1. ImageIO.read(InputStream input)

    • 从输入流中读取图片。
    • 返回值：BufferedImage 对象。

  2. ImageIO.read(File input):

    • 从文件中读取图片。
    • 返回值：BufferedImage 对象。

写入图片：

  1. ImageIO.write(RenderedImage im, String formatName, OutputStream output):

    • 将 RenderedImage 对象写入输出流，可以指定图片格式。
    • formatName 参数指定图片的格式，如 "jpg"、"png"。

  2. ImageIO.write(RenderedImage im, String formatName, File output):

    • 将 RenderedImage 对象写入文件，可以指定图片格式。

获取图片格式：

  1. ImageIO.getReaderFormatFileName(String fileName):

    • 根据文件名获取图片的格式。

  2. ImageIO.getReaderMIMETypes():

    • 获取所有支持的图片格式及其 MIME 类型。

示例代码：

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            // 读取图片
            File inputfile = new File("input.jpg");
            BufferedImage image = ImageIO.read(inputfile);

            // 处理图片（这里省略了处理过程）

            // 写入图片
            File outputfile = new File("output.jpg");
            ImageIO.write(image, "jpg", outputfile);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

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

相关文章

使用前端三剑客实现一个备忘录

使用前端三剑客实现一个备忘录

一&#xff0c;界面介绍 这个备忘录的界面效果如下&#xff1a; 可以实现任务的增删&#xff0c;并且在任务被勾选后会被放到已完成的下面。 示例&#xff1a; &#xff08;1&#xff09;&#xff0c;增加一个任务 &#xff08;2&#xff09;&#xff0c;勾选任务 &#xff…
阅读更多...
【知乎直答】批量多线程生成原创文章软件-AI智能搜索聚合

【知乎直答】批量多线程生成原创文章软件-AI智能搜索聚合

【知乎直答】批量多线程生成原创文章软件介绍&#xff1a; 1、知乎发布的全新AI产品“知乎直答”是其AI搜索功能的产品化成果&#xff0c;旨在提升用户的提问、搜索体验以及结果生成和归纳的质量。 2、数据基础&#xff1a;该产品基于知乎平台上的真实问答数据及全网高质量问答…
阅读更多...
Chromium 中前端js XMLHttpRequest接口c++代码实现

Chromium 中前端js XMLHttpRequest接口c++代码实现

在JavaScript中发出HTTP请求的主要方式包括&#xff1a;XMLHttpRequest对象、Fetch API、Axios库和各种其他的HTTP客户端库。 本人主要分析下XMLHttpRequest接口在c中对应实现 一、上前端代码 <!DOCTYPE html> <html lang"en"> <head> <meta…
阅读更多...
Go基础学习11-测试工具gomock和monkey的使用

Go基础学习11-测试工具gomock和monkey的使用

文章目录 基础回顾MockMock是什么安装gomockMock使用1. 创建user.go源文件2. 使用mockgen生成对应的Mock文件3. 使用mockgen命令生成后在对应包mock下可以查看生成的mock文件4. 编写测试代码5. 运行代码并查看输出 GomonkeyGomonkey优势安装使用对函数进行monkey对结构体中方法…
阅读更多...
Marp精华总结（二）进阶篇

Marp精华总结（二）进阶篇

概述 这是Marp精华总结的第二篇&#xff0c;主要补充第一篇未提到的一些内容。 系列目录 Marp精华总结&#xff08;一&#xff09;基础篇Marp精华总结&#xff08;二&#xff09;进阶篇Marp精华总结&#xff08;三&#xff09;高级篇 自适应标题 通过在标题行中插入<!-…
阅读更多...
EfficientSAM

EfficientSAM

不建议复现
阅读更多...
历经十年/头发都快掉光/秘钥生成器终极版/机器码/到期功能限制/运行时间限制/日期防篡改/跨平台

历经十年/头发都快掉光/秘钥生成器终极版/机器码/到期功能限制/运行时间限制/日期防篡改/跨平台

一、项目介绍 1.0 前言说明 标题一点都不夸张&#xff0c;从第一版的秘钥生成器到今天这个版本&#xff0c;确实经历了十年的时间&#xff0c;最初的版本做的非常简陋&#xff0c;就是搞了个异或加密&#xff0c;控制运行时间&#xff0c;后面又增加设备数量的控制&#xff0…
阅读更多...
JavaFX加载fxml文件几种方法

JavaFX加载fxml文件几种方法

环境&#xff1a;idea&#xff0c;maven创建JavaFX工程 工程目录如下&#xff1a; MusicPlayer.java package cn.com;import java.io.IOException;import javafx.application.Application; import javafx.fxml.FXMLLoader; import javafx.geometry.Insets; import javafx.geo…
阅读更多...
目标检测 Deformable DETR（2021）详细解读

目标检测 Deformable DETR（2021）详细解读

文章目录 前言整体网络架构可变形注意力模块backbone生成多尺度特征多尺度位置编码prediction heads两个变体 前言 为解决DETR attention的计算量大导致收敛速度慢、小目标检测效果差的问题&#xff1a;提出了Deformable Attention&#xff0c;其注意力模块只关注一个query周围…
阅读更多...
ML 系列： (10)— ML 中的不同类型的学习

ML 系列： (10)— ML 中的不同类型的学习

一、说明 我们之前将机器学习方法分为三类&#xff1a;监督学习、无监督学习和强化学习。机器学习方法可以分为不同的类型&#xff0c;我们将在下面讨论最重要的类型。 二、懒惰学习与急切学习 预先学习的工作原理是使用训练数据构建模型&#xff0c;然后使用此模型评估测试数据…
阅读更多...
STM32F103C8----3-3 蜂鸣器（跟着江科大学STM32）

STM32F103C8----3-3 蜂鸣器（跟着江科大学STM32）

一&#xff0c;电路图 &#xff08;接线图&#xff09; 面包板的的使用请参考&#xff1a;《面包板的使用_面包板的详细使用方法-CSDN博客》 二&#xff0c;目的/效果 3-3 蜂鸣器 三&#xff0c;创建Keil项目 详细参考&#xff1a;《STM32F103C8----2-1 Keil5搭建STM32项目模…
阅读更多...
MySQL 中的 EXPLAIN 命令详解

MySQL 中的 EXPLAIN 命令详解

在 MySQL 数据库中&#xff0c;EXPLAIN命令是一个非常强大的工具&#xff0c;它可以提供关于 SQL 查询执行计划的关键信息。理解这些信息对于优化查询性能至关重要。本文将详细介绍 MySQL 中的EXPLAIN命令提供的关键信息。 一、什么是 EXPLAIN 命令 EXPLAIN命令用于获取 MySQ…
阅读更多...
Java多态（向上转型、动态绑定）+结合题目理解原理

Java多态（向上转型、动态绑定）+结合题目理解原理

第一次尝试使用markdowm写博客哈 文章目录 1.多态的引入2.重写和重载3.避免在构造方法里面去调用重写4.向上转型和向下转型5.让你真正明白什么是多态6.通过一些习题进行理解 1.多态的引入 首先说一下&#xff0c;这个想要使用多态需要我们满足的条件&#xff0c;然后具体的进行…
阅读更多...
进程概念（冯诺依曼体系结构、操作系统、进程）-- 详解

进程概念（冯诺依曼体系结构、操作系统、进程）-- 详解

目录 一、冯诺依曼体系结构1、概念2、硬件层面的数据流3、关于冯诺依曼的知识点强调4、CPU 工作原理5、补充&#xff08;CPU 和寄存器、高速缓存以及主存之间的关系&#xff09; 二、操作系统&#xff08;Operating System&#xff09;1、概念2、定位3、设计 OS 的目的4、如何理…
阅读更多...
Linux高级编程_28_进程

Linux高级编程_28_进程

文章目录 进程并行与并发单道与多道程序进程控制块(PCB)了解PCB存储位置进程号&#xff1a;进程号&#xff1a;&#xff08;PID&#xff09;进程组号&#xff1a;&#xff08;PGID&#xff09;父进程号&#xff1a;&#xff08;PPID&#xff09; fork函数 多进程创建进程状态进…
阅读更多...
基于vue框架的大学生勤工俭学咨询服务系统的设计与实现60uw9（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。

基于vue框架的大学生勤工俭学咨询服务系统的设计与实现60uw9（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。

系统程序文件列表 项目功能&#xff1a;大学生,企业,招聘信息,在线咨询,咨询回复,职位应聘 开题报告内容 基于Vue框架的大学生勤工俭学咨询服务系统的设计与实现 开题报告 一、研究背景 随着高等教育的普及与就业市场的竞争加剧&#xff0c;大学生勤工俭学已成为一种普遍现…
阅读更多...
＜＜机器学习实战＞＞1-9节笔记

＜＜机器学习实战＞＞1-9节笔记

2.前言与导学 从关注算法的分类与特性到关注算法适合解决哪类问题 很多经典算法不再有效&#xff0c;但特征工程、集成学习越来越有效&#xff0c;和深度学习分别适合于不同领域 3、基本概念 如果预测目标是离散的&#xff0c;则是分类问题&#xff0c;否则回归 机器学习相比…
阅读更多...
【AIGC】ChatGPT开发者必备：如何获取 OpenAI 的 API Key

【AIGC】ChatGPT开发者必备：如何获取 OpenAI 的 API Key

博客主页&#xff1a; [小ᶻZ࿆] 本文专栏: AIGC | ChatGPT 文章目录 &#x1f4af;前言&#x1f4af;API Key的重要性&#x1f4af;获取API Key的基本步骤&#x1f4af;定价策略和使用建议&#x1f4af;小结 &#x1f4af;前言 在现代应用开发中&#xff0c;获取OpenAI的…
阅读更多...
TCP Analysis Flags 之 TCP ZeroWindowProbe

TCP Analysis Flags 之 TCP ZeroWindowProbe

前言 默认情况下&#xff0c;Wireshark 的 TCP 解析器会跟踪每个 TCP 会话的状态&#xff0c;并在检测到问题或潜在问题时提供额外的信息。在第一次打开捕获文件时&#xff0c;会对每个 TCP 数据包进行一次分析&#xff0c;数据包按照它们在数据包列表中出现的顺序进行处理。可…
阅读更多...
什么是沉默成本?超详细＋通俗易懂版

什么是沉默成本?超详细＋通俗易懂版

沉默成本是一个在会计学、金融学以及经济学中常用的概念&#xff0c;但更常见的表述是沉没成本&#xff08;Sunk Cost&#xff09;。沉没成本指的是已经发生且无法收回的成本&#xff0c;这些成本与当前的决策无关&#xff0c;但往往会影响人们的决策过程。以下是对沉没成本的详…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023