What are some really common data structures, e.g. in java.util?

Array :

Arrays are the most commonly used data structure.
The length of an array is established when the array is created.
After creation, its length is fixed.
It Contains elements of the same type (i.e. a homogeneous collection).
For Example, you can only store a String in a String[], if you will try to store Integer, you will get ArrayStoreException at runtime.
Each item in an array is called an element, and each element is accessed by its numerical index.
Java programming language provides built-in support for an array in the language itself.
It has a special syntax to declare array e.g. int[] , which is an array of int primitive type.
Declares an array of integers : int[] anArray;

LinkedList :

LinkedLists are data structures made of nodes.
Each node contains data and a reference to the next node, and possibly to the previous node as well for a doubly linked list.
For example, a stack or queue can be implemented with a linked list or a doubly linked list because you can insert and delete at both ends.
There would also be other situations where data will be frequently inserted and deleted from the middle.
The Apache library provides a TreeList implementation, which is a good replacement for a LinkedList as it performs much better than a LinkedList at the expense of using a little more memory.
This means a LinkedList is rarely a good choice of implementation.

Stack :

Stacks allow access to only one data item, which is the last item inserted (i.e. Last In First Out - LIFO).
If you remove this item, you can access the next-to-last item inserted, and so on.
The LIFO is achieved through restricting access only via methods like peek( ), push( ), and pop( ).
This is useful in many programming situations like parsing mathematical expressions like (4+2) * 3, storing methods and exceptions in the order they occur, checking your source code to see if the brackets and braces are balanced properly, etc.
The LIFO access mechanism used by a stack has many practical uses.
For example, Evaluation of expressions / syntax Parsing, validating and parsing XML, undo sequence in a text editor, pages visited history in a web browser, etc.

Queue :

Queues are somewhat like a stack, except that in a queue the first item inserted is the first to be removed (i.e. First In First Out – FIFO).
The FIFO is achieved through restricting access only via methods like peek( ), offer( ), and poll( ).
For example, waiting in a line for a bus, a queue at the bank or supermarket teller, etc.

HashMap / HashTable :
(Check difference here : http://www.muktadadariya.com/2016/11/hashmap-vs-hashtable-java.html)

Every HashMaps / HashTables stores data in the form of (key, value) combination.
Every key is Unique.
But values can repeat which means the value can be same as different key present in it.
Computing a hash value doesn't depend on the number pf itmes in tha hash table.
HashMaps / HashTables provides you constant time O(1) functionality for getting a value back if you know the key, which is a very natural use case in most of the java application.
HashMaps / HashTables are amortized constant-time access data structures that map keys to values.
This data structure is backed by the real array in memory.
It uses a hashing functionality to identify a location, and some type of collision detection algorithm is used to handle values that hash to the same location.

Trees :

Trees are the data structures that contain nodes with optional data elements and one or more child elements, and possibly each child element references the parent element to represent a hierarchical or ordered set of data elements.
For example, a hierarchy of employees in an organization, storing the XML data as a hierarchy, etc.
If every node in a tree can have utmost 2 children, the tree is called a binary tree.
The binary trees are very common because the shape of a binary tree makes it easy to search and insert data.
The edges in a tree represent quick ways to navigate from node to node.

List :

Lists are known as arrays that can grow.
These data structures are generally backed by a fixed sized array and they re-size themselves as necessary.
A list can have duplicate elements.
For example, adding new line items to an order that stores its line items as a list, removing all expired products from a list of products, etc.
Initialize them with an appropriate initial size to minimize the number of re-sizes

Set :

Graph :

Graphs are data structures that represent arbitrary relationships between members of any data sets that can be represented as networks of nodes and edges.
A tree structure is essentially a more organized graph where each node can only have one parent node.
Unlike a tree, a graph's shape is dictated by a physical or abstract problem.
For example, nodes (or vertices) in a graph may represent cities, while edges may represent airline flight routes between the cities.
To make a Java graph class, you will have to work out the way in which the information can be stored and accessed.
A graph will be using some of the data structures mentioned above.
The Java API does not provide an implementation for this.
But there are a number of third party libraries like JUNG, JGraphT, and JDSL (does not seem to support generics).

Mukta's World...