The choice greatly depends on what do you want to do with it.

If it is what mentioned in your question:

I have a collection of objects that are guaranteed to be distinct (in particular, indexed by a unique integer ID). I also know exactly how many of them there are

If this is what you need to do, the you need neither of them. There is a size() method in Collection for which you can get the size of it, which mean how many of them there are in the collection.

If what you mean for "collection of object" is not really a collection, and you need to choose a type of collection to store your objects for further processing, then you need to know, for different kind of collections, there are different capabilities and characteristic.

First, I believe to have a fair comparison, you should consider using ArrayList instead Array, for which you don't need to deal with the reallocation.

Then it become the choice of ArrayList vs HashSet, which is quite straight-forward:

Do you need a List or Set? They are for different purpose: Lists provide you indexed access, and iteration is in order of index. While Sets are mainly for you to keep a distinct set of data, and given its nature, you won't have indexed access.

After you made your decision of List or Set to use, then it is a choice of List/Set implementation, normally for Lists, you choose from ArrayList and LinkedList, while for Sets, you choose between HashSet and TreeSet.

All the choice depends on what you would want to do with that collection of data. They performs differently on different action.

For example, an indexed access in ArrayList is O(1), in HashSet (though not meaningful) is O(n), (just for your interest, in LinkedList is O(n), in TreeSet is O(nlogn) )

For adding new element, both ArrayList and HashSet is O(1) operation. Inserting in the middle is O(n) for ArrayList, while it doesn't make sense in HashSet. Both will suffer from reallocation, and both of them need O(n) for the reallocation (HashSet is normally slower in reallocation, because it involve calculation of hash for each element again).

To find if certain element exists in the collection, ArrayList is O(n) and HashSet is O(1).

There are still lots of operations you can do, so it is quite meaningless to discuss for performance without knowing what you want to do.

The HashSet is an implementation of a Set.

What data structure should I use to best implement this? Since I will be changing the property of the Student objects in set student (thereby changing the hashcodes) should I use an ArrayList instead?

If the hashcodes for the set elements are liable to change, then you should NOT be using a HashSet. (If you do, the data structure will break, and elements in the set are liable to go missing.)

But I doubt you should be using ArrayList either, because if hashcode() is sensitive to changes to the object, then equals(Object) will most likely be too. And that means that contains(...) and similar methods won't be able to find objects.

I think you should be using a Map type, and using a "student identifier" as the key.

(You could also override hashcode and equals so that equality means that two objects have the same id. But that makes equals(Object) useless for other purposes.)

Okey, so let's start with a definition of a hash function. So a hash function is such a function that given input value X will return value Y in a predefined and finite range. Sounds a bit complex but here's an example of the simplest hash function: "Take the first letter of a string". So for "apple" hash would be "a". For "banana" it would be "b" For "citrine" it would be "c". For "behemoth" it also would be "b". Range is finite - letters from "a" to "z". Giving you 24 possible outputs. For the same input you always get the same output however from a given output you will not be able to reconstruct the input. That's a primary difference between hashing and encryption actually - hashing is generally a one way process. Now, imagine we are making an array of strings that has 24 spots in it, each starting with a different letter and going alphabetically (so apple, banana, citrus, door etc). Now, we want to check if a given word exists in our array. If you did it the traditional way, you would do something like this: bool isInArray(word) { for w in wordsArray { if (w == word) {return true;} } return false; } This is an O(n) operation. You have to check an entire array to make sure a given word is or isn't in it. However, if we use our hash function (except we replace 'a' with 0, 'b' with 1... 'z' with 23) we could do it like this: bool isInArray(word) { char firstLetter = word[0]; int hashIndex = firstLetter - 97 (// -97 as https://www.asciitable.com/ - a has a numeric value 97, b is 98 and so on) return (word == wordsArray[hashIndex]); } And now we just need O(1) operations, it's constant. It doesn't matter what word you put in, it's always going to take just the first letter of it, turn it into a value from 0 to 23 and this becomes an index inside an array. Now, as you can imagine this kind of hash function is kinda worthless. You can't for instance have multiple words starting with the same letter as they would both generate the exact same hash. We could improve on it a bit - for instance rather than taking just the first letter we could take a sum of all characters (as in a numeric value), first two characters etc. This does lead us to an interesting discovery however - 2 different values can have an identical hash, depending on how you calculate it. We could still use it to make our lookups much faster however. What if we had an... array of arrays of strings! So for instance: array[0] = ['apple', 'annie', 'avocado'] array[1] = ['banana', 'bomb', 'brown'] etc. In this case such a check wouldn't be an O(1) anymore (first lookup for first character would give us an index that leads to a specific section of an array so we might have to check multiple values inside there) but it still would be much faster than checking through an entire 2D array. And this leads us to hashmaps and hashsets. Hashsets are easier to explain - they would represent our first original array of 24 words. You can check if a given word exists in this array in O(1) operations on average. Hashmaps are somewhat more complex and are more similar to example #2 - they first have a key (hash) and a value (of any type). A very simple example on how to use it would be a program that counts how many times a given word has appeared in a novel. You would first create a hashmap where a key is a string and a value is an integer. If a given string exists - you can add 1 to it's value. If it doesn't - you add it to your hashmap and set the value to 1. This is much more efficient than arrays as on average to check if a given word does or does not exist (and find corresponding value you assigned to it) takes just one operation. Rather than having to go through a whole array. Of course, in practice hash functions are not as simple as "first character" in a string and it actually takes a bit of effort and know how to find 2 different values that generate identical hash. Rest of the logic is unchanged however - you want such a mapping that that lets you allocate any input to a specific index in your array (well, not necessarily an array, I am simplifying a bit) so you can look it up much faster than usual.

With out checking things on the computer for verification, I believe a hashset is used when look for speed, but sacrifices memory in the process. Or maybe that was some other hash thing. Any way, hashing involves placing an object in an array based on a certained predefined algorithm. What this means is that if you wanted to search for this item in that array, it would give you a big O of 1, versus O(N) or O(logN) that you would get with your standard arraylist. The reason it's one is because you use the same algorithm to retrieve the location of the object your looking for based on its "hash".

Alright, I said I was a novice. So the HashSet is the object and the Set is the COLLECTIONS INTERFACE. I think I do a little better with this explanation: Look them up on the java documentation at oracle (a really invaluable resource, get used to using it: http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html) and you'll see that ArrayList is a class object and List is a collections interface. What we're doing is taking the object that is limited in what it can do and placing inside a wrapper, like putting reeses into a wrapper at the factory. Before we use the interface, the array can only be one size and is limited in what it can do in terms of organization. Before we wrap the reeses we can't ship them overseas. When we wrap the ArrayList in the interface, the interface does the resizing and organizing work the ArrayList can't. But it's not made to work without an ArrayList, , just like you wouldn't want a reeses wrapper without a reeses inside. It's not made to hold peanut butter, that''s what the reeses is for. Again, if you have a question as to whether something is an object or a collections interface, check the oracle documentation. They're designed to do very different things.

The ArrayList uses an array for storing the data. The ArrayList.contains will be of O(n) complexity. So essentially searching in array again and again will have O(n^2) complexity.

While HashSet uses hashing mechanism for storing the elements into their respective buckets. The operation of HashSet will be faster for long list of values. It will reach the element in O(1).

They're completely different classes, so the question is: what kind of behaviour do you want?

HashSet ensures there are no duplicates, gives you an O(1) contains() method but doesn't preserve order.
ArrayList doesn't ensure there are no duplicates, contains() is O(n) but you can control the order of the entries.