Question

10.3 Example. When you first declare a new list, it is empty and its length is zero. If you add three objects—a, b, and c—one at a time and in the order given, to the end of the list, the list will appear as

a b c

The object a is first, at position 1, b is at position 2, and c is last at position 3.1 To save space here, we will sometimes write a list’s contents on one line. For example, we might write

1. Some people number the entries in a list beginning with 0 instead of 1.
abc
to represent this list.
The following pseudocode represents the previous three additions to the specific list myList:

myList.add(a) myList.add(b) myList.add(c)

At this point, myList is not empty, so myList.isEmpty() is false. Since the list contains three entries,myList.getLength() is 3. Notice that adding entries to the end of a list does not change the positions of entries already in the list.

Write a Java program to do the six ADT list operations shown in Figure 10-2, p297, and display the final list. Use the JavaClassLibrary List (see page 308) for the interface and ArrayListfor the implementation.

Is it better to number the entries in a list beginning with 0 instead of 1?

Attach the lab and copyAndPaste the output. SR

Figure 10-2

Java Class Library: The Interface List

1. 10.19 The standard package java.util contains an interface List for an ADT list that is similar to the list that our interface describes. One difference between a list in the Java Class Library and our ADT list is the numbering of a list’s entries. A list in the Java Class Library uses the same numbering scheme as a Java array: The first entry is at position, or index, 0. In contrast, we begin our list at position 1. The interface List also declares more methods than our interface does. You’ll see a few of those additional methods in Java Interlude 4.

The following method headers from the interface List are for a selection of methods that are similar to the ones you have seen in this chapter. We have highlighted where they differ from our methods. Once again, T is the generic type of the entries in the list.

public boolean add(T newEntry)
public void add(int index, T newEntry)
public T remove(int index)
public void clear()
public T set(int index, T anEntry) // Like replace public T get(int index) // Like getEntry public boolean contains(Object anEntry)
public int size() // Like getLength public boolean isEmpty()

The first add method, which adds an entry to the end of a list, returns a boolean value, whereas our analogous method is a void method. The method set is like our replace method, and the method get is like our method getEntry. The data type of contains’ parameter is Object instead of a generic type. In practice, this difference has little consequence. Lastly, the method size is like our getLength.

You can learn more about the interface List in the online documentation for the Java Class Library.

Java Class Library: The Class ArrayList

10.20 The Java Class Library contains an implementation of the ADT list that uses a resizable array. This class, called ArrayList, implements the interface java.util.List, that we just discussed. The class also is in the package java.util.

Two of the constructors available for ArrayList are as follows: public ArrayList()

Creates an empty list with an initial capacity of 10. The list increases its capacity as needed by an unspecified amount.

public ArrayList(int initialCapacity)
Creates an empty list with the specified initial capacity. The list increases its capacity as needed by an

unspecified amount.

10.21 The class java.util.Vector, which we described in Chapter 6 , is similar to ArrayList. Both classes implement the same interfaces: java.util.List, as well as others. Even so, Vector contains a few more methods than ArrayList. We will ignore these extra methods, as they mostly are redundant.

You can use either ArrayList or Vector as an implementation of the interface List. For example, you could write either of the following statements to define a list of strings:

List<String> myList = new ArrayList<>();
or
List<string> myList = new Vector<>();
Now myList has only the methods declared in the interface List.

Answer 1

import java.util.ArrayList;
import java.util.List;

public class ListOperations<T> {
    public static void main(String[] args) {
        List<String> myList = new ArrayList<>();
        // add item to the list
        myList.add("a");
        myList.add("c");
        // add item to the specified index of list
        myList.add(1, "b");
        System.out.println("List:");
        for(int i=0;i<myList.size();i++)
            System.out.print(myList.get(i)+" ");
        System.out.println();
        System.out.println("check 'b' is in the list or not");
        System.out.println(myList.contains("b"));
        System.out.println("check 'd' is in the list or not");
        System.out.println(myList.contains("d"));
        System.out.println("Number of items in the list");
        System.out.println(myList.size());
        System.out.println("Remove item in the position 1");
        myList.remove(1);
        System.out.println("List after removal");
        for(int i=0;i<myList.size();i++)
            System.out.print(myList.get(i));
        System.out.println();
        System.out.println("Remove all items");
        myList.clear();
        System.out.println("List after removal");
        for(int i=0;i<myList.size();i++)
            System.out.print(myList.get(i));
        System.out.println();
        System.out.println("check list is emty or not");
        System.out.println(myList.isEmpty());
    }
}

OUTPUT

Array is continuous space in memory. And OS stores the address from where elements start. Assume address of first element is 1001. If we want to know 10th element, it will be at an offset on 10 from 1001. So, offset is the reason why array indices start from 0.