If the order of the elements is not important, you can use: List<MyObject> newList = new List<MyObject>(listOfObjects) { object1 }; This works by using the List<T> constructor which accepts an IEnumerable<T>, then the collection initializer to add the other items. For example, the following: static void Main() { int test = 2; List<int> test2 = … Read more
I later realized that I don’t really use the values contained in my Map so a List will suffice. Map isn’t just a list of key-value pairs, it is a unique mapping from keys to values. So when you change from Map to List, you are allowing duplicates where you previously didn’t. On the other … Read more
List<T> already implements Collection<T> – why would you need to create a new one? Collection<T> collection = myList; The error message is absolutely right – you can’t directly instantiate an interface. If you want to create a copy of the existing list, you could use something like: Collection<T> collection = new ArrayList<T>(myList);
In your case, the same key is related to multiple values, so standard dictionary is not suitable, as is. You can declare it like Dictionary<Key, List<Values>>. But, also, you can use: Lookup class, which is Represents a collection of keys each mapped to one or more values. You need framework 3.5 and more, for this.
Assuming K is your key type and V is your value type: for (Map.Entry<K,V> entry : map.entrySet()) { K key = entry.getKey(); V value = entry.getValue(); // do stuff }
You should use Comparator.nullsLast twice: list.sort(nullsLast(comparing(Bean::getVal, nullsLast(naturalOrder())))); First nullsLast will handle the cases when the Bean objects are null. Second nullsLast will handle the cases when the return value of Bean::getVal is null. In case you’re sure there aren’t any null values in your list then you can omit the first nullsLast (as noted by … Read more
I think the LinkedHashMap has to be faster in traversal due to a superior nextEntry implementation in its Iterator Here is why : Let us go step by step from the values implementation. The HashMap implementation of values is this : public Collection<V> values() { Collection<V> vs = values; return (vs != null ? vs … Read more
return new ArrayList(new HashSet(recipients));
There’s probably a built-in method to do it somewhere* (as you note, Arrays.asList won’t work as it expects an Integer[] rather than an int[]). I don’t know the Java libraries well enough to tell you where that is. But writing your own is quite simple: public static List<Integer> createList(int[] array) { List<Integer> list = new … Read more
Stream<String> stringStream = stringList.stream(); String coolest = stringStream.reduce((a,b)-> coolnessIndex(a) > coolnessIndex(b) ? a:b; ).get() if calling coolnessIndex is expensive we can use distinct so it’s called only for distinct elements (assuming that the coolnesIndex is the same for equal elements) Stream<String> stringStream = stringList.stream().distinct(); String coolest = stringStream.reduce((a,b)-> coolnessIndex(a) > coolnessIndex(b) ? a:b; ).get() Stream … Read more