5 very useful ArrayList methods to remember in Java

These 5 methods will be very helpful to do away with Iterators, ConcurrentModificationException and generally tricky collection scenarios.

Let’s create two Arraylist objects to use the methods with;

1. List<City> list1 = new ArrayList<>();
2. List<City> list2 = new ArrayList<>();

And let’s create a class City and generate the equals, hashcode, toString and a constructor for it.

1. class City{
3. String name;
5. @Override
6. public String toString() {
7. return "City [name=" + name + "]";
8. }
10. public Object startsWith(String string) {
11. // TODO Auto-generated method stub
12. return null;
13. }
15. public City(String name) {
16. super();
17. this.name = name;
18. }
20. @Override
21. public int hashCode() {
22. final int prime = 31;
23. int result = 1;
24. result = prime * result + ((name == null) ? 0 : name.hashCode());
25. return result;
26. }
28. @Override
29. public boolean equals(Object obj) {
30. if (this == obj)
31. return true;
32. if (obj == null)
33. return false;
34. if (getClass() != obj.getClass())
35. return false;
36. City other = (City) obj;
37. if (name == null) {
38. if (other.name != null)
39. return false;
40. } else if (!name.equals(other.name))
41. return false;
42. return true;
43. }
45. public String getName() {
46. return name;
47. }
49. public void setName(String name) {
50. this.name = name;
51. }
53. }

Now fill the 2 lists with City objects,

1. list1.add(new City("Berlin"));
2. list1.add(new City("London"));
3. list1.add(new City("Tokyo"));
6. list2.add(new City("New Delhi"));
7. list2.add(new City("Moscow"));
8. list2.add(new City("Paris"));
9. list2.add(new City("Tokyo"));

Lets print the original first list before, the list will show the contained objects in readable format as we have implemented the toString method.

1. System.out.println("Orignal List");
2. System.out.println(list1);
4. Orignal List
5. [City [name=Berlin], City [name=London], City [name=Tokyo]]

1. retainAll: removes from this list all of its elements that are not contained in the specified collection.

1. list1.retainAll(list2);
2. System.out.println("\nAfter retainAll:"+list1);

So here we will remove all the element not present in the second list, thus only Tokyo remains in the list.

This will help you in preventing the use of Iterators.

Result: After retainAll:[City [name=Tokyo]]

2) addAll : Appends all of the elements in the specified collection to the end of this list

1. System.out.println("\nAfter addAll:"+list1);
2. list1.containsAll(list2);

This will add all the elements from the second list to the first one.No need and Iterate and Add.

Result:

After addAll:[City [name=Tokyo], City [name=New Delhi], City [name=Moscow], City [name=Paris], City [name=Tokyo]]

3) containsAll: Returns true if this list contains all of the elements of the specified collection.

1. System.out.println("\nResult of containsAll :"+list1.containsAll(list2));

As the first list contains all the elements of the second list it returns true.
Result of containsAll : true

4) Streams have been much talked addition on java8 ;

1. list1.stream().findFirst().ifPresent(System.out::println);

As you can read easily, get me the stream and then the first element if it exits, here is the result;

Stream gets you the first element:City [name=Tokyo]

5) clear() : Removes all of the elements from this list

1. list1.clear();

Result: Cleared:[]

I will emphasize that using these methods make tasks easy and bug free, also Exceptions and unnecessary code can be prevented.