Quelles sont les astuces pour utiliser Java Guava ?

Introduction à Guava

Guava est une bibliothèque open source publiée par Google. Elle fournit principalement des classes d'outils et des API très utiles dans le développement Java, telles que le traitement des chaînes, les opérations d'ensemble, la programmation fonctionnelle, la mise en cache, etc.

Strings

Strings est un ensemble d'outils de chaînes fournis par Guava, qui fournit de nombreuses méthodes utiles pour traiter les chaînes. Voici les principales méthodes de Strings :

• isNullOrEmpty(String string) : Déterminez si la chaîne est vide ou nulle. isNullOrEmpty(String string)：判断字符串是否为空或null。

• padEnd(String string, int minLength, char padChar)：在字符串末尾填充指定字符，直到字符串达到指定长度。

• padStart(String string, int minLength, char padChar)：在字符串开头填充指定字符，直到字符串达到指定长度。

• repeat(String string, int count)：重复指定字符串指定次数。

• commonPrefix(CharSequence a, CharSequence b)：获取两个字符串的最长公共前缀。

• commonSuffix(CharSequence a, CharSequence b)：获取两个字符串的最长公共后缀。

以下是Strings的使用示例：

public class StringsDemo {
    public static void main(String[] args) {
        // 判断字符串是否为空或null
        String str1 = null;
        String str2 = "";
        System.out.println(Strings.isNullOrEmpty(str1));
        System.out.println(Strings.isNullOrEmpty(str2));

        // 在字符串末尾填充指定字符，直到字符串达到指定长度
        String str3 = "abc";
        String paddedStr1 = Strings.padEnd(str3, 6, '*');
        System.out.println(paddedStr1);

        // 在字符串开头填充指定字符，直到字符串达到指定长度
        String str4 = "abc";
        String paddedStr2 = Strings.padStart(str4, 6, '*');
        System.out.println(paddedStr2);

        // 重复指定字符串指定次数
        String str5 = "abc";
        String repeatedStr = Strings.repeat(str5, 3);
        System.out.println(repeatedStr);

        // 获取两个字符串的最长公共前缀
        String str6 = "abcdefg";
        String str7 = "abcdxyz";
        String commonPrefix = Strings.commonPrefix(str6, str7);
        System.out.println(commonPrefix);

        // 获取两个字符串的最长公共后缀
        String str8 = "abcdefg";
        String str9 = "xyzdefg";
    String commonSuffix = Strings.commonSuffix(str8, str9);
    System.out.println(commonSuffix);
}

集合操作（Collections）

Guava提供了一些非常有用的集合操作API，如下所示：

1.ImmutableList

不可变集合是Guava的一个重要特性，它可以确保集合不被修改，从而避免并发访问的问题。ImmutabelList是不可变List的实现，下面是一个示例代码：

List<String> list = Lists.newArrayList("a", "b", "c");
ImmutableList<String> immutableList = ImmutableList.copyOf(list);

2.Iterables

Iterables类提供了一些有用的方法来操作集合，如下所示：

Iterable<String> iterable = Lists.newArrayList("a", "b", "c");

// 判断集合是否为空
boolean isEmpty = Iterables.isEmpty(iterable);

// 获取第一个元素，如果集合为空返回null
String first = Iterables.getFirst(iterable, null);

// 获取最后一个元素，如果集合为空返回null
String last = Iterables.getLast(iterable, null);

// 获取所有符合条件的元素
Iterable<String> filtered = Iterables.filter(iterable, new Predicate<String>() {
    @Override
    public boolean apply(String input) {
        return input.startsWith("a");
    }
});

// 转换集合类型
List<String> newList = Lists.newArrayList(Iterables.transform(iterable, new Function<String, String>() {
    @Override
    public String apply(String input) {
        return input + input;
    }
}));

3.Multimaps

Multimaps提供了一个非常有用的数据结构，它允许一个键对应多个值，下面是一个示例代码：

ListMultimap<Integer, String> map = ArrayListMultimap.create();
map.put(1, "a");
map.put(1, "b");
map.put(2, "c");
List<String> values = map.get(1); // 返回[a, b]

4.Maps

Maps提供了一些有用的方法来操作Map，如下所示：

Map<Integer, String> map = ImmutableMap.of(1, "a", 2, "b", 3, "c");

// 判断Map是否为空
boolean isEmpty = Maps.isEmpty(map);

// 获取Map中的所有键
Set<Integer> keys = map.keySet();

// 获取Map中的所有值
Collection<String> values = map.values();

// 获取Map中的所有键值对
Set<Map.Entry<Integer, String>> entries = map.entrySet();

// 根据键获取值，如果不存在则返回null
String value = Maps.getIfPresent(map, 1);

条件检查（Preconditions）

Preconditions是Guava提供的一组前置条件检查工具，它提供了一些检查参数是否符合预期的方法。以下是Preconditions的主要方法：

• checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)：检查参数是否符合预期，并抛出IllegalArgumentException异常，可以包含错误信息模板和占位符。

• checkNotNull(T reference, String errorMessageTemplate, Object... errorMessageArgs)：检查参数是否为null，并抛出NullPointerException异常，可以包含错误信息模板和占位符。

• checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)：检查对象状态是否符合预期，并抛出IllegalStateException异常，可以包含错误信息模板和占位符。

• checkElementIndex(int index, int size, String errorMessageTemplate, Object... errorMessageArgs)：检查下标是否在集合的范围内，并抛出IndexOutOfBoundsException异常，可以包含错误信息模板和占位符。

• checkPositionIndex(int index, int size, String errorMessageTemplate, Object... errorMessageArgs)：检查下标是否在集合的范围内，可以等于集合的大小，并抛出IndexOutOfBoundsException异常，可以包含错误信息模板和占位符。

• checkPositionIndexes(int start, int end, int size)

padEnd(String string, int minLength, char padChar) : remplissez les caractères spécifiés à la fin de la chaîne jusqu'à ce que la chaîne atteigne la longueur spécifiée.

padStart(String string, int minLength, char padChar) : remplissez les caractères spécifiés au début de la chaîne jusqu'à ce que la chaîne atteigne la longueur spécifiée.

• repeat(String string, int count) : Répétez la chaîne spécifiée un nombre de fois spécifié.

• commonPrefix(CharSequence a, CharSequence b) : Obtenez le préfixe commun le plus long de deux chaînes.

• commonSuffix(CharSequence a, CharSequence b) : obtenez le suffixe commun le plus long de deux chaînes.

• Ce qui suit est un exemple d'utilisation de chaînes :

  public class PreconditionsDemo {
      public static void main(String[] args) {
          // 检查参数是否符合预期，并抛出IllegalArgumentException异常，可以包含错误信息模板和占位符
          String str1 = "abc";
          Preconditions.checkArgument(str1.length() < 3, "字符串长度必须小于3");
          // 检查参数是否为null，并抛出NullPointerException异常，可以包含错误信息模板和占位符
          String str2 = null;
          Preconditions.checkNotNull(str2, "字符串不能为空");
          // 检查对象状态是否符合预期，并抛出IllegalStateException异常，可以包含错误信息模板和占位符
          boolean flag1 = false;
          Preconditions.checkState(flag1, "状态不正确");
          // 检查下标是否在集合的范围内，并抛出IndexOutOfBoundsException异常，可以包含错误信息模板和占位符
          List<Integer> list1 = Lists.newArrayList(1, 2, 3, 4, 5);
          Preconditions.checkElementIndex(6, list1.size(), "下标越界");
          // 检查下标是否在集合的范围内，可以等于集合的大小，并抛出IndexOutOfBoundsException异常，可以包含错误信息模板和占位符
          List<Integer> list2 = Lists.newArrayList(1, 2, 3, 4, 5);
          Preconditions.checkPositionIndex(5, list2.size(), "下标越界");
          // 检查开始下标和结束下标是否在集合的范围内，并抛出IndexOutOfBoundsException异常
          List<Integer> list3 = Lists.newArrayList(1, 2, 3, 4, 5);
          Preconditions.checkPositionIndexes(2, 6, list3.size());
          // 可以在错误信息中使用占位符
          int value1 = 101;
          Preconditions.checkArgument(value1 <= 100, "值必须小于等于 %s", 100);
          // 可以使用Supplier来避免计算开销
          int value2 = 101;
          Preconditions.checkArgument(value2 <= 100, () -> "值必须小于等于 " + 100);
  }

  Collections (Collections)
• Guava fournit des API d'opération de collection très utiles, comme suit :
  1.ImmutableList
• La collection Immutable est une fonctionnalité importante de Guava. , il garantit que la collection n'est pas modifiée, évitant ainsi les problèmes d'accès simultanés. ImmutabelList est une implémentation de List immuable, voici un exemple de code :

  public class CacheDemo {
      public static void main(String[] args) {
          Cache<String, String> cache = CacheBuilder.newBuilder()
                  .maximumSize(100)
                  .expireAfterWrite(10, TimeUnit.MINUTES)
                  .build();
  
          cache.put("key", "value");
  
          String value = cache.getIfPresent("key");
      }
  }

  2.Iterables
• La classe Iterables fournit des méthodes utiles pour faire fonctionner les collections, comme indiqué ci-dessous :

  rrreee

  3.Multimaps
• Multimaps fournit un A très structure de données utile qui permet à une clé de correspondre à plusieurs valeurs. Voici un exemple de code :

  rrreee

  4 Maps
• Maps fournit quelques méthodes utiles pour faire fonctionner Maps, comme indiqué ci-dessous :

  rrreee

  Vérification conditionnelle (conditions préalables)
• . Les préconditions sont un ensemble d'outils de vérification des préconditions fournis par Guava. Il fournit quelques méthodes pour vérifier si les paramètres répondent aux attentes. Voici les principales méthodes de préconditions :

checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs) : Vérifiez si les paramètres répondent aux attentes et lancez une exception IllegalArgumentException, qui peut contenir un modèle de message d'erreur et des espaces réservés. 🎜🎜🎜🎜checkNotNull(T reference, String errorMessageTemplate, Object... errorMessageArgs) : vérifie si le paramètre est nul et renvoie NullPointerException, qui peut contenir des modèles de message d'erreur et des espaces réservés. 🎜🎜🎜🎜checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs) : Vérifiez si l'état de l'objet est comme prévu et lancez une exception IllegalStateException, qui peut contenir des modèles de message d'erreur et des espaces réservés. 🎜🎜🎜🎜checkElementIndex(int ​​​​index, int size, String errorMessageTemplate, Object... errorMessageArgs) : Vérifiez si l'indice est dans la plage de la collection et lancez une exception IndexOutOfBoundsException, qui peut inclure un modèle de message d’erreur et des espaces réservés. 🎜🎜🎜🎜checkPositionIndex(int ​​​​index, int size, String errorMessageTemplate, Object... errorMessageArgs) : Vérifiez si l'indice est dans la plage de la collection, qui peut être égale à la taille de la collection et lève une exception IndexOutOfBoundsException, qui peut contenir des modèles de message d'erreur et des espaces réservés. 🎜🎜🎜🎜checkPositionIndexes(int start, int end, int size) : vérifiez si l'indice de début et l'indice de fin sont dans la plage de la collection et lancez une exception IndexOutOfBoundsException. 🎜🎜🎜🎜Ce qui suit est un exemple d'utilisation des conditions préalables : 🎜rrreee🎜Vous pouvez définir le cache local (CacheBuilder) avec un délai d'expiration🎜🎜Cache est une classe d'outil de mise en cache fournie par Guava, qui peut nous aider à mettre en cache les données en mémoire et à améliorer la performance du programme. Voici les principales méthodes du Cache : 🎜🎜🎜🎜get(K key, Callable<? extends V> valueLoader) : récupère la valeur du cache de la clé spécifiée. Si elle n'est pas dans le cache, appelez valueLoader pour charger les données. et stockez-le dans le cache. 🎜🎜🎜🎜getIfPresent(Object key) : récupère la valeur du cache de la clé spécifiée si elle n'est pas dans le cache, renvoie null. 🎜🎜🎜🎜getAllPresent(Iterable<?> keys) : récupère la valeur du cache des clés spécifiées, s'il n'y a pas de valeur de cache, renvoie null. 🎜🎜🎜🎜put(K key, V value) : stocke la valeur du cache de la clé spécifiée dans le cache. 🎜🎜🎜🎜putAll(Map<? extends K, ? extends V> m) : stocke la valeur du cache de la carte spécifiée dans le cache. 🎜🎜🎜🎜invalidate(Object key) : supprime la valeur de cache de la clé spécifiée du cache. 🎜🎜🎜🎜invalidateAll(Iterable<?> keys) : supprime la valeur du cache des clés spécifiées du cache. 🎜🎜🎜🎜invalidateAll() : supprime toutes les valeurs mises en cache du cache. 🎜🎜🎜🎜size() : Obtenez le nombre de valeurs mises en cache dans le cache. 🎜🎜🎜🎜asMap() : Convertit le cache en carte. 🎜🎜🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!