You don’t need to re-add the ArrayList back to your Map. If the ArrayList already exists then just add your value to it. An improved implementation might look like: Map<String, Collection<String>> map = new HashMap<String, Collection<String>>(); while processing each line: String user = user field from line String value = value field from line Collection<String> … Read more
You can get an empty list of type Foo through the following syntax: return Collections.<Foo>emptyList().iterator();
How exactly Iterator removes elements depends on its implementation, which may be different for different Collections. Definitely it doesn’t break the loop you’re in. I’ve just looked how ArrayList iterator is implemented and here’s the code: public void remove() { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { ArrayList.this.remove(lastRet); cursor = lastRet; lastRet … Read more
Edit January 1, 2014 Apache Commons Collections 4.0 was finally released on November 21, 2013, and contains a fix for this issue. Link to CollectionUtils.java Lines in question (1688 – 1691), with acknowledgement the method was previously broken: /* … * @since 4.0 (method existed in 3.2 but was completely broken) */ public static <E> … Read more
Because toArray() creates an array of Object, and you can’t make Object[] into DataObject[] just by casting it. toArray(DataObject[]) creates an array of DataObject. And yes, it is a shortcoming of the Collections class and the way Generics were shoehorned into Java. You’d expect that Collection<E>.toArray() could return an array of E, but it doesn’t. … Read more
You’re after the symmetric difference. This is discussed in the Java tutorial. Set<Type> symmetricDiff = new HashSet<Type>(set1); symmetricDiff.addAll(set2); // symmetricDiff now contains the union Set<Type> tmp = new HashSet<Type>(set1); tmp.retainAll(set2); // tmp now contains the intersection symmetricDiff.removeAll(tmp); // union minus intersection equals symmetric-difference
The ICollection<T> interface doesn’t specify anything about an order. The objects will be in the order specified by the object returned. For example, if you return the Values collection of a SortedDictionary, the objects will be in the the order defined by the dictionary’s comparer. If you need the method to return, by contract, a … Read more
Why would you want those for a regular HashMap or LinkedHashMap? You can just do this: Map<String, Object> map = Maps.newHashMap(); map.put(key, value); The thing with ImmutableMap is that it is a little bit more cumbersome to create; you first need to make a Builder, then put the key-value pairs in the builder and then … Read more
Prefer Collection (or List, or Set as appropriate) to an array. With generics you get the type-checking that was lacking pre-Java 5. Also, by exposing only the interface, you are free to change the implementation later (e.g. switch an ArrayList for a LinkedList). Arrays and generics don’t mix very well. So, if you want to … Read more
Made a quick implementation myself: public class ObservableCollectionEx<T> : ObservableCollection<T> where T : INotifyPropertyChanged { protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) { Unsubscribe(e.OldItems); Subscribe(e.NewItems); base.OnCollectionChanged(e); } protected override void ClearItems() { foreach(T element in this) element.PropertyChanged -= ContainedElementChanged; base.ClearItems(); } private void Subscribe(IList iList) { if (iList != null) { foreach (T element in iList) element.PropertyChanged … Read more