I have a Java primitive type at hand:

    Class&lt;?&gt; c = int.class; // or long.class, or boolean.class

I&#39;d like to get a *default value* for this class -- specifically, the value is assigned to fields of this type if they are not initialized. E.g., `0` for a number, `false` for a boolean.

Is there a generic way to do this? I tried this:

    c.newInstance()

But I&#39;m getting an `InstantiationException`, and not a default instance.

Getting default value for primitive types

Can the following piece of code be rewritten w/o using `Collections.synchronizedMap()` yet maintaining correctness at concurrency? 

    Collections.synchronizedMap(new WeakHashMap&lt;Class, Object&gt;());

i.e. is there something from java.util.concurrent one can use instead? Note that merely replacing with 

    new ConcurrentHashMap&lt;Class, Object&gt;(new WeakHashMap&lt;Class, Object&gt;()));

obviously won&#39;t work

Is there java.util.concurrent equivalent for WeakHashMap?

I used `ToStringBuilder.reflectionToString(class)` in commons-lang, to implement `toString()` for simple DTOs. Now I&#39;m trying to use Google Guava instead of Apache commons library. And I found `Objects.ToStringHelper` in Guava. But it&#39;s too verbose if there&#39;re lots of members in the class. For example:

	@Override
	public String toString() {
		return MoreObjects.toStringHelper(this.getClass()).add(&quot;name&quot;, name)
				.add(&quot;emailAddress&quot;, emailAddress)
				.add(&quot;department&quot;, department).add(&quot;yearJoined&quot;, yearJoined)
				.toString();
	}

is much simpler if I use commons-lang:

    @Override
    public String toString() {
        return ToStringBuilder.reflectionToString(this);
    }

Is there any better ways to implement `toString()` with Guava, not with commons-lang?

[Guava docs][1]

  [1]: https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/base/MoreObjects.html

Using Google Guava&#39;s Objects.ToStringHelper

I would like to append double quotes to strings in an array and then later join them as a single string (retaining the quotes). Is there any String library which does this? I have tried Apache commons StringUtils.join and the Joiner class in Google guava but couldn&#39;t find anything that appends double quotes.

My input would be an array as mentioned below:

    String [] listOfStrings = {&quot;day&quot;, &quot;campaign&quot;, &quot;imps&quot;, &quot;conversions&quot;};

Required output should be as mentioned below:

    String output = &quot;\&quot;day\&quot;, \&quot;campaign\&quot;, \&quot;imps\&quot;, \&quot;conversions\&quot;&quot;;

I know I can loop through the array and append quotes. But I would like a more cleaner solution if there is one.

Java - Append quotes to strings in an array and join strings in an array

I have a list of strings and I have a function to generate a value for each key in the list.

I want to create a map using this function. Can I do this with Google collections?


How to transform List&lt;String&gt; to Map&lt;String,String&gt; with Google collections?

I didn&#39;t find such a multimap construction... When I want to do this, I iterate over the map, and populate the multimap. Is there an other way?


    final Map&lt;String, Collection&lt;String&gt;&gt; map = ImmutableMap.&lt;String, Collection&lt;String&gt;&gt;of(
                &quot;1&quot;, Arrays.asList(&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;c&quot;));
    System.out.println(Multimaps.forMap(map));

    final Multimap&lt;String, String&gt; expected = ArrayListMultimap.create();
    for (Map.Entry&lt;String, Collection&lt;String&gt;&gt; entry : map.entrySet()) {
        expected.putAll(entry.getKey(), entry.getValue());
    }
    System.out.println(expected);

The first result is `{1=[[a, b, c, c]]}` but I expect `{1=[a, b, c, c]}`



How to create a Multimap&lt;K,V&gt; from a Map&lt;K, Collection&lt;V&gt;&gt;?

I&#39;d like to have a list which contains the integers in the range 1 to 500.  Is there some way to create this list using Guava (or just plain Java) without having to loop through the range and add the values individually within my own code?

Populating a List with a contiguous range of integers

I was looking for a [bidirectional map](http://en.wikipedia.org/wiki/Bidirectional_map) implementation in Java, and stumbled upon these two libraries:

* [Google Guava](https://github.com/google/guava) (formerly &quot;Google Collections&quot;)
* [Apache Commons Collections](http://commons.apache.org/collections/)

Both are free, have the bidirectional map implementation that I was looking for (BidiMap in Apache, BiMap in Google), are amazingly nearly the same size (Apache 493 kB, Google 499 kB) [ed.: no longer true!] and seem in all ways pretty similar to me.

Which one should I choose, and why? Are there some other equivalent alternatives (must be free and have at least the bidirectional map)? I&#39;m working with the latest Java SE, so no need to artificially limit to Java 5 or anything like that.

Google Guava vs. Apache Commons

Guava offers a nice shortcut for initializing a map.  However I get the following compiler error (Eclipse Indigo) when my map initializes to nine entries. 

The method `of(K, V, K, V, K, V, K, V, K, V)` in the type `ImmutableMap` is not applicable for the arguments 
`(String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String)`

	ImmutableMap&lt;String,String&gt; myMap = ImmutableMap.of(
			&quot;key1&quot;, &quot;value1&quot;, 
			&quot;key2&quot;, &quot;value2&quot;, 
			&quot;key3&quot;, &quot;value3&quot;, 
			&quot;key4&quot;, &quot;value4&quot;, 
			&quot;key5&quot;, &quot;value5&quot;, 
			&quot;key6&quot;, &quot;value6&quot;, 
			&quot;key7&quot;, &quot;value7&quot;, 
			&quot;key8&quot;, &quot;value8&quot;, 
			&quot;key9&quot;, &quot;value9&quot;
			);

The message appears to say that 

&gt; An ImmutableMap has a maximum size of four pairs of key,value.

Obviously, this cannot be the case but I can&#39;t figure out what to do to increase the size of my initializer.

Can someone tell me what is missing?



initializing a Guava ImmutableMap

Is there a short and sweet way to generate a `List&lt;Integer&gt;`, or perhaps an  `Integer[]` or `int[]`, with sequential values from some `start` value to an `end` value?

That is, something shorter than, but equivalent to&lt;sup&gt;1&lt;/sup&gt; the following:

    void List&lt;Integer&gt; makeSequence(int begin, int end) {
      List&lt;Integer&gt; ret = new ArrayList&lt;&gt;(end - begin + 1);
      for (int i=begin; i&lt;=end; i++) {
        ret.add(i);
      }
      return ret;  
    }

The use of guava is fine.

**Update:**

## Performance Analysis

Since this question has received several good answers, both using native Java 8 and third party libraries, I thought I&#39;d test the performance of all the solutions.

The first test simply tests creating a list of 10 elements `[1..10]` using the following methods:

 - **classicArrayList**: the code given above in my question (and essentially the same as adarshr&#39;s answer).
 - **eclipseCollections**: the code given in [Donald&#39;s answer](https://stackoverflow.com/a/36350104/149138) below using Eclipse Collections 8.0.
 - **guavaRange**: the code given in [daveb&#39;s answer](https://stackoverflow.com/a/10242491/149138) below. Technically, this doesn&#39;t create a `List&lt;Integer&gt;` but rather a `ContiguousSet&lt;Integer&gt;` - but since it implements `Iterable&lt;Integer&gt;` in-order, it mostly works for my purposes.
 - **intStreamRange**: the code given in [Vladimir&#39;s answer](https://stackoverflow.com/a/22829036/149138) below, which uses `IntStream.rangeClosed()` - which was introduced in Java 8.
 - **streamIterate**: the code given in [Catalin&#39;s answer](https://stackoverflow.com/a/36114723/149138) below which also uses `IntStream` functionality introduced in Java 8.

Here are the results in kilo-operations per second (higher numbers are better), for all the above with lists of size 10:

[![List creation throughput][1]][1]

... and again for lists of size 10,000:

[![enter image description here][2]][2]

That last chart is correct - the solutions other than Eclipse and Guava are too slow to even get a single pixel bar! The fast solutions are 10,000 to 20,000 _times_ faster than the rest.

What&#39;s going on here, of course, is that the guava and eclipse solutions don&#39;t actually materialize any kind of 10,000 element list - they are simply fixed-size wrappers around the start and endpoints. Each element is created as needed during iteration. Since we don&#39;t actually iterate in this test, the cost is deferred. All of the other solutions actually materialize the full list in memory and pay a heavy price in a creation-only benchmark.

Let&#39;s do something a bit more realistic and also iterate over all the integers, summing them. So in the case of the `IntStream.rangeClosed` variant, the benchmark looks like:

	@Benchmark
	public int intStreamRange() {
		List&lt;Integer&gt; ret = IntStream.rangeClosed(begin, end).boxed().collect(Collectors.toList());  
		
		int total = 0;
		for (int i : ret) {
			total += i;
		}
		return total;  
	}

Here, the pictures changes a lot, although the non-materializing solutions are still the fastest. Here&#39;s length=10:

[![List&lt;Integer&gt; Iteration (length=10)][3]][3] 

... and length = 10,000:

[![List&lt;Integer&gt; Iteration (length=10,000)][4]][4]

The long iteration over many elements evens things up a lot, but eclipse and guava remain more than twice as fast even on the 10,000 element test.

So if you _really_ want a `List&lt;Integer&gt;`, eclipse collections seems like the best choice - but of course if you use streams in a more native way (e.g., forgetting `.boxed()` and doing a reduction in the primitive domain) you&#39;ll probably end up faster than all these variants. 

---

&lt;sup&gt;1&lt;/sup&gt; Perhaps with the exception of error handling, e.g., if `end` &lt; `begin`, or if the size exceeds some implementation or JVM limits (e.g., arrays larger than `2^31-1`.


  [1]: https://i.stack.imgur.com/j830l.png
  [2]: https://i.stack.imgur.com/zdxOz.png
  [3]: https://i.stack.imgur.com/VQDYA.png
  [4]: https://i.stack.imgur.com/LWWtu.png

How can I generate a list or array of sequential integers in Java?

I am looking among the standard libraries (like apache commons, jax, jboss, javax) for an interface or enum that lists the values of all the standard mime-type (aka content-type).

This interface should not be encumbered with too deep with other classes that would make it difficult to include the whole bunch as gwt source code.

for example

    interface ContentType{
      String JSON = &quot;Application/JSON&quot;;
      blah ... blah ...
    }

or,

    enum ContentType{
      JSON(&quot;Application/JSON&quot;),
      blah ... blah ...
    }




Interface/enum listing standard mime-type constants

I have had a quick scan of the [Guava API][1] and the new collection types it provides(`Multimap` and `BiMap` for example appear useful) and I am thinking of including the library in the project(s) I work on.

However, I also have a reticence to include libraries willy-nilly if they are of no great benefit and learning the features wastes valuable time.

Have you included the Guava library in your project and has it proved useful in any unexpected way? Would you always use it in the future? What has been its main benefit/time saver? What are its hidden features?


  [1]: https://google.github.io/guava/releases/snapshot/api/docs/

The Guava library: What are its most useful and/or hidden features?

I want to have a map with duplicate keys.

I know there are many map implementations (Eclipse shows me about 50), so I bet there must be one that allows this. I know it&#39;s easy to write your own map that does this, but I would rather use some existing solution.

Maybe something in commons-collections or google-collections?



Map implementation with duplicate keys

I am involved in the development of Android application which is a rather &quot;thick&quot; mobile client for a Web service. It heavily communicates with the server but also has a lot of inner logic too. So, I decided to use some features of `Google Guava` library to simplify development process. Here is a list of features I&#39;m very interested in: immutable collections, base utils, collection extensions, functional programming sugar and idioms (`common.collect` and `common.base`), primitives utilities (`common.primitives`), hashing utilities (`common.hash`), concurrent utils (futures and `AsyncFunction`). Things I **don&#39;t want** to use in Android: `common.cache` (see question below), `common.eventbus` (we have better Android specific libs for this, such as [Otto][1]), `common.io` (we can use [okio][2] for Android now).
&lt;p&gt; I read that using Guava for Android can significantly slow down compilation process and also decrease the whole runtime performance:
https://stackoverflow.com/questions/9283070/bad-performance-with-guava-cache  (in this case it is reasonable and there is no need to use Guava&#39;s cache for Android) and
https://stackoverflow.com/questions/7548038/adding-google-guava-to-android-project-significantly-slows-down-the-build
 &lt;p&gt;So, is it efficient to use Guava library in Android project or this library is designed to be used &lt;b&gt;only&lt;/b&gt; for the server-side development, and I should go with standard solutions? Any explanations will be very appreciated.&lt;/p&gt;


  [1]: https://github.com/square/otto
  [2]: https://github.com/square/okio

Is it a good idea to use Google Guava library for Android development?

We currently use apache collections, string utils, etc. I need to decide if we should switch from the apache foundations implementation.

The important criteria is ease of developers use. Performance/memory usage is not yet an important issue for us. Speed of development is the key criteria at this point.

I would appreciate opinions about how the developer&#39;s life became significantly easier with guava.




What are the big improvements between guava and apache equivalent libraries?

When I use `implementation &#39;com.google.firebase:firebase-inappmessaging-display:17.2.0&#39;` in my `app/build.gradle`, I get this error:

```none
Duplicate class com.google.common.util.concurrent.ListenableFuture found in modules guava-20.0.jar (com.google.guava:guava:20.0) and listenablefuture-1.0.jar (com.google.guava:listenablefuture:1.0)

Go to the documentation to learn how to Fix dependency resolution errors.
```

What I also have in my `app/build.gradle` is this:

    implementation &#39;com.google.android.gms:play-services-base:16.1.0&#39;
    implementation &#39;com.google.android.gms:play-services-analytics:16.0.8&#39;
    implementation &#39;com.google.android.gms:play-services-awareness:16.0.0&#39;
    implementation &#39;com.google.android.gms:play-services-cast:16.2.0&#39;
    implementation &#39;com.google.android.gms:play-services-gcm:16.1.0&#39;
    implementation &#39;com.google.android.gms:play-services-location:16.0.0&#39;
    implementation &#39;com.google.android.gms:play-services-maps:16.1.0&#39;
    implementation &#39;com.google.firebase:firebase-core:16.0.8&#39;
    implementation &#39;com.google.firebase:firebase-iid:17.1.2&#39;
    implementation &#39;com.google.firebase:firebase-messaging:17.6.0&#39;
    implementation &#39;android.arch.work:work-runtime:1.0.1&#39;
    implementation &#39;com.android.support:multidex:1.0.3&#39;
    apply plugin: &#39;com.google.gms.google-services&#39;

Maybe one of the libraries that I am using already includes support for the In-App Messaging dependency, and then it becomes redundant? Thank you.

Duplicate class com.google.common.util.concurrent.ListenableFuture found in modules guava-20.0.jar (com.google.guava:guava:20.0)

Guava provides us with great factory methods for Java types, such as `Maps.newHashMap()`.

But are there also builders for java Maps?

    HashMap&lt;String,Integer&gt; m = Maps.BuildHashMap.
        put(&quot;a&quot;,1).
        put(&quot;b&quot;,2).
        build();

builder for HashMap

Assume, I have a constant number of collections (e.g. 3 ArrayLists) as members of a class. Now, I want to expose all the elements to other classes so they can simply iterate over all elements (ideally, read only).
I&#39;m using guava collections and I wonder how I could use guava iterables/iterators to generate a logical view on the internal collections **without** making temporary copies.

Combine multiple Collections into a single logical Collection?

**Context**

I need to return a reference to a map that I&#39;m using for a data cache, and I&#39;d like to make sure nobody can modify their reference.

**Question**

I&#39;ve seen lots of references to UnmodifiableMap and ImmutableMap online, but I don&#39;t see anything comparing/contrasting them.  I figure there is a good reason that Google/Guava created their own version - can someone tell me what it is?

UnmodifiableMap (Java Collections) vs ImmutableMap (Google)

[Apache Commons IO][1] has a nice convenience method [IOUtils.toString()][2] to read an `InputStream` to a String.

Since I am trying to move away from Apache Commons and to [Guava][3]: is there an equivalent in Guava? I looked at all classes in the `com.google.common.io` package and I couldn&#39;t find anything nearly as simple.

**Edit:** I understand and appreciate the issues with charsets. It just so happens that I know that all my sources are in ASCII (yes, ASCII, not ANSI etc.), so in this case, encoding is not an issue for me.


  [1]: http://commons.apache.org/io
  [2]: http://commons.apache.org/io/api-release/org/apache/commons/io/IOUtils.html#toString%28java.io.InputStream%29
  [3]: http://code.google.com/p/guava-libraries/

Guava equivalent for IOUtils.toString(InputStream)

I see that Guava has isNullOrEmpty utility method for Strings

    Strings.isNullOrEmpty(str)

Do we have anything similar for Lists? Something like

    Lists.isNullOrEmpty(list)

which should be equivalent to

    list == null || list.isEmpty()

Also, do we have anything similar for Arrays? Something like

    Arrays.isNullOrEmpty(arr)

which should be equivalent to

    arr == null || arr.length == 0

Google Guava isNullOrEmpty for collections

I have a simple integer-to-string mapping in Java, but I need to be able to easily retrieve string from integer, and also integer from string. I&#39;ve tried Map, but it can retrieve only string from integer, it&#39;s one way:

    private static final Map&lt;Integer, String&gt; myMap = new HashMap&lt;Integer, String&gt;();
    // This works one way:
    String myString = myMap.get(myInteger);
    
    // I would need something like:
    Integer myInteger = myMap.getKey(myString);


Is there a right way to do it to have it both directions? 

Another problem is that I only have a few constant values that don&#39;t change (`1-&gt;&quot;low&quot;, 2-&gt;&quot;mid&quot;, 3-&gt;&quot;high&quot;`, so it wouldn&#39;t be worth to go for a complicated solution. 

Bi-directional Map in Java?

I am going through the code which uses `Predicate` in Java. I have never used `Predicate`. Can someone guide me to any tutorial or conceptual explanation of `Predicate` and its implementation in Java?

Predicate in Java

I want to get string values of my fields (they can be type of long string or any object),

if a field is null then it should return empty string, I did this with guava;

    nullToEmpty(String.valueOf(gearBox))
    nullToEmpty(String.valueOf(id))
    ...

But this returns null if gearbox is null! Not empty string because valueOf methdod returns string &quot;null&quot; which leads to errors.

Any Ideas?

EDIt: there are 100s fields I look for something easy to implement
               

Get empty string when null

I am looking to find guava-libraries in maven repository.  It looks like guava is adding more features to google-collections library.

is guava-libraries available in maven repo?

I have a rather large Android app that relies on many library projects. The Android compiler has a limitation of 65536 methods per .dex file and I am surpassing that number. 

There are basically two paths you can choose (at least that I know of) when you hit the method limit.

1) Shrink your code

2) Build multiple dex files ([see this blog post](http://android-developers.blogspot.se/2011/07/custom-class-loading-in-dalvik.html))


I looked into both and tried to find out what was causing my method count to go so high. The Google Drive API takes the biggest chunk with the Guava dependency at over 12,000. Total libs for Drive API v2 reach over 23,000!

My question I guess is, what do you think I should do? Should I remove Google Drive integration as a feature of my app? Is there a way to shrink the API down (yes, I use proguard)? Should I go the multiple dex route (which looks rather painful, especially dealing with third party APIs)?


How to shrink code - 65k method limit in dex

I&#39;ve recently read about this and seen people using this class, but in pretty much all cases, using `null` would&#39;ve worked as well - if not more intuitively. Can someone provide a concrete example where `Optional` would achieve something that `null` couldn&#39;t or in a much cleaner way? The only thing I can think of is to use it with `Maps` that don&#39;t accept `null` keys, but even that could be done with a side &quot;mapping&quot; of null&#39;s value. Can anyone provide me with a more convincing argument?

What&#39;s the point of Guava&#39;s Optional class

Imagine that I have a list of certain objects:
    
    List&lt;Student&gt;

And I need to generate another list including the `ids` of `Students` in the above list: 
     
    List&lt;Integer&gt;

Avoiding using a loop, is it possible to achieve this by using **apache collections** or **guava**? 

***Which methods should be useful for my case?*** 


How to make a new list with a property of an object which is in another list

Is there a reason there&#39;s

    Lists.transform()

but no

    Lists.filter()

?

How do I filter a list correctly? I could use

    new ArrayList(Collection2.filter())

of course, but this way it&#39;s not guaranteed that my ordering stays the same, if I understand correctly.

Guava: Why is there no Lists.filter() function?

I would like to do the following:

    List&lt;Integer&gt; list = IntStream.range(0, 7).collect(Collectors.toList());

but in a way that the resulting list is an implementation of Guava&#39;s `ImmutableList`.

I know I could do

    List&lt;Integer&gt; list = IntStream.range(0, 7).collect(Collectors.toList());
    List&lt;Integer&gt; immutableList = ImmutableList.copyOf(list);

but I would like to collect to it directly. I&#39;ve tried

    List&lt;Integer&gt; list = IntStream.range(0, 7)
        .collect(Collectors.toCollection(ImmutableList::of));

but it threw an exception:

&gt; java.lang.UnsupportedOperationException
	at com.google.common.collect.ImmutableCollection.add(ImmutableCollection.java:96)


How can I collect a Java 8 stream into a Guava ImmutableCollection?

## Context

I am writing a simple __[JUnit]__ test for the `MyObject` class.

A `MyObject` can be created from a static factory method that takes a varargs of __[String]__.

    MyObject.ofComponents(&quot;Uno&quot;, &quot;Dos&quot;, &quot;Tres&quot;);

At any time during the existence of `MyObject`, clients can inspect the parameters it was created by in the form of a __[List&amp;lt;E&amp;gt;]__, through the `.getComponents()` method.

    myObject.ofComponents(); // -&gt; List&lt;String&gt;: { &quot;Uno&quot;, &quot;Dos&quot;, &quot;Tres&quot; }

In other words, a `MyObject` both remembers and exposes the list of parameters that brought it into existence. More details about this contract:

- The order of `getComponents` will be the same as the one chosen for object creation
- Duplicate subsequent __[String]__ components are allowed and retained in order
- Behaviour on `null` is undefined (other code guarantees no `null` gets to the factory)
- There are no ways to alter the list of components after object instantiation

I am writing a simple test that creates a `MyObject` from a list of __[String]__ and checks that it can return the same list via `.getComponents()`. _I do this immediately but this is supposed to happen at a distance in a realistic code path_.

## Code

Here my attempt:

---

    List&lt;String&gt; argumentComponents = Lists.newArrayList(&quot;One&quot;, &quot;Two&quot;, &quot;Three&quot;);
    List&lt;String&gt; returnedComponents =
        MyObject.ofComponents(
            argumentComponents.toArray(new String[argumentComponents.size()]))
            .getComponents();
    assertTrue(Iterables.elementsEqual(argumentComponents, returnedComponents));

---

## Question

- Is __[Google Guava]__ `Iterables.elementsEqual()` the best way, provided I have the library in my build path, to compare those two lists? _this is something I have been agonizing about; should I use this helper method which goes over an [Iterable&amp;lt;E&amp;gt;].. check size and then iterate running `.equals()`.. or any other of the methods that an Internet search suggests? what&#39;s the canonical way to compare lists for unit tests?_

### Optional insights I would love to get

- Is the method test designed reasonably? I am not an expert in __[JUnit]__!
- Is `.toArray()` the best way to convert a __[List&amp;lt;E&amp;gt;]__ to a varargs of E?


[Google Guava]: http://code.google.com/p/guava-libraries/
&quot;Guava: Google Core Libraries for Java&quot;

[String]:
http://docs.oracle.com/javase/7/docs/api/java/lang/String.html
&quot;JDK: java.lang.String&quot;

[List&amp;lt;E&amp;gt;]:
http://docs.oracle.com/javase/7/docs/api/java/util/List.html
&quot;JDK: java.util.List&lt;E&gt;&quot;

[Iterable&amp;lt;E&amp;gt;]:
http://docs.oracle.com/javase/7/docs/api/java/lang/Iterable.html
&quot;JDK: java.lang.Iterable&lt;E&gt;&quot;

[JUnit]:
http://www.junit.org/
&quot;JUnit: Resources for test driven development&quot;

How to JUnit test that two List&lt;E&gt; contain the same elements in the same order?

What is the best construction for creating a `List` of Strings?  Is it `Lists.newArrayList()` (from guava) or `new ArrayList()`?

is it just a personal preference?&lt;br&gt;
or is it just Type generic type inference?&lt;br&gt;
or is there any theoretical or practical value in using Lists.newArrayList()? 

Lists.newArrayList vs new ArrayList

I have a `List&lt;Foo&gt;` and want a `Multimap&lt;String, Foo&gt;` where we&#39;ve grouped the `Foo`&#39;s by their `getId()` function.

I am using Java 8 and its almost awesome in that you can do:

    List&lt;Foo&gt; foos = ...
    Map&lt;String, List&lt;Foo&gt;&gt; foosById = foos.stream().collect(groupingBy(Foo::getId));

However, I have a good amount of code that wants a `MultiMap&lt;String, Foo&gt;` so this doesnt save me anything and I&#39;m back to using a for-loop to create my `Multimap`. Is there a nice &quot;functional&quot; way that I am missing?

Cleanest way to create a Guava Multimap from a Java 8 stream

I&#39;m looking for a implementation of java.util.Queue or something in the Google collection who behave like a Queue, but also ensure that each element of the queue is unique. (all further insertion will have no effect)

It&#39;s that possible, or will I have to do it by hand?

For now I&#39;m using a Queue&lt;MyStuff&gt;, with a LinkedList implementation, and I check the uniqueness before insertion. ( I use a side Map for doing this, add / remove element from the side map before / after the queu ). I don&#39;t like it too much.

Any input is welcome. If it&#39;s not in the java.util package, then maybe it&#39;s a bad idea?

A Queue that ensure uniqueness of the elements?

I&#39;m pretty new to Guava (let&#39;s be honest, I&#39;m not &quot;pretty new&quot;, I&#39;m a complete rookie on that subject) and so I decided to go through some documentation and got quite amazed while reading this:

[`com.google.common.base.Preconditions.checkNotNull(...)`][1]

I don&#39;t get the point of this method.
This means that instead of doing : 

    myObject.getAnything();

*(which might cause a `NullPointerException` if myObject is null)*

I should use

    checkNotNull(myObject).getAnything();

which **will** throw a `NullPointerException` if `myObject` is null and return `myObject` if it is not null.

I&#39;m puzzled and this might be the stupidest question ever but ...

What is the point of this?
Those two lines do the exact same thing as for outcomes given any situations I can think of.

I don&#39;t even think that the latter is more readable.

So I must be missing something. What is it?


  [1]: https://google.github.io/guava/releases/23.0/api/docs/com/google/common/base/Preconditions.html#checkNotNull-T-

What&#39;s the point of Guava checkNotNull

Highly repetitive code is generally a bad thing, and there are design patterns that can help minimize this. However, sometimes it&#39;s simply inevitable due to the constraints of the language itself. Take the following example from `java.util.Arrays`:

    /**
     * Assigns the specified long value to each element of the specified
     * range of the specified array of longs.  The range to be filled
     * extends from index &lt;tt&gt;fromIndex&lt;/tt&gt;, inclusive, to index
     * &lt;tt&gt;toIndex&lt;/tt&gt;, exclusive.  (If &lt;tt&gt;fromIndex==toIndex&lt;/tt&gt;, the
     * range to be filled is empty.)
     *
     * @param a the array to be filled
     * @param fromIndex the index of the first element (inclusive) to be
     *        filled with the specified value
     * @param toIndex the index of the last element (exclusive) to be
     *        filled with the specified value
     * @param val the value to be stored in all elements of the array
     * @throws IllegalArgumentException if &lt;tt&gt;fromIndex &amp;gt; toIndex&lt;/tt&gt;
     * @throws ArrayIndexOutOfBoundsException if &lt;tt&gt;fromIndex &amp;lt; 0&lt;/tt&gt; or
     *	       &lt;tt&gt;toIndex &amp;gt; a.length&lt;/tt&gt;
     */
    public static void fill(long[] a, int fromIndex, int toIndex, long val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i=fromIndex; i&lt;toIndex; i++)
            a[i] = val;
    }


The above snippet appears in the source code 8 times, with very little variation in the documentation/method signature but *exactly the same method body*, one for each of the root array types `int[]`, `short[]`, `char[]`, `byte[]`, `boolean[]`, `double[]`, `float[]`, and `Object[]`.

I believe that unless one resorts to reflection (which is an entirely different subject in itself), this repetition is inevitable. I understand that as a utility class, such high concentration of repetitive Java code is highly atypical, but even with the best practice, **repetition does happen**! Refactoring doesn&#39;t always work because it&#39;s not always possible (the obvious case is when the repetition is in the documentation).

Obviously maintaining this source code is a nightmare. A slight typo in the documentation, or a minor bug in the implementation, is multiplied by however many repetitions was made. In fact, the best example happens to involve this exact class:

&lt;a href=&quot;http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html&quot;&gt;Google Research Blog - Extra, Extra - Read All About It: Nearly All Binary Searches and Mergesorts are Broken (by Joshua Bloch, Software Engineer)&lt;/a&gt;

The bug is a surprisingly subtle one, occurring in what many thought to be just a simple and straightforward algorithm.

        // int mid =(low + high) / 2; // the bug
        int mid = (low + high) &gt;&gt;&gt; 1; // the fix

The above line **appears 11 times in the source code**!

So my questions are:

  * How are these kinds of repetitive Java code/documentation handled in practice? How are they developed, maintained, and tested?
     * Do you start with &quot;the original&quot;, and make it as mature as possible, and then copy and paste as necessary and hope you didn&#39;t make a mistake?
     * And if you did make a mistake in the original, then just fix it everywhere, unless you&#39;re comfortable with deleting the copies and repeating the whole replication process?
     * And you apply this same process for the testing code as well?
  * Would Java benefit from some sort of limited-use source code preprocessing for this kind of thing?
     * Perhaps Sun has their own preprocessor to help write, maintain, document and test these kind of repetitive library code?

---

A comment requested another example, so I pulled this one from Google Collections: &lt;a href=&quot;http://code.google.com/p/google-collections/source/browse/trunk/src/com/google/common/base/Predicates.java&quot;&gt;com.google.common.base.Predicates&lt;/a&gt; lines 276-310 (`AndPredicate`) vs lines 312-346 (`OrPredicate`).

The source for these two classes are identical, except for:

 * `AndPredicate` vs `OrPredicate` (each appears 5 times in its class)
 * `&quot;And(&quot;` vs `Or(&quot;` (in the respective `toString()` methods)
 * `#and` vs `#or` (in the `@see` Javadoc comments)
 * `true` vs `false` (in `apply`; `!` can be rewritten out of the expression)
 * `-1 /* all bits on */` vs `0 /* all bits off */` in `hashCode()`
 * `&amp;=` vs `|=` in `hashCode()`

Managing highly repetitive code and documentation in Java

After updating my dependency versions in **`AndroidStudio3.1`**, I started getting the following error:

        Information:Gradle tasks [:app:assembleDebug]
    Error:com.android.builder.dexing.DexArchiveBuilderException: Failed to process C:\Users\Blabla\.gradle\caches\modules-2\files-2.1\com.google.guava\guava\21.0\3a3d111be1be1b745edfa7d91678a12d7ed38709\guava-21.0.jar
    Error:com.android.builder.dexing.DexArchiveBuilderException: Error while dexing.
    Error:com.android.tools.r8.ApiLevelException: Default interface methods are only supported starting with Android N (--min-api 24): java.util.Collection com.google.common.collect.BiMap.values()
    Error:Execution failed for task &#39;:app:transformClassesWithDexBuilderForDebug&#39;.
    &gt; com.android.build.api.transform.TransformException: com.android.builder.dexing.DexArchiveBuilderException: com.android.builder.dexing.DexArchiveBuilderException: Failed to process C:\Users\Blabla\.gradle\caches\modules-2\files-2.1\com.google.guava\guava\21.0\3a3d111be1be1b745edfa7d91678a12d7ed38709\guava-21.0.jar
    Information:BUILD FAILED in 6s
    Information:4 errors
    Information:0 warnings
    Information:See complete output in console

I have already cleaned and rebuilt project. Checked my **`&quot;multiDexEnabled true&quot;`** and &#39;compile **`&#39;com.android.support:multidex:1.0.2&#39;`** is added.

 What else can I do?

EDIT: Adding build.gradle

    apply plugin: &#39;com.android.application&#39;
    
    android {
        compileSdkVersion 27
        buildToolsVersion &#39;26.0.2&#39;
        defaultConfig {
            applicationId &quot;com.blabla&quot;
            minSdkVersion 19
            targetSdkVersion 27
            versionCode 1
            versionName &quot;1.0&quot;
            testInstrumentationRunner &quot;android.support.test.runner.AndroidJUnitRunner&quot;
            vectorDrawables.useSupportLibrary = true
            multiDexEnabled true
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile(&#39;proguard-android.txt&#39;), &#39;proguard-rules.pro&#39;
            }
        }
        configurations.all {
            resolutionStrategy.force &#39;com.google.code.findbugs:jsr305:1.3.9&#39;
        }

    }
    
    dependencies {
        compile fileTree(dir: &#39;libs&#39;, include: [&#39;*.jar&#39;])
        androidTestCompile(&#39;com.android.support.test.espresso:espresso-core:2.2.2&#39;, {
            exclude group: &#39;com.android.support&#39;, module: &#39;support-annotations&#39;
        })
        compile &#39;com.android.support:appcompat-v7:27.0.0&#39;
        compile &#39;com.android.support.constraint:constraint-layout:1.0.2&#39;
        compile &#39;com.android.support:multidex:1.0.2&#39;
        compile &#39;com.android.support:design:27.0.0&#39;
        compile &#39;com.android.support:cardview-v7:27.0.0&#39;
        compile &#39;com.jakewharton:butterknife:8.7.0&#39;
        compile &#39;com.google.code.gson:gson:2.8.0&#39;
        compile &#39;com.google.guava:guava:21.0&#39;
        compile &#39;com.microsoft.azure:azure-mobile-android:3.2.0@aar&#39;
        compile &#39;com.microsoft.azure:notification-hubs-android-sdk:0.4@aar&#39;
        compile &#39;com.microsoft.azure:azure-notifications-handler:1.0.1@aar&#39;
        compile &#39;com.squareup.okhttp:okhttp:2.5.0&#39;
        compile &#39;com.google.firebase:firebase-core:11.4.2&#39;
        compile &#39;com.google.firebase:firebase-crash:11.4.2&#39;
        compile &#39;com.google.firebase:firebase-auth:11.4.2&#39;
        compile &#39;com.google.firebase:firebase-database:11.4.2&#39;
        compile &#39;com.google.firebase:firebase-storage:11.4.2&#39;
        testCompile &#39;junit:junit:4.12&#39;
        annotationProcessor &#39;com.jakewharton:butterknife-compiler:8.7.0&#39;
        compile &#39;com.google.android.gms:play-services-maps:11.4.2&#39;
        compile &#39;com.google.android.gms:play-services-location:11.4.2&#39;
        compile &#39;com.google.maps.android:android-maps-utils:0.5+&#39;
    }
    apply plugin: &#39;com.google.gms.google-services&#39;



Error:com.android.builder.dexing.DexArchiveBuilderException: Failed to process guava-21.0.jar Android 3.1 Dev Channel

Google Guava has CacheBuilder that allows to create ConcurrentHash with expiring keys that allow to remove entries after the fixed tiemout. However I need to cache only one instance of certain type.

What is the best way to cache single object within fixed timeout using Google Guava?

What is the best way to cache single object within fixed timeout?

Optional is used to represent nullable object, Some uses of this class include

  

 1. As a method return type, as an alternative to returning null to   
    indicate that no value was available
 2. To distinguish between &quot;unknown&quot; (for example, not present in a map)
    and &quot;known to have no value&quot; (present in the map, with value   
    Optional.absent())
 3. To wrap nullable references for storage in a collection that does not
   support null (though there are several other approaches to this that
   should be considered first)

For the first case, do I need to return Optional&lt;T&gt; in all nullable return method?  

Should I use Java8/Guava Optional for every method that may return null?

I am trying to use WorkManager 1.0.0-alpha09. and getting this error:

    Program type already present: 
    com.google.common.util.concurrent.ListenableFuture
    
    Message{kind=ERROR, text=Program type already present: 
    com.google.common.util.concurrent.ListenableFuture, sources=[Unknown source 
    file], tool name=Optional.of(D8)}

If i use version 1.0.0-alpha08 or less. I don&#39;t get this error, but i need public constructor 

    public Worker(Context context, WorkerParameters workerParams)

How to solve &#39;Program type already present: com.google.common.util.concurrent.ListenableFuture&#39;?

I am using Guava to cache hot data. When the data does not exist in the cache, I have to get it from database:

    public final static LoadingCache&lt;ObjectId, User&gt; UID2UCache = CacheBuilder.newBuilder()
            //.maximumSize(2000)
            .weakKeys()
            .weakValues()
            .expireAfterAccess(10, TimeUnit.MINUTES)
            .build(
            new CacheLoader&lt;ObjectId, User&gt;() {
                @Override
                public User load(ObjectId k) throws Exception {
                    User u = DataLoader.datastore.find(User.class).field(&quot;_id&quot;).equal(k).get();
                    return u;
                }
            });

My problem is when the data does not exists in database, I want it to return `null` and to not do any caching. But Guava saves `null` with the key in the cache and throws an exception when I get it:

&gt; com.google.common.cache.CacheLoader$InvalidCacheLoadException:
&gt; CacheLoader returned null for key shisoft.

How do we avoid caching `null` values?

How to avoid caching when values are null?

One of the dependencies declared in my project has a transitive dependency on `&#39;com.google.guava:guava:15.0&#39;`. But my application deployed on WAS/Weblogic doesn&#39;t work due to a CDI issue which has been fixed in `&#39;com.google.guava:guava:15.0:cdi1.0&#39;`. (same version, but with classifier) I need to tell gradle to use this jar during build and packaging. I am trying to figure on how we can ovrride this transitive dependency with a jar specific version classifier.

Tried the following approches:

 1. Added the dependency explicitly: `compile &#39;com.google.guava:guava:15.0:cdi1.0&#39;`. But both jars got included in the resultant WAR.
 2. Added the dependency explicitly and defined a resolution strategy:

        configurations.all {
            resolutionStrategy {
	            force &#39;com.google.guava:guava:15.0:cdi1.0&#39;
            }
        }
Even this didn&#39;t work.

 3. Defined a resolution strategy to check and change the version.

        configurations.all {
             resolutionStrategy.eachDependency { DependencyResolveDetails details -&gt;
    		     if (details.requested.group + &quot;:&quot; + details.requested.name == &#39;com.google.guava:guava&#39;) {
    	            details.useVersion &quot;15.0:cdi1.0&quot;
    	            //details.useTarget &quot;com.google.guava:guava:15.0:cdi1.0&quot;
    	        }
    	    }
        }
Even this didn&#39;t work.

Need your suggestions on how this issue can be tackled.

Gradle: Override transitive dependency by version classifier

I have a question about simplifying some Collection handling code, when using Google Collections (*update*: [Guava][1]).

I&#39;ve got a bunch of &quot;Computer&quot; objects, and I want to end up with a Collection of their &quot;resource id&quot;s.  This is done like so:

    Collection&lt;Computer&gt; matchingComputers = findComputers();
    Collection&lt;String&gt; resourceIds = 
        Lists.newArrayList(Iterables.transform(matchingComputers, new Function&lt;Computer, String&gt;() {
        public String apply(Computer from) {
            return from.getResourceId();
        }
    }));


Now, `getResourceId()` may return null (and changing that is not an option right now), yet in this case I&#39;d like to omit nulls from the resulting String collection.

Here&#39;s one way to filter nulls out: 

    Collections2.filter(resourceIds, new Predicate&lt;String&gt;() {
        @Override
        public boolean apply(String input) {
            return input != null;
        }
    });

You could put all that together like this:

    Collection&lt;String&gt; resourceIds = Collections2.filter(
    Lists.newArrayList(Iterables.transform(matchingComputers, new Function&lt;Computer, String&gt;() {
        public String apply(Computer from) {
            return from.getResourceId();
        }
    })), new Predicate&lt;String&gt;() {
        @Override
        public boolean apply(String input) {
            return input != null;
        }
    });

But this is hardly elegant, let alone readable, for such a simple task! In fact, plain old Java code (with no fancy Predicate or Function stuff at all) would arguably be much cleaner:

    Collection&lt;String&gt; resourceIds = Lists.newArrayList();
    for (Computer computer : matchingComputers) {
        String resourceId = computer.getResourceId();
        if (resourceId != null) {
            resourceIds.add(resourceId);
        }
    }

Using the above is certainly also an option, but out of curiosity (and desire to learn more of Google Collections), **can you do the exact same thing in some shorter or more elegant way using Google Collections**?


  [1]: https://code.google.com/p/guava-libraries/

Is there an elegant way to remove nulls while transforming a Collection using Guava?

Does Guava provide a method to get a default value if a passed object reference is `null` ? I&#39;am looking for something like `&lt;T&gt; T nullToDefault(T obj, T default)`, were the ***default*** is returned if ***obj*** is `null`.

Here on stackoverflow I found nothing about it. I am only looking for a pure Guava solution (if there is some)! 

I found nothing in the Gauva 10 API, only `com.google.common.base.Objects` looks promising but lacks something similar.

How to convert a possible null-value to a default value using Guava?

From ImmutableList javadocs:

&gt; Unlike
&gt; Collections.unmodifiableList(java.util.List),
&gt; which is a view of a separate
&gt; collection that can still change, an
&gt; instance of ImmutableList contains its
&gt; own private data and will never
&gt; change. ImmutableList is convenient
&gt; for public static final lists
&gt; (&quot;constant lists&quot;) and also lets you
&gt; easily make a &quot;defensive copy&quot; of a
&gt; list provided to your class by a
&gt; caller.

Does it mean that: 

 1. if I have ImmutableList of Dimension objects (for example) then I can&#39;t change any Dimension object in it?
 2. and if I have Collections.unmodifiableList (list) of Dimension objects then I can&#39;t only add or delete any object but I can change them (for example call setDimension(width, height) method)?

All Guava Solutions on Gang of Coders

Total of 45 Guava Solutions