I had the same issue in react-native project, the below lines worked for me, compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 }
For people that absolutely need performance, boxing and unboxing and generified collections and whatnot are big no-no’s. The same problem happens in performance computing where you need the same complex to work both for float and double (say some of the method shown in Goldberd’s “What every computer scientist should know about floating-point numbers” paper). … Read more
The idea is to fail fast. For instance, consider this silly class: public class Foo { private final String s; public Foo(String s) { this.s = s; } public int getStringLength() { return s.length(); } } Let’s say you don’t want to allow null values for s. (or else getStringLength will throw a NPE). With … Read more
How about a LinkedHashSet? Its iterator preserves insertion order, but because it’s a Set, its elements are unique. As its documentation says, Note that insertion order is not affected if an element is re-inserted into the set. In order to efficiently remove elements from the head of this “queue”, go through its iterator: Iterator<?> i … Read more
The guava builder saves typing the type arguments multiple times. Compare: List<Foo<Bar, Baz>> list = Lists.newArrayList(); List<Foo<Bar, Baz>> list = new ArrayList<Foo<Bar, Baz>>(); In Java 7 it’s a bit obsolete though, because you have the diamond operator: List<Foo<Bar, Baz>> list = new ArrayList<>();
You can just use the Guava Multimaps factory: ImmutableMultimap<String, Foo> foosById = Multimaps.index(foos, Foo::getId); or wrap a call to Multimaps.index with a Collector<T, A, R> interface (shown below, in an unoptimized naive implementation). Multimap<String, Foo> collect = foos.stream() .collect(MultimapCollector.toMultimap(Foo::getId)); and the Collector: public class MultimapCollector<T, K, V> implements Collector<T, Multimap<K, V>, Multimap<K, V>> { private … Read more
It wasn’t implemented because it would expose a perilous large number of slow methods, such as #get(index) on the returned List view (inviting performance bugs). And ListIterator would be a pain to implement as well (though I submitted a patch years ago to cover that). Since indexed methods can’t be efficient in the filtered List … Read more
Why not simply use List#equals? assertEquals(argumentComponents, imapPathComponents); Contract of List#equals: two lists are defined to be equal if they contain the same elements in the same order.
The toImmutableList() method in the accepted answer of Alexis is now included in Guava 21 and can be used as: ImmutableList<Integer> list = IntStream.range(0, 7) .boxed() .collect(ImmutableList.toImmutableList()); Edit: Removed @Beta from ImmutableList.toImmutableList along with other frequently used APIs in Release 27.1 (6242bdd).
It looks like Google has finally implementing a workaround/fix for surpassing the 65K method limit of dex files. About the 65K Reference Limit Android application (APK) files contain executable bytecode files in the form of Dalvik Executable (DEX) files, which contain the compiled code used to run your app. The Dalvik Executable specification limits the … Read more