The document describes Java List interfaces and common implementations like ArrayList and LinkedList. It provides examples of initializing List with different data types, adding/inserting elements, and sorting a List using Collections.sort(). Key points covered include declaring List with generic types, initializing capacity for ArrayList, copying elements between Lists, and sorting Lists into natural ascending order.

1. Write a java class "LIST" that outputs:
//main:
public class AssignmentThree
{
public static void main(String[] args)
{
List myList = new List(15);
// Cause List Empty Message
myList.removeFront();
myList.removeRear();
myList.removeItem("a");
// Cause Not found message
myList.addToFront("x");
myList.removeItem("y");
myList.removeItem("x");
myList.addAfterItem("x", "z");
myList.addBeforeItem("x", "z");
// Normal behavior
myList.addToFront("not.");
myList.addToFront("or");
myList.addToRear("is");
myList.addToRear("try.");
myList.addAfterItem("is", "no");
myList.addBeforeItem("is", "There");
myList.addToFront("Do");
myList.addAfterItem("or", "do");
myList.print("Original list");
myList.printSorted("Sorted Original List");
sop(" Front is " + myList.getFront());
sop("Rear is " + myList.getRear());

2. sop("Count is " + myList.askCount());
sop("Is There present? " + myList.isPresent("There"));
sop("Is Dog present? " + myList.isPresent("Dog"));
myList.addToFront("junk");
myList.addToRear("morejunk");
myList.addAfterItem("or", "moremorejunk");
myList.print("List with junk");
sop("Count is " + myList.askCount());
myList.removeFront();
myList.removeRear();
myList.removeItem("moremorejunk");
myList.print("List with junk removed");
sop("Count is " + myList.askCount());
sop("");
// Cause List Full message
for(int ii = 0; ii < 10; ++ii)
{
myList.addToFront(DUMMY);
}
myList.addToRear(DUMMY);
myList.addBeforeItem("no", DUMMY);
myList.addAfterItem("There", DUMMY);
myList.print("After filling List");
sop("Count is " + myList.askCount());
while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY);
myList.print("After removing " + DUMMY );
sop("Count is " + myList.askCount());
}

3. private static void sop(String s)
{
System.out.println(s);
}
private static final String DUMMY = "dummy";
}
//Class List:
public class List {
public List(int size)
{
}
public void addToFront(java.lang.String item)
{
}
public void addToRear(java.lang.String item)
{
}
public void addBeforeItem(java.lang.String beforeItem,
java.lang.String item)
{
}
public void addAfterItem(java.lang.String afterItem,
java.lang.String item)
{
}
public java.lang.String getFront()
{
}

4. public java.lang.String getRear()
{
}
public boolean isPresent(java.lang.String item)
{
}
public int askCount()
{
}
public void removeFront()
{
}
public void removeRear()
{
}
public void removeItem(java.lang.String item)
{
}
public void print(java.lang.String title)
{
}
public void printSorted(java.lang.String title)
{
}
}
Solution

5. The List is the base interface for all list types, and the ArrayList and LinkedList classes are two
common List’s implementations.
Besides ArrayList and LinkedList, Vector class is a legacy collection and later was retrofitted to
implement the Listinterface. Vector is thread-safe, but ArrayList and LinkedList are not. The
following class diagram depicts the inheritance tree of the List collections.
It’s a good practice to declare a list instance with a generic type parameter, for example:
1
2
3
4
List listAnything = new ArrayList();
List listWords = new ArrayList();
List listNumbers = new ArrayList();
List linkedWords = new LinkedList();
Since Java 7, we can remove the type parameter on the right side as follows:
1
2
List listNumbers = new ArrayList<>();
List linkedWords = new LinkedList<>();
The compiler is able to infer the actual type parameter from the declaration on the left side.
When creating a new ArrayList using the empty constructor, the list is constructed with an initial
capacity of ten. If you are sure how many elements will be added to the list, it’s recommended to
specify a capacity which is large enough. Let’s say, if we know that a list contains around 1000
elements, declare the list as follows:
1
List listNumbers = new ArrayList<>(1000);
It’s also possible to construct a list that takes elements from an existing collection, for example:
1
2
3
List listNumberOne; // existing collection
List listNumberTwo = new ArrayList<>(listNumberOne);
The listNumberTwo constructed with copies of all elements from the listNumberOne.The
methods add(Object), add(index, Object) and addAll() are used to add elements to the list. It
requires to add elements of the same type (or sub type) as the type parameter declared by the list.
For example:

6. 1
2
3
4
5
6
7
8
9
List listStrings = new ArrayList();
// OK to add Strings:
listStrings.add("One");
listStrings.add("Two");
listStrings.add("Three");
// But this will cause compile error
listStrings.add(123);
Adding elements of sub types of the declared type:
1
2
3
4
5
6
List linkedNumbers = new LinkedList<>();
linkedNumbers.add(new Integer(123));
linkedNumbers.add(new Float(3.1415));
linkedNumbers.add(new Double(299.988));
linkedNumbers.add(new Long(67000));
We can insert an element into the list at a specified indexThe simplest way to sort out elements
in a list is using the Collections.sort() static method which sorts the specified list into ascending
order, based on the natural ordering of its elements. Here’s an example:
1
2
3
4
5

7. 6
7
8
9
10
11
12
List listStrings = new ArrayList();
listStrings.add("D");
listStrings.add("C");
listStrings.add("E");
listStrings.add("A");
listStrings.add("B");
System.out.println("listStrings before sorting: " + listStrings);
Collections.sort(listStrings);
System.out.println("listStrings after sorting: " + listStrings);
Output:
1
2
listStrings before sorting: [D, C, E, A, B]
listStrings after sorting: [A, B, C, D, E]
1
2
3
4
List listAnything = new ArrayList();
List listWords = new ArrayList();
List listNumbers = new ArrayList();
List linkedWords = new LinkedList();