java项目常用的工具类

海棠未语

于 2024-09-16 20:46:25 发布

阅读量422

点赞数 14

分类专栏： java基础文章标签： java 项目开发工具类集合判断对象判断数组判断

本文链接：https://blog.csdn.net/qq_43016560/article/details/142287163

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

当我们在项目中进行开发的时候，往往会有很多工具类，有的是为了简化操作，有的是业务需要而进行封装。当代码量累计起来之后，发现工具类越来越多，而且每位小伙伴的编程习惯和知识构成不一样，往往导致一个工具类封装了之后很少使用和维护。甚至很多时候对共工具类进行了过度封装，这时不妨看看下面的基于JDK等已经封装好的工具类，直接上手使用即可。

一、Objects工具类常用方法

1、比较两个对象是否相等 equals

  public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

2、toString,如果传入对象为空则返回默认值

   public static String toString(Object o, String nullDefault) {
        return (o != null) ? o.toString() : nullDefault;
    }

3、验证对象不为空，如果为空则按照默认信息抛出空指针异常

  public static <T> T requireNonNull(T obj, String message) {
        if (obj == null)
            throw new NullPointerException(message);
        return obj;
    }

4、判断对象是否为空

 public static boolean isNull(Object obj) {
        return obj == null;
    }

5、判断对象是否不为空

 public static boolean nonNull(Object obj) {
        return obj != null;
    }

6、计算并返回多个对象的哈希码的组合

public static int hash(Object... values) {
    return Arrays.hashCode(values);
}

二、CollectionUtils工具类常用方法

CollectionUtils 是 Apache Commons Collections 库中的一个非常有用的工具类，它提供了一系列静态方法来简化集合的操作。以下是一些 CollectionUtils 的常用方法及其用途：

package org.apache.commons.collections4;

1、判断集合是否为空

  public static boolean isEmpty(final Collection<?> coll) {
      return coll == null || coll.isEmpty();
  }

2、判断集合是否不为空

public static boolean isNotEmpty(final Collection<?> coll) {
    return !isEmpty(coll);
}

3、反转给定数组的顺序

public static void reverseArray(final Object[] array) {
    int i = 0;
    int j = array.length - 1;
    Object tmp;

    while (j > i) {
        tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
        j--;
        i++;
    }
}

4、向指定的集合中添加多个元素，如果集合为 null，则不进行任何操作。

 public static <C> boolean addAll(final Collection<C> collection, final C... elements) {
        boolean changed = false;
        for (final C element : elements) {
            changed |= collection.add(element);
        }
        return changed;
    }

maven引入方式

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

三、MapUtils工具类常用方法

MapUtils 是 Apache Commons Collections 库中的一个实用工具类，它提供了一系列用于操作 Map 对象的方法。以下是 MapUtils 的一些常用方法及其用途：

package org.apache.commons.collections4;

1、将map中的key与value交换位置

public static <K, V> Map<V, K> invertMap(final Map<K, V> map) {
    final Map<V, K> out = new HashMap<>(map.size());
    for (final Entry<K, V> entry : map.entrySet()) {
        out.put(entry.getValue(), entry.getKey());
    }
    return out;
}

2、如果map为空则返回一个空map，否则返回map本身

public static <K,V> Map<K,V> emptyIfNull(final Map<K,V> map) {
    return map == null ? Collections.<K,V>emptyMap() : map;
}

3、判断map是否为空

public static boolean isEmpty(final Map<?,?> map) {
    return map == null || map.isEmpty();
}

4、判断map是否不为空

public static boolean isNotEmpty(final Map<?,?> map) {
    return !MapUtils.isEmpty(map);
}

5、返回一个线程安全的map

public static <K, V> Map<K, V> synchronizedMap(final Map<K, V> map) {
    return Collections.synchronizedMap(map);
}

maven引入

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

四、ArrayUtils工具类常用方法

ArrayUtils 是 Apache Commons Lang 库中的一个实用工具类，它提供了一系列用于操作数组的方法。这个类的工具方法可以帮助开发者处理数组，包括数组的创建、搜索、比较、转换和其他实用操作。以下是 ArrayUtils 的一些常用方法及其用途：

package org.apache.commons.lang3;

1、将数组转为map

入参要求：

数组中元素为key-value形式，或包含元素是至少两个元素的 Array，其中第一个元素用作 key，第二个元素用作 value。

public static Map<Object, Object> toMap(final Object[] array) {
    if (array == null) {
        return null;
    }
    final Map<Object, Object> map = new HashMap<>((int) (array.length * 1.5));
    for (int i = 0; i < array.length; i++) {
        final Object object = array[i];
        if (object instanceof Map.Entry<?, ?>) {
            final Map.Entry<?,?> entry = (Map.Entry<?,?>) object;
            map.put(entry.getKey(), entry.getValue());
        } else if (object instanceof Object[]) {
            final Object[] entry = (Object[]) object;
            if (entry.length < 2) {
                throw new IllegalArgumentException("Array element " + i + ", '"
                    + object
                    + "', has a length less than 2");
            }
            map.put(entry[0], entry[1]);
        } else {
            throw new IllegalArgumentException("Array element " + i + ", '"
                    + object
                    + "', is neither of type Map.Entry nor an Array");
        }
    }
    return map;
}

2、反转给定数组的顺序

public static void reverse(final Object[] array) {
    if (array == null) {
        return;
    }
    reverse(array, 0, array.length);
}

3、判断数组是否为空

public static boolean isEmpty(final Object[] array) {
    return getLength(array) == 0;
}

4、判断数组是否不为空

public static <T> boolean isNotEmpty(final T[] array) {
    return !isEmpty(array);
}

maven 引入方式

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version> <!-- 请使用最新版本 -->
</dependency>

五、Collections工具类常用方法

Collections 是 Java 集合框架（Java Collections Framework，JCF）中的一个工具类，位于 java.util 包中。它提供了一系列静态方法，用于操作和返回集合，特别是对集合进行各种有用的操作，如排序、搜索、替换、同步和迭代等。以下是 Collections 类的一些常用方法及其用途：

package java.util;

1、反转指定列表中元素的顺序

public static void reverse(List<?> list) {
    int size = list.size();
    if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
        for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
            swap(list, i, j);
    } else {
        // instead of using a raw type here, it's possible to capture
        // the wildcard but it will require a call to a supplementary
        // private method
        ListIterator fwd = list.listIterator();
        ListIterator rev = list.listIterator(size);
        for (int i=0, mid=list.size()>>1; i<mid; i++) {
            Object tmp = fwd.next();
            fwd.set(rev.previous());
            rev.set(tmp);
        }
    }
}

2、返回集合中最小的元素

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) {
    Iterator<? extends T> i = coll.iterator();
    T candidate = i.next();

    while (i.hasNext()) {
        T next = i.next();
        if (next.compareTo(candidate) < 0)
            candidate = next;
    }
    return candidate;
}

3、返回集合中最大的元素

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
    Iterator<? extends T> i = coll.iterator();
    T candidate = i.next();

    while (i.hasNext()) {
        T next = i.next();
        if (next.compareTo(candidate) > 0)
            candidate = next;
    }
    return candidate;
}

4、返回一个空集合（推荐使用）

public static final <T> List<T> emptyList() {
    return (List<T>) EMPTY_LIST;
}

5、返回一个空Map

public static final <K,V> Map<K,V> emptyMap() {
    return (Map<K,V>) EMPTY_MAP;
}

6、返回一个空的Set

public static final <T> Set<T> emptySet() {
    return (Set<T>) EMPTY_SET;
}

7、返回含有单个元素的List

public static <T> List<T> singletonList(T o) {
    return new SingletonList<>(o);
}

8、返回含有单个元素的Map

public static <K,V> Map<K,V> singletonMap(K key, V value) {
    return new SingletonMap<>(key, value);
}

9、返回含有单个元素的Set

public static <T> Set<T> singleton(T o) {
    return new SingletonSet<>(o);
}

10、返回一个线程安全的List

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
            new SynchronizedRandomAccessList<>(list) :
            new SynchronizedList<>(list));
}

11、返回一个线程安全的Map

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
    return new SynchronizedMap<>(m);
}

12、返回一个线程安全的Set

public static <T> Set<T> synchronizedSet(Set<T> s) {
    return new SynchronizedSet<>(s);
}

13、对集合进行排序

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null);
}

14、对集合进行排序（指定比较器）

public static <T> void sort(List<T> list, Comparator<? super T> c) {
    list.sort(c);
}

15、返回一个不可修改的List

public static <T> List<T> unmodifiableList(List<? extends T> list) {
    return (list instanceof RandomAccess ?
            new UnmodifiableRandomAccessList<>(list) :
            new UnmodifiableList<>(list));
}

（定义常量List使用）

16、返回一个不可修改的Map

public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m) {
    return new UnmodifiableMap<>(m);
}

17、返回一个不可修改的Set

public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
    return new UnmodifiableSet<>(s);
}

18、返回指定元素在列表出现的次数

public static int frequency(Collection<?> c, Object o) {
    int result = 0;
    if (o == null) {
        for (Object e : c)
            if (e == null)
                result++;
    } else {
        for (Object e : c)
            if (o.equals(e))
                result++;
    }
    return result;
}