Was sind die Tipps für die Verwendung von Java Guava?

Einführung in Guava

Guava ist eine von Google veröffentlichte Open-Source-Bibliothek. Sie bietet hauptsächlich einige sehr nützliche Toolklassen und APIs für die Java-Entwicklung, wie z. B. String-Verarbeitung, Mengenoperationen, funktionale Programmierung, Caching usw.

Strings

Strings ist eine Reihe von String-Tools, die von Guava bereitgestellt werden und viele nützliche Methoden zur Verarbeitung von Strings bieten. Im Folgenden sind die Hauptmethoden von Strings aufgeführt:

• isNullOrEmpty(String string): Bestimmen Sie, ob die Zeichenfolge leer oder null ist. 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): Füllt die angegebenen Zeichen am Ende der Zeichenfolge auf, bis die Zeichenfolge die angegebene Länge erreicht.

padStart(String string, int minLength, char padChar): Füllt die angegebenen Zeichen am Anfang der Zeichenfolge auf, bis die Zeichenfolge die angegebene Länge erreicht.

• repeat(String string, int count): Wiederholen Sie die angegebene Zeichenfolge eine bestimmte Anzahl von Malen.

• commonPrefix(CharSequence a, CharSequence b): Ermittelt das längste gemeinsame Präfix zweier Zeichenfolgen.

• commonSuffix(CharSequence a, CharSequence b): Ermittelt das längste gemeinsame Suffix zweier Zeichenfolgen.

• Das Folgende ist ein Beispiel für die Verwendung von Strings:

  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 bietet einige sehr nützliche Sammlungsoperations-APIs wie folgt:
  1. ImmutableList
• Immutable Collection ist eine wichtige Funktion von Guava Dadurch wird sichergestellt, dass die Sammlung nicht geändert wird, wodurch Probleme beim gleichzeitigen Zugriff vermieden werden. ImmutabelList ist eine Implementierung von unveränderlicher Liste. Hier ist ein Beispielcode:

  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
• Die Iterables-Klasse bietet einige nützliche Methoden zum Betreiben von Sammlungen, wie unten gezeigt:

  rrreee

  3.Multimaps
• Multimaps bietet ein sehr gutes Ergebnis Nützliche Datenstruktur, die es einem Schlüssel ermöglicht, mehreren Werten zu entsprechen:

  rrreee

  Maps bietet einige nützliche Methoden zum Betreiben von Maps, wie unten gezeigt:
rrreee
• Bedingte Prüfung (Vorbedingungen)
  Preconditions ist eine Reihe von Tools zur Vorbedingungsprüfung, die von Guava bereitgestellt werden. Es bietet einige Methoden, um zu überprüfen, ob die Parameter den Erwartungen entsprechen. Im Folgenden sind die Hauptmethoden von Preconditions aufgeführt:

• checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs): Überprüfen Sie, ob die Parameter den Erwartungen entsprechen, und lösen Sie eine IllegalArgumentException-Ausnahme aus, die enthalten kann eine Fehlermeldungsvorlage und Platzhalter.

🎜🎜checkNotNull(T reference, String errorMessageTemplate, Object... errorMessageArgs): Prüft, ob der Parameter null ist und löst eine NullPointerException aus, die Fehlermeldungsvorlagen und Platzhalter enthalten kann. 🎜🎜🎜🎜checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs): Überprüfen Sie, ob der Objektstatus wie erwartet ist, und lösen Sie eine IllegalStateException-Ausnahme aus, die Fehlermeldungsvorlagen und Platzhalter enthalten kann. 🎜🎜🎜🎜checkElementIndex(int ​​​​index, int size, String errorMessageTemplate, Object... errorMessageArgs): Überprüfen Sie, ob der Index innerhalb des Bereichs der Sammlung liegt, und lösen Sie eine IndexOutOfBoundsException-Ausnahme aus kann eine Fehlermeldungsvorlage und Platzhalter enthalten. 🎜🎜🎜🎜checkPositionIndex(int ​​​​index, int size, String errorMessageTemplate, Object... errorMessageArgs): Überprüfen Sie, ob der Index innerhalb des Bereichs der Sammlung liegt, der der Größe entsprechen kann der Sammlung und löst eine IndexOutOfBoundsException-Ausnahme aus, die Fehlermeldungsvorlagen und Platzhalter enthalten kann. 🎜🎜🎜🎜checkPositionIndexes(int start, int end, int size): Überprüfen Sie, ob der Start- und Endindex innerhalb des Bereichs der Sammlung liegen, und lösen Sie eine IndexOutOfBoundsException-Ausnahme aus. 🎜🎜🎜🎜Das Folgende ist ein Beispiel für die Verwendung von Vorbedingungen: 🎜rrreee🎜Sie können den lokalen Cache (CacheBuilder) mit Ablaufzeit festlegen🎜🎜Cache ist eine von Guava bereitgestellte Caching-Tool-Klasse, die uns dabei helfen kann, Daten im Speicher zwischenzuspeichern und zu verbessern die Leistung des Programms. Im Folgenden sind die Hauptmethoden von Cache aufgeführt: 🎜🎜🎜🎜get(K-Taste, Callable16b170b82654b3ad3ad8b85ee0de190b valueLoader): Rufen Sie den Cache-Wert des angegebenen Schlüssels ab, wenn er sich nicht im Cache befindet, rufen Sie valueLoader auf, um die Daten zu laden und speichern Sie es im Cache. 🎜🎜🎜🎜getIfPresent(Objektschlüssel): Rufen Sie den Cache-Wert des angegebenen Schlüssels ab. Wenn er nicht im Cache ist, geben Sie null zurück. 🎜🎜🎜🎜getAllPresent(Iterable6b3d0130bba23ae47fe2b8e8cddf0195 Schlüssel): Ruft den Cache-Wert der angegebenen Schlüssel ab. Wenn kein Cache-Wert vorhanden ist, wird Null zurückgegeben. 🎜🎜🎜🎜put(K-Schlüssel, V-Wert): Speichern Sie den Cache-Wert des angegebenen Schlüssels im Cache. 🎜🎜🎜🎜putAll(Map191ecd8411de86c8e7d83e2b6eee1741 m): Speichert den Cache-Wert der angegebenen Map im Cache. 🎜🎜🎜🎜invalidate(Objektschlüssel): Löschen Sie den Cache-Wert des angegebenen Schlüssels aus dem Cache. 🎜🎜🎜🎜invalidateAll(Iterable6b3d0130bba23ae47fe2b8e8cddf0195 Keys): Löscht den Cache-Wert der angegebenen Schlüssel aus dem Cache. 🎜🎜🎜🎜invalidateAll(): Alle zwischengespeicherten Werte aus dem Cache entfernen. 🎜🎜🎜🎜size(): Ermittelt die Anzahl der zwischengespeicherten Werte im Cache. 🎜🎜🎜🎜asMap(): Cache in Karte konvertieren. 🎜🎜🎜rrreee

Das obige ist der detaillierte Inhalt vonWas sind die Tipps für die Verwendung von Java Guava?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!