Shulou(Shulou.com)06/03 Report--

This article mainly introduces "how to use Guava". In daily operation, I believe many people have doubts about how to use Guava. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "how to use Guava"! Next, please follow the editor to study!

Recently, when looking at a classmate's code, I found that the code uses a lot of content in Google's open source Guava core library, which makes the code simple and clear, so I learn to share the most practical functions in Guava.

Guava project is an open source Java core library of Google. It mainly contains some functions that are often used in Java development, such as data check, immutable collection, count collection, collection enhancement operation, Imax O, cache, string operation and so on. And Guava is widely used in Google internal Java projects, and is also widely used by other companies, even in the new version of JDK directly introduced the excellent class library of Guava, so the quality is beyond doubt.

The mode of use is directly introduced by mavan dependency.

Com.google.guava guava 30.0-jre data check

Data verification is very simple, one is non-empty judgment, the other is expected value judgment. I think every Java developer is familiar with it and often deals with NullPointException at first. The way we deal with it is naturally an if (xx = = null) that can be easily solved. The judgment of the expected value is similar, just check whether the data value is the result you want.

Even with such a simple operation, do we often make mistakes? And the code written is always one by one to judge that an exception is thrown, which is so elegant no matter how it looks. Fortunately, let's try using Guava for the first time.

Non-empty judgment

String param = "unread code"; String name = Preconditions.checkNotNull (param); System.out.println (name); / / unread code String param2 = null; String name2 = Preconditions.checkNotNull (param2); / / NullPointerException System.out.println (name2)

After the introduction of Guava, you can directly use Preconditions.checkNotNull for non-empty judgment. The advantage is that there are two advantages: one is that the semantic is clear and the code is elegant; the other is that you can also customize the error message, so that if the parameter is empty and the error message is clear, you can directly locate the specific parameter.

String param2 = null; String name2 = Preconditions.checkNotNull (param2, "param2 is null"); / / java.lang.NullPointerException: param2 is null

Expected value judgment

Similar to the non-null judgment, you can compare the current value with the expected value, and if it is not equal, you can customize the error message to throw.

String param = "www.wdbyte.com2"; String wdbyte = "www.wdbyte.com"; Preconditions.checkArgument (wdbyte.equals (param), "[% s] 404 NOT FOUND", param); / / java.lang.IllegalArgumentException: [www.wdbyte.com2] 404 NOT FOUND

Whether or not to cross the line

The Preconditions class can also be used to check whether the element fetch of arrays and collections is out of bounds.

/ / quickly create ArrayList List list = Lists.newArrayList ("a", "b", "c", "d") in Guava; / / start verification int index = Preconditions.checkElementIndex (5, list.size ()); / / java.lang.IndexOutOfBoundsException: index (5) must be less than size (4)

The way to quickly create a List in the code is also provided by Guava, and the extra poses created by collections in Guava are described in more detail later.

An immutable set

Creating immutable collections is one of my personal favorite reasons for Guava, because it's so practical to create a collection that can't be deleted, modified, or added. You don't have to worry about what's wrong with such a collection. Generally speaking, it has the following advantages:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Thread safety, because no elements can be modified, can be used by multiple threads at will, and there is no concurrency problem.

It can be provided to a third party without worry, but it can't be modified anyway.

Reduce memory footprint, because it cannot be changed, so the internal implementation can maximize memory footprint savings.

Can be used as a collection of constants.

Creation mode

Having said so much, how on earth do you use it? Hurry up and roll up the code.

/ / creation method 1:of ImmutableSet immutableSet = ImmutableSet.of ("a", "b", "c"); immutableSet.forEach (System.out::println); / / a / / b / c / / creation method 2:builder ImmutableSet immutableSet2 = ImmutableSet.builder () .add ("hello") .add (new String ("unread code")) .build (); immutableSet2.forEach (System.out::println) / / hello / / unread code / / creation method 3: copy from other collections to create ArrayList arrayList = new ArrayList (); arrayList.add ("www.wdbyte.com"); arrayList.add ("https"); ImmutableSet immutableSet3 = ImmutableSet.copyOf (arrayList); immutableSet3.forEach (System.out::println); / / www.wdbyte.com / / https

You can print the traversal results normally, but if you add or delete them, you will directly report to UnsupportedOperationException.

In fact, an immutable collection is also provided in JDK, which can be created as follows.

ArrayList arrayList = new ArrayList (); arrayList.add ("www.wdbyte.com"); arrayList.add ("https"); / / JDK Collections create immutable List List list = Collections.unmodifiableList (arrayList); list.forEach (System.out::println); / / www.wdbyte.com https list.add ("unread code"); / / java.lang.UnsupportedOperationException

Matters needing attention

1. Immutable collections created with Guava reject the null value because the null value is not needed in 95% of the cases in the Google internal survey.

two。 Once created successfully using the immutable collection provided by JDK, the elements added to the original collection will be reflected in the immutable collection, while the immutable collection of Guava will not have this problem.

List arrayList = new ArrayList (); arrayList.add ("a"); arrayList.add ("b"); List jdkList = Collections.unmodifiableList (arrayList); ImmutableList immutableList = ImmutableList.copyOf (arrayList); arrayList.add ("ccc"); jdkList.forEach (System.out::println); / / result: ab ccc System.out.println ("-"); immutableList.forEach (System.out::println); / / result: ab

3. If the element of an immutable collection is a reference object, the properties of the reference object can be changed.

Other immutable sets

Immutable sets in addition to the set demonstrated above, there are many immutable sets. Here is the correspondence between immutable sets and other sets in Guava.

Does the mutable set interface belong to JDK or Guava immutable version of CollectionJDKImmutableCollectionListJDKImmutableListSetJDKImmutableSetSortedSet/NavigableSetJDKImmutableSortedSetMapJDKImmutableMapSortedMapJDKImmutableSortedMapMultisetGuavaImmutableMultisetSortedMultisetGuavaImmutableSortedMultisetMultimapGuavaImmutableMultimapListMultimapGuavaImmutableListMultimapSetMultimapGuavaImmutableSetMultimapBiMapGuavaImmutableBiMapClassToInstanceMapGuavaImmutableClassToInstanceMapTableGuavaImmutableTable

Collection operation factory

In fact, only one creation method will be introduced here, but why is it introduced separately? If you watch it, you'll yell and use it. Although JDK has provided a large number of set-related operation methods, and it is also very convenient to use, Guava has added some very useful methods to ensure that you can't put it down the last time you use it.

Create a collection.

/ / create an ArrayList collection List list1 = Lists.newArrayList (); / / create an ArrayList collection with 3 data List list2 = Lists.newArrayList ("a", "b", "c"); / / create an ArrayList collection with the capacity initialized as 10 List list3 = Lists.newArrayListWithCapacity (10); LinkedList linkedList1 = Lists.newLinkedList (); CopyOnWriteArrayList cowArrayList = Lists.newCopyOnWriteArrayList (); HashMap hashMap = Maps.newHashMap (); ConcurrentMap concurrentMap = Maps.newConcurrentMap () TreeMap treeMap = Maps.newTreeMap (); HashSet hashSet = Sets.newHashSet (); HashSet newHashSet = Sets.newHashSet ("a", "a", "b", "c")

Guava adds factory method creation for each collection, and it has shown how factory methods are created for some collections. Is it very easy to use? And you can just throw in a few elements when you create it, which is so great that you don't have to add it any more.

Set intersection union difference set

It's too simple, just look at the code and the output.

Set newHashSet1 = Sets.newHashSet ("a", "a", "b", "c"); Set newHashSet2 = Sets.newHashSet ("b", "b", "c", "d"); / / intersection SetView intersectionSet = Sets.intersection (newHashSet1, newHashSet2); System.out.println (intersectionSet); / / [b, c] / / Union SetView unionSet = Sets.union (newHashSet1, newHashSet2); System.out.println (unionSet) / / [a, b, c, d] / / newHashSet1, SetView setView = Sets.difference (newHashSet1, newHashSet2); System.out.println (setView); / / [a] quantitative set does not exist in newHashSet2

This is really useful, because we often need to design a collection that can be counted, or value is a Map collection of List, if you don't understand, take a look at the following code to see if you wrote the same one night.

1. Count the number of occurrences of the same element (I have written the following code as succinctly as possible).

JDK native writing:

/ / Java counts the number of occurrences of the same element. List words = Lists.newArrayList ("a", "b", "c", "d", "a", "c"); Map countMap = new HashMap (); for (String word: words) {Integer count = countMap.get (word); count = (count = = null)? 1: + count; countMap.put (word, count) } countMap.forEach ((k, v)-> System.out.println (k + ":" + v)); / * result: * a result 2 * b result 1 * d result 1 * /

Although the code has been optimized as much as possible, there is still a lot of code, so what's the difference in Guava? In Guava. The HashMultiset class is mainly used in, see below.

ArrayList arrayList = Lists.newArrayList ("a", "b", "c", "d", "a", "c"); HashMultiset multiset = HashMultiset.create (arrayList); multiset.elementSet () .forEach (s-> System.out.println (s + ":" + multiset.count (s); / * result: * AVL 2 * B1 * CWV 2 * dRV 1 * /

Yes, just add the elements, regardless of whether they repeat or not, you can use the count method to count the number of repeated elements. Looking comfortable and elegant, HashMultiset is a Collection class implemented in Guava that makes it easy to count the number of elements.

two。 One-to-many, value is the Map collection of List.

Suppose you have a scenario where you need to classify a lot of animals by species, and I'm sure you'll end up writing similar code.

JDK native writing:

HashMap animalMap = new HashMap (); HashSet dogSet = new HashSet (); dogSet.add ("prosperous wealth"); dogSet.add ("rhubarb"); animalMap.put ("dog", dogSet); HashSet catSet = new HashSet (); catSet.add ("Garfield"); catSet.add ("Tom"); animalMap.put ("cat", catSet); System.out.println (animalMap.get ("cat")); / / [Garfield, Tom]

The last line queries the cat to get the cat's "Garfield" and "Tom". This code is so annoying to do. What if I use Guava?

/ / use guava HashMultimap multimap = HashMultimap.create (); multimap.put ("dog", "rhubarb"); multimap.put ("dog", "prosperous wealth"); multimap.put ("cat", "Garfield"); multimap.put ("cat", "Tom"); System.out.println (multimap.get ("cat")); / / [Garfield, Tom]

HashMultimap can throw in duplicate key values, and finally get all the value values. You can see that the output is the same as JDK, but the code is extremely clean.

String operation

As the longest used data type in development, enhancements to string manipulation can make development more efficient.

Character splicing

String concatenation is actually built into JDK 8, but it is a simple concatenation with no additional operations, such as filtering out null elements and removing spaces before and after. First take a look at several ways to concatenate strings in JDK 8.

/ / JDK mode-ArrayList list = Lists.newArrayList ("a", "b", "c", null); String join = String.join (",", list); System.out.println (join); / / String result = list.stream (). Collect (Collectors.joining (","); System.out.println (result); / / a StringJoiner stringJoiner = new StringJoiner (",") List.forEach (stringJoiner::add); System.out.println (stringJoiner.toString ()); / / _

You can see that the null value is also concatenated into the string, which is sometimes not what we want, so what's the difference in using Guava?

ArrayList list = Lists.newArrayList ("a", "b", "c", null); String join = Joiner.on (","). SkipNulls (). Join (list); System.out.println (join); / / c String join1 = Joiner.on (","). UseForNull ("null"). Join ("prosperous wealth", "Tom", "Jerry", null); System.out.println (join1); / / Wang Cai, Tom, Jerry, empty value

You can see that null values can be skipped with skipNulls (), and useFornull (String) can be used to customize the display of text for null values.

String segmentation

JDK has its own string segmentation, and I think you must have used it, which is String's split method, but there is a problem with this method, that is, if the last element is empty, then it will be discarded. The strange thing is that the first element is empty but will not be discarded, which is very confusing. Here is an example to demonstrate this problem.

String str = ", String splitArr = str.split (", "); Arrays.stream (splitArr) .forEach (System.out::println); System.out.println ("-"); / * a * * b * * /

You can also test it yourself, the last element is not empty, it just disappears.

What is the operation of using Guava? Guava provides the Splitter class, and there are a series of operations that can intuitively control the segmentation logic.

String str = ", a, b,"; Iterable split = Splitter.on (",") .omitEmptyStrings () / ignore null values .trimResults () / / filter blanks in the results .split (str); split.forEach (System.out::println); / * * a * b * / cache

In development, we may need to use small-scale caching to improve access speed. At this point, the introduction of professional caching middleware may feel wasteful. Now, simple caching classes are available in Guava, and elements that have been added can be automatically expired based on expected capacity, expiration time, and so on. Even so, we have to estimate the memory space that may be used to prevent excessive memory consumption.

Now take a look at how to use caching in Guava.

@ Test public void testCache () throws ExecutionException, InterruptedException {CacheLoader cacheLoader = new CacheLoader () {/ / if the element is not found, it will be called here @ Override public Animal load (String s) {return null;}} LoadingCache loadingCache = CacheBuilder.newBuilder () .maximumSize (1000) / capacity .remoreAfterWrite (3, TimeUnit.SECONDS) / expiration time .removalListener (new MyRemovalListener ()) / / fail listener .build (cacheLoader); / / loadingCache.put ("Dog", new Animal ("prosperous Wealth", 1)); loadingCache.put ("Cat", new Animal ("Tom", 3)) LoadingCache.put ("Wolf", new Animal ("Grey Wolf", 4)); loadingCache.invalidate ("Cat"); / / Manual failure Animal animal = loadingCache.get ("Wolf"); System.out.println (animal); Thread.sleep (4 * 1000); / / Wolf has passed automatically to get an error System.out.println (loadingCache.get (Wolf)) for the null value. / * key= cat, value=Animal {name=' Tom', age=3}, reason=EXPLICIT * Animal {name=' Big Wolf', age=4} * key= Dog, value=Animal {name=' Wealth', age=1}, reason=EXPIRED * key= Wolf, value=Animal {name=' Grey Wolf', age=4}, reason=EXPIRED * * com.google.common.cache.CacheLoader$InvalidCacheLoadException: CacheLoader returned null for key Wolf. * /} / * Cache removal listener * / class MyRemovalListener implements RemovalListener {@ Override public void onRemoval (RemovalNotification notification) {String reason= String.format ("key=%s,value=%s,reason=%s", notification.getKey (), notification.getValue (), notification.getCause ()); System.out.println (reason);}} class Animal {listener @ Override public String toString () {return "Animal {" + "name='" + name +'\'+ ", age=" + age +'}';} public Animal (String name, Integer age) {this.name = name; this.age = age;}

This example is mainly divided into CacheLoader, MyRemovalListener, LoadingCache.

The load method is overridden in CacheLoader, which is called when the query cache misses. I return null directly here, which throws CacheLoader returned null for key exception information when it misses.

MyRemovalListener, as a listening class when the cache element expires, automatically calls the onRemoval method when the element cache expires. Note here that this method is a synchronous method. If it takes a long time here, it will block until the processing is completed.

LoadingCache is the main operating object of the cache, and the put and get methods are commonly used.

At this point, the study on "how to use Guava" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.