Interface List
An ordered collection (also known as a sequence). The user of this interface has precise control over where in the list each element is inserted. The user can access elements by their integer index (position in the list), and search for elements in the list.
Unlike sets, lists typically allow duplicate elements. More formally, lists typically allow pairs of elements e1 and e2 such that e1.equals(e2) , and they typically allow multiple null elements if they allow null elements at all. It is not inconceivable that someone might wish to implement a list that prohibits duplicates, by throwing runtime exceptions when the user attempts to insert them, but we expect this usage to be rare.
The List interface places additional stipulations, beyond those specified in the Collection interface, on the contracts of the iterator , add , remove , equals , and hashCode methods. Declarations for other inherited methods are also included here for convenience.
The List interface provides four methods for positional (indexed) access to list elements. Lists (like Java arrays) are zero based. Note that these operations may execute in time proportional to the index value for some implementations (the LinkedList class, for example). Thus, iterating over the elements in a list is typically preferable to indexing through it if the caller does not know the implementation.
The List interface provides a special iterator, called a ListIterator , that allows element insertion and replacement, and bidirectional access in addition to the normal operations that the Iterator interface provides. A method is provided to obtain a list iterator that starts at a specified position in the list.
The List interface provides two methods to search for a specified object. From a performance standpoint, these methods should be used with caution. In many implementations they will perform costly linear searches.
The List interface provides two methods to efficiently insert and remove multiple elements at an arbitrary point in the list.
Note: While it is permissible for lists to contain themselves as elements, extreme caution is advised: the equals and hashCode methods are no longer well defined on such a list.
Some list implementations have restrictions on the elements that they may contain. For example, some implementations prohibit null elements, and some have restrictions on the types of their elements. Attempting to add an ineligible element throws an unchecked exception, typically NullPointerException or ClassCastException . Attempting to query the presence of an ineligible element may throw an exception, or it may simply return false; some implementations will exhibit the former behavior and some will exhibit the latter. More generally, attempting an operation on an ineligible element whose completion would not result in the insertion of an ineligible element into the list may throw an exception or it may succeed, at the option of the implementation. Such exceptions are marked as «optional» in the specification for this interface.
Unmodifiable Lists
- They are unmodifiable. Elements cannot be added, removed, or replaced. Calling any mutator method on the List will always cause UnsupportedOperationException to be thrown. However, if the contained elements are themselves mutable, this may cause the List’s contents to appear to change.
- They disallow null elements. Attempts to create them with null elements result in NullPointerException .
- They are serializable if all elements are serializable.
- The order of elements in the list is the same as the order of the provided arguments, or of the elements in the provided array.
- The lists and their subList views implement the RandomAccess interface.
- They are value-based. Programmers should treat instances that are equal as interchangeable and should not use them for synchronization, or unpredictable behavior may occur. For example, in a future release, synchronization may fail. Callers should make no assumptions about the identity of the returned instances. Factories are free to create new instances or reuse existing ones.
- They are serialized as specified on the Serialized Form page.
This interface is a member of the Java Collections Framework.
Store User-defined Class Objects in ArrayList
In this tutorial, we will learn how to store user-defined (custom) class objects in Java ArrayList in an easy way and step by step.
In the previous ArrayList tutorial, we have learned that ArrayList class uses generic from Java 1.5 or later. Using generic, ArrayList class can be used to store any type of object.
In other words, we can store multiple types of objects in an ArrayList using generic feature.
For example, we could have an ArrayList of Book objects, an ArrayList of Employee objects, or an ArrayList of Strings. The specified type must be a class, not a primitive type.
If you want to store primitive data types in ArrayList, you will have to use one of java wrapper classes such as Integer, Double, or Character.
Declaration of ArrayList Objects
The syntax for declaring an ArrayList of objects is as follows:
Inside angle brackets, we declare the class types of objects that will be stored in ArrayList. Let’s understand with the help of some examples.
1. ArrayList emp = new ArrayList(); // Here, Employee is the name of class. // ArrayList indicates that only Employee objects can be stored in the array list. 2. ArrayList b = new ArrayList();
How to store User-defined (Custom) Class Objects in Java ArrayList?
Let’s take an example program where we will store user-defined (custom) class objects in ArrayList.
Suppose there are three students whose name, id, rollNo have to add to the custom ArrayList. First, we will create a class Student.
In this class, we will define a constructor and three instance variables name, id, and rollNo of data type String, int, and int respectively. Look at the below program source code.
Program code 1:
package customArrayList; public class Student < // Create instance variables name, id, and rollNo of data type String, int, and int respectively. String name; int id; int rollNo; // Create three parameters constructor with parameters name, id, and rollNo. Student(String name, int id, int rollNo) < this.name = name; this.rollNo = rollNo; this.id = id; >>
Now create another class addingData in which we will store three Student class objects in the ArrayList.
package customArrayList; import java.util.ArrayList; public class AddingData < // Create a ArrayList method of generic type 'Student'. ArrayListstudentData() < // Create three objects of the class Student and pass arguments to the constructor. Student s1 = new Student("Deep", 1234, 04); Student s2 = new Student("Shubh", 4321, 20 ); Student s3 = new Student("Riddhi", 1212, 02); // Create the object of ArrayList of generic type 'Student'. ArrayListstudentlist = new ArrayList(); // Now add Student objects in the ArrayList using reference variable studentlist. studentlist.add(s1); studentlist.add(s2); studentlist.add(s3); // Return object reference variable 'studentlist' of the array list to the method 'studentValue'. return studentlist; > > Now create one more class to retrieve students data from the above class’s studentData() method and iterate over them to get the student detail.
package customArrayList; import java.util.ArrayList; public class RetriveStudents < public static void main(String[] args) < // Call AddingData class by creating object of that class. AddingData data = new AddingData(); // Call studentData() method using reference variable data. ArrayListlistst = data.studentData(); // Now iterate and display all the Student data. for(Student st:listst) < System.out.println("Student's name: " +st.name); System.out.println("Student ID " +st.id); System.out.println("Roll number: " +st.rollNo); >> > Output: Student's name: Deep Student ID 1234 Roll number: 4 Student's name: Shubh Student ID 4321 Roll number: 20 Student's name: Riddhi Student ID 1212 Roll number: 2
The same program can also be done without using any constructor. Look at the below source code and follow all steps.
Program code 2:
package customArrayList2; public class Student < // Declare instance variables name, phyMarks, mathsMarks, chemMarks, total, and per. String name; int phyMarks; int mathsMarks; int chemMarks; int total; float per; >
package customArrayList2; import java.util.ArrayList; public class Studentdata < // Declare an ArrayList method of generic type Student. ArrayListaddData() < // Create two objects s1 and s2 of the student class and initialize the value of variables using reference variable s1 and s2. Student s1 = new Student(); s1.name = "Shubh"; s1.phyMarks = 95; s1.mathsMarks = 100; s1.chemMarks = 90; s1.total = 95 + 100 + 90; s1.per = ((s1.total)*100)/300; Student s2 = new Student(); s2.name = "Deep"; s2.phyMarks = 80; s2.mathsMarks = 85; s2.chemMarks = 90; s2.total = 80 + 85 + 90; s2.per = ((s2.total)*100)/300; // Create an ArrayList object of generic type Student. ArrayListal = new ArrayList(); // Call add() method to store student class objects in the array list using reference variable al. al.add(s1); al.add(s2); return al; > >
package customArrayList2; import java.util.ArrayList; public class RetriveStudentData < // Declare an instance method. void fetchStudentData() < // Create an object of the Studentdata class. Studentdata stdata = new Studentdata(); // Call addData() method using reference variable stdata. ArrayListlistst = stdata.addData(); // Now iterate and display all the student data. // enhance for loop - for each loop. for(Student student:listst) < System.out.println("Name: " +student.name); System.out.println("Physics Marks: " +student.phyMarks); System.out.println("Maths Marks: " +student.mathsMarks); System.out.println("Chemistry Marks: " +student.chemMarks); System.out.println("Total Marks: " +student.total); System.out.println("Percentage:" +student.per); >> > In this example program, we will create a client class to test our logic.
package customArrayList2; public class TestStudentOperation < public static void main(String[] args) < Studentdata st = new Studentdata(); st.addData(); RetriveStudentData rsd = new RetriveStudentData(); rsd.fetchStudentData(); >>
Output: Name: Shubh Physics Marks: 95 Maths Marks: 100 Chemistry Marks: 90 Total Marks: 285 Percentage: 95.0 Name: Deep Physics Marks: 80 Maths Marks: 85 Chemistry Marks: 90 Total Marks: 255 Percentage: 85.0
Let’s take another example program where we will create a class Employee and we will iterate and display all employee data from the Employee class. So let’s see the following source code.
Program code 3:
package customArrayList3; import java.util.ArrayList; public class Employee < int eNo; String name, address; Employee(int eNo, String name, String address) < this.eNo = eNo; this.name = name; this.address = address; >public Employee() < >// Display all employees data. void displayData(ArrayList list) < System.out.println("Employee Detail"); for(Employee emp: list ) < System.out.println("Employee number: " +emp.eNo); System.out.println("Employee Name: " +emp.name); System.out.println("Employee Address: " +emp.address); >> > package customArrayList3; import java.util.ArrayList; public class AddingEmployeeData < public static void main(String[] args) < Employee emp1 = new Employee(102, "Shubh", "Nagpur" ); Employee emp2 = new Employee(205, "Anjali", "Dhanbad"); Employee emp3 = new Employee(333, "Shanjna", "Mumbai"); ArrayListlist = new ArrayList(); list.add(emp1); list.add(emp2); list.add(emp3); Employee temp = new Employee(); // Call displayData method using temp reference variable object and pass list as a parameter. temp.displayData(list); > >
Output: Employee Detail Employee number: 102 Employee Name: Shubh Employee Address: Nagpur Employee number: 205 Employee Name: Anjali Employee Address: Dhanbad Employee number: 333 Employee Name: Shanna Employee Address: Mumbai
Hope that this tutorial has covered almost all important points related to store user-defined class objects in Java ArrayList. I hope that you will have understood and practiced all example programs.
Thanks for reading.