Here is an algorithm that you could follow to accomplish the task: Construct a union of the two arrays Construct the intersection of the two arrays Subtract the intersection from the union to get your result Java collections support addAll, removeAll, and retainAll. Use addAll to construct unions, retainAll for constructing intersections, and removeAll for … Read more
You cannot create an array of a generic type. Instead, you can create an ArrayList<ArrayList<String>>.
ArrayList remove() relies on the objects implementation of the Equal method. If no implementation has been done then the object is removed by Object‘s implementation of Equals which indeed is the pointer comparison. From the documentation on ArrayList – More formally, removes the element with the lowest index i such that (o==null ? get(i)==null : … Read more
It doesn’t decrease this automatically. From the doc. public void trimToSize() Trims the capacity of this ArrayList instance to be the list’s current size. An application can use this operation to minimize the storage of an ArrayList instance.
Synchronized collections are a waste of time and dangerous. A trivial example why they are bad is to consider two threads running a loop at the same time on the same collection: int i = 0; while (i < list.size()) { if (testSomeCondition(list.get())) { list.remove(i); else i++; } Our list could be synchronized (e.g. a … Read more
Either: Set<Foo> fooSet = new LinkedHashSet<>(one); fooSet.addAll(two); List<Foo> finalFoo = new ArrayList<>(fooSet); or List<Foo> twoCopy = new ArrayList<>(two); twoCopy.removeAll(one); one.addAll(twoCopy);
There is nothing wrong with the idea of modifying an element inside a list while traversing it (don’t modify the list itself, that’s not recommended), but it can be better expressed like this: for (int i = 0; i < letters.size(); i++) { letters.set(i, “D”); } At the end the whole list will have the … Read more
You can use Collections.min and List.indexOf: int minIndex = list.indexOf(Collections.min(list)); If you want to traverse the list only once (the above may traverse it twice): public static <T extends Comparable<T>> int findMinIndex(final List<T> xs) { int minIndex; if (xs.isEmpty()) { minIndex = -1; } else { final ListIterator<T> itr = xs.listIterator(); T min = itr.next(); … Read more
The list is maintaining an object reference to the original value stored in the list. So when you execute this line: Integer x = i.next(); Both x and the list are storing a reference to the same object. However, when you execute: x = Integer.valueOf(9); nothing has changed in the list, but x is now … Read more
ArrayList has a indexOf() method. Check the API for more, but here’s how it works: private ArrayList<String> _categories; // Initialize all this stuff private int getCategoryPos(String category) { return _categories.indexOf(category); } indexOf() will return exactly what your method returns, fast.