To use a Comparator: Collections.sort(myList, new Comparator<Chromosome>() { @Override public int compare(Chromosome c1, Chromosome c2) { return Double.compare(c1.getScore(), c2.getScore()); } }); If you plan on sorting numerous Lists in this way I would suggest having Chromosome implement the Comparable interface (in which case you could simply call Collections.sort(myList), without the need of specifying an explicit … Read more
You should use Java’s built in serialization mechanism. To use it, you need to do the following: Declare the Club class as implementing Serializable: public class Club implements Serializable { … } This tells the JVM that the class can be serialized to a stream. You don’t have to implement any method, since this is … Read more
The sorting part can be done by implementing a custom Comparator<Vehicle>. Collections.sort(vehiclearray, new Comparator<Vehicle>() { public int compare(Vehicle v1, Vehicle v2) { return v1.getEmail().compareTo(v2.getEmail()); } }); This anonymous class will be used for sorting the Vehicle objects in the ArrayList on the base of their corresponding emails alphabetically. Upgrading to Java8 will let you also … Read more
You have ArrayList all wrong, You can’t have an integer array and assign a string value. You cannot do a add() method in an array Rather do this: List<String> alist = new ArrayList<String>(); alist.add(“apple”); alist.add(“banana”); alist.add(“orange”); String value = alist.get(1); //returns the 2nd item from list, in this case “banana” Indexing is counted from 0 … Read more
Try this Object obj = ois.readObject(); // Check it’s an ArrayList if (obj instanceof ArrayList<?>) { // Get the List. ArrayList<?> al = (ArrayList<?>) obj; if (al.size() > 0) { // Iterate. for (int i = 0; i < al.size(); i++) { // Still not enough for a type. Object o = al.get(i); if (o … Read more
java.util.Arrays.asList() produces a list from which it is impossible to remove elements, so it throws on a removal attempt. You could wrap it with ArrayList: List<Integer> ints = new java.util.ArrayList<>(java.util.Arrays.asList(1,20,20)); Update Arrays.asList() returns return new ArrayList<>(a); where ArrayList is not java.util.ArrayList, but java.util.Arrays.ArrayList (internal class), which does not allow removal.
It’s the initial capacity, i.e. the number of items that ArrayList will allocate to begin with as the internal storage of items. ArrayList can contain “any number of items” (as long you have the memory for it) and when doing large initial insertions you can tell ArrayList to allocate a larger storage to begin with … Read more
The alternative is to use the @Mock annotation since then Mockito can use type reflection to find the generic type: public class MyTest { @Mock private ArrayList<String> mockArrayList; … public void setUp() { MockitoAnnotations.initMocks(this); } public void testMyTest() { when(mockArrayList.get(0)).thenReturn(“Hello world”); String result = mockArrayList.get(0); assertEquals(“Should have the correct string”, “Hello world”, result); verify(mockArrayList).get(0); } … Read more
The best resource is straight from the official API: The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O(n) time. All of the other operations run in linear time (roughly speaking). The constant factor is low compared … Read more
You can extend any class that is not final in Java. Having said that, you should avoid inheritance if there is no true is-a relationship. Consider composition for reuse. Read about Liskov substitution principle