Code360 powered by Coding Ninjas X Naukri.com. Code360 powered by Coding Ninjas X Naukri.com
Table of contents
1.
Introduction
2.
Class Hierarchy
3.
Class Declaration
3.1.
Syntax:
3.2.
Explanation:
4.
Constructor
4.1.
Syntax:
4.2.
Explanation:
5.
Package
6.
Example 1
6.1.
Code :
6.2.
Output :
6.3.
Explanation :
7.
Example 2
7.1.
Code :
7.2.
Output:
7.3.
Explanation :
8.
Methods Inherited
8.1.
Functions of Abstract Sequential List
8.2.
Functions inherited from abstract list and Collection packages.
9.
FAQs
9.1.
What are the packages that we need to import for abstract sequential lists?
9.2.
Why do we need a Collection Framework?
10.
Conclusion
Last Updated: Mar 27, 2024
Easy

Abstract Sequential List

Author Ayushi Poddar
0 upvote

Introduction

Abstract Sequential List is a class type part of the Java Collection Framework used to implement the Collection Interface and Abstract Collection class. In Java, a specified framework is named the “ Collection Framework, “  defined in JDK 1.2. This framework holds all the collection classes and interfaces, and Abstract Sequenced List is one such example. A collection Framework is a group of individual objects represented as a single unit known as a collection of things.

The class belonging to the Abstract Sequential List provides us with a skeletal implementation of the List interface in order to make the efforts as less as possible to make an interface that is backed by a “sequential access’ data store, for example, a linked list and for random access data, an array.

Also read, Duck Number in Java and Hashcode Method in Java

Class Hierarchy

Below is the class hierarchy that is followed for implementing Abstract Sequential List.

Get the tech career you deserve, faster!
Connect with our expert counsellors to understand how to hack your way to success
User rating 4.7/5
1:1 doubt support
95% placement record
Akash Pal
Senior Software Engineer
326% Hike After Job Bootcamp
Himanshu Gusain
Programmer Analyst
32 LPA After Job Bootcamp
After Job
Bootcamp

Class Declaration

The correct syntax for declaring the class for implementation of Abstract Sequential List is as follows.

Syntax:

public abstract class AbstractSequentialList<E> extends AbstractList<E>

Explanation:

Here 'E' is the type of element that is to be maintained by this list. The above declaration implements Iterable<E> , Collection<E> , List<E> interfaces. LinkedList is the only direct subclass under Abstract Sequential List.

AbstractSequentialList is an abstract class, and it has a default constructor - 'protected AbstractSequentialList() 'hence it doesn't allow us to create an AbstractSequentialList object and the syntax for the same is :

AbstractSequentialList<E> asl = new LinkedList<E>();  

Constructor

“ protected AbstractSequentialList() “ is the default constructor and as it is kept protected, it doesn’t allow to create an AbstractSequentialList object.

Syntax:

AbstractSequentialList<E> asl = new LinkedList<E>();  

Explanation:

The Abstract Sequential List is an abstract class, that is the reason why it should be assigned an instance of it’s subclass.

Package

In order to work with the Abstract Sequential List class in Java, we also need to import the necessary packages, which are as follows :

import java.util.AbstractSequentialList;

Example 1

Now let's take up a small example of a shortcode to understand how we need to deal with the implementation of an Abstract Sequential List.

Code :

import java.util.AbstractSequentialList;
import java.util.*;
  
public class List1 {
  
    public static void main(String[] args)
    {
        AbstractSequentialList<Integer> list1= new LinkedList<>(); //Created an instance
        list1.add(99); // Adding elements to the list
        list1.add(100);
        list1.add(101);
        System.out.println(list1); // Printing all the elements of the list
    }
}

Output :

[99, 100, 101]

Explanation :

Here we first imported the required packages - util and AbstractSequentialList. After creating the main method, we created an instance of the abstract class named 'list1'. Further, we used the predefined function' .add( ) 'to add elements to this created list, one after the other. We then printed the entire list by just typing it inside the println statement.

Example 2

Let's try out a program where we use some other predefined functions as well.

Code :

import java.util.*;
import java.util.AbstractSequentialList;
  
public class AbstractSequentialListExample {
public static void main(String args[])
    {
AbstractSequentialList<String> list1 = new LinkedList<String>(); //Created an instance
            list1.add("Hey"); // Adding elements to the list
            list1.add("there !");
            list1.add("Hope,");
            list1.add("you");
            list1.add("are doing great");
          System.out.println("AbstractSequentialList: "+list1); // Printing all the elements of the list
          list1.remove(0); // Removing element from the list
          list1.remove(1);
            System.out.println("Final List: "+ list1);
            System.out.println("The element is: "+ list1.get(4)); // Accessing an element from the list
    }
}

Output:

AbstractSequentialList: [Hey, there!, Hope, you, are doing great]
Final List: [Hope, you, are doing great]
The element is: are doing great


Practice by yourself on online java compiler.

Explanation :

Here we first imported the required packages - util and AbstractSequentialList. After creating the main method, we created an instance of the abstract class named 'list1', and this time, the list would contain string elements. Further, we used the predefined function' .add( ) 'to add elements to this created list, one after the other. We printed the entire list by just typing it inside the println statement. We also tried using the function 'remove( ) 'to remove elements from the list, and finally, we also used the function 'get( ) 'to access an element from the list.

Methods Inherited

Functions of Abstract Sequential List

  • add(int index, Element)
    This function inserts the given element at the specified position in the list.
  • addAll(int index, Collection C)
    This function inserts all the elements in the specified collection into this list at the specified position.
  • get(int index)
    This function returns the element at the specified position in the list.
  • set(int index, Element)
    This function replaces the element at the specified position in the list with the specified element.

Functions inherited from abstract list and Collection packages.

  • clear()
    This function removes all of the elements from the list.
  • hashCode()
    This function returns the hash code value for the list.
  • subList(int from, int last)
    This function returns a portion of the list between the specified index position 'from' to 'last.'
  • removeAll(Collection<?>C)
    This function removes all of the collection's elements that are also contained in the specified collection.
  • addAll(Collection<?extends E>c)
    This function appends all of the elements in the specified collection to the end of this list.
  • size()
    This function returns the size of the list.

    Must Read Array of Objects in Java

FAQs

What are the packages that we need to import for abstract sequential lists?

The two most needed packages that we need to import are Java.util and java.util.AbstractSequentialList.

Why do we need a Collection Framework?

Before JDK 1.2, there were standard methods for grouping Java objects such as Arrays, Vectors, or hashtables, but none of these had a common interface, which on the contrary sequential lists have.

Conclusion

This article extensively discussed the Abstract Sequential List and the concept of its interfaces and its implementation. Abstract Sequenced List is a class type that is a part of the Java Collection Framework and which is used for the implementation of the Collection Interface and Abstract Collection class. We hope that this blog has helped you enhance your knowledge regarding Abstract Sequential Lists and if you would like to learn more, check out our articles on Coding Ninjas

Recommended Readings:

Do upvote our blog to help other ninjas grow. Happy Coding!

 

Previous article
Abstract List
Next article
CopyOnWriteArrayList
Live masterclass