Depends on your data;

HashSet gives you an O(1) contains() method but doesn't preserve order.

ArrayList contains() is O(n) but you can control the order of the entries.

Array if you need to insert anything in between, worst case can be O(n), since you will have to move the data down and make room for the insertion. In Set, you can directly use SortedSet which too has O(n) too but with flexible operations.

I believe Set is more flexible.

A simple array is not dynamic, meaning that you only get two spots in the array where as the array list will expand as needed. In your example the array would error if you added a third string while in the list you can add strings effectively infinitely (not LITERALLY true but true enough for practical purposes). Now why would you want to use the simple array because it's less overhead and faster. With the array list you want to pass the size you think it will be to the constructor if you can, because basically the way the array list works is when it hits its size limit it makes a new array list that's double the length and copies the old contents into it, so the fewer times you have to do that the better.

Arrays and ArrayLists are both used for the same thing (storing more than one object), but are used in different places.

The main difference between the two is that ArrayLists can "grow" but arrays can't. That is to say, when I make a new array, I have to tell Java how big it is. Like so:

int[] bunchOfNumbers = new int[50];

This makes an array that can hold 50 integers.

However, if we were to do this with an arraylist, we don't have to tell it how big to go, so we can just write :

ArrayList<Integer> bunchOfNumbers = new ArrayList<Integer>();

So, what do these differences mean?

Well, for one thing, we can't add any more than 50 numbers to our array. On the other hand, we can add as many numbers to the ArrayList as we damn well please.

The downside to ArrayLists is hard to understand without knowing how ArrayLists work, so I'll do that first.

An ArrayList is, at its core, an array. However, because a standard Array can't grow, it needs to pay attention to if you are going to over-extend. If you are, it creates a new bigger array, copies over the elements in the old array, and then adds your new value to it.

Now we can understand that adding things to an ArrayList can take time because we have to copy the previous array when it has to grow.

So, to conclude
Array

• Very fast

• Can't grow past their initial limit.

ArrayList

• Can be slower

• Can grow very large on demand

If you have any questions, feel free to ask. There are also other Lists in java that might be of use to you like the LinkedList, which has very fast insertion and deletion but is slow if you need to pull a specific element out of it.

List is an ordered sequence of elements whereas Set is a distinct list of elements which is unordered (thank you, Quinn Taylor).

List<E>:

An ordered collection (also known as a sequence). The user of this interface has precise control over where in the list each element is inserted. The user can access elements by their integer index (position in the list), and search for elements in the list.

Set<E>:

A collection that contains no duplicate elements. More formally, sets contain no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element. As implied by its name, this interface models the mathematical set abstraction.

Map implementation:

public final class Person
{
  ... remainder left to the student ...
}

Map<Person, Date> currentPartyAttendees; // date is arrival time.

Set implementation:

public final class PartyAttendee
{
  ... person details ...
  Date arrive;

  int hashcode()
  {
    ... use Apache HashCodeBuilder ... 
  }

  boolean equals(Object other)
  {
    ... implementation left to student.  Use Apache EqualsBuilder ...
  }
}

Set<PartyAttendee> currentPartyAttendees;

this is a nice example of why it's helpful to know data structures. it's not to solve leetcode problems, it's to know when to use what. so you know what an array is, you declare an array size and you can access elements with O(1) run time, but if you want to reorder things, you have to shift all the elements downstream, which takes more time.

"List" in Java is just in interface, you have to specify what type of list you want to use. There are several list types to choose from, most commonly a LinkedList or ArrayList. An interface is just a set of Methods, so whatever list type you create will have those methods to choose from, but they may be implemented differently behind the scenes.

An ArrayList in Java is maybe somewhat misleadingly named. It's just a dynamically sized array that has the Methods of a list. You don't have to declare a size for an ArrayList. It will automatically allocate a size for you, without telling you because you don't care, and if you reach the limit of the allocated size it'll add some more size for you without you needing to do anything. I think it creates a new, bigger array to do this, but I'm not 100% sure. So, use an ArrayList when you want the O(1) access run time of an array, but the size of the array is unknown or changing. If you're familiar with Python, what Python calls a List is essentially the same thing as what Java calls an ArrayList.