Return object from arraylist java

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:

ArrayList arrayListName;

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.

For 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 source 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'. ArrayList studentData[] { // 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'. ArrayList studentlist = 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. ArrayList listst = 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 source 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. ArrayList addData[] { // 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. ArrayList al = 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. ArrayList listst = 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 source 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"]; ArrayList list = 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 programs.
Thanks for reading!!!

Next ⇒ LinkedList in Java

⇐ Prev Next ⇒

• All Implemented Interfaces: Serializable, Cloneable, Iterable, Collection, List, RandomAccess Direct Known Subclasses: AttributeList, RoleList, RoleUnresolvedList
  public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable

  Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null. In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list. [This class is roughly equivalent to Vector, except that it is unsynchronized.]

  The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O[n] time. All of the other operations run in linear time [roughly speaking]. The constant factor is low compared to that for the LinkedList implementation.

  Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.

  An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.

  Note that this implementation is not synchronized. If multiple threads access an ArrayList instance concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally. [A structural modification is any operation that adds or deletes one or more elements, or explicitly resizes the backing array; merely setting the value of an element is not a structural modification.] This is typically accomplished by synchronizing on some object that naturally encapsulates the list. If no such object exists, the list should be "wrapped" using the Collections.synchronizedList method. This is best done at creation time, to prevent accidental unsynchronized access to the list:

  List list = Collections.synchronizedList[new ArrayList[...]];

  The iterators returned by this class's iterator and listIterator methods are fail-fast: if the list is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove or add methods, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

  Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

  This class is a member of the Java Collections Framework.

  Since: 1.2 See Also:Collection, List, LinkedList, Vector, Serialized Form

• • • finalize, getClass, notify, notifyAll, wait, wait, wait
    • containsAll, equals, hashCode

• • • public ArrayList[int initialCapacity]

      Constructs an empty list with the specified initial capacity.

      Parameters:initialCapacity - the initial capacity of the list Throws: IllegalArgumentException - if the specified initial capacity is negative
    • public ArrayList[]

      Constructs an empty list with an initial capacity of ten.

    • public ArrayList[Collection c]

      Retains only the elements in this list that are contained in the specified collection. In other words, removes from this list all of its elements that are not contained in the specified collection.

      Specified by: retainAll in interface Collection Specified by: retainAll in interface List Overrides: retainAll in class AbstractCollection Parameters:c - collection containing elements to be retained in this list Returns:true if this list changed as a result of the call Throws: ClassCastException - if the class of an element of this list is incompatible with the specified collection [optional] NullPointerException - if this list contains a null element and the specified collection does not permit null elements [optional], or if the specified collection is nullSee Also:Collection.contains[Object]
    • public ListIterator listIterator[int index]

      Returns a list iterator over the elements in this list [in proper sequence], starting at the specified position in the list. The specified index indicates the first element that would be returned by an initial call to next. An initial call to previous would return the element with the specified index minus one.

      The returned list iterator is fail-fast.

      Specified by: listIterator in interface List Overrides: listIterator in class AbstractList Parameters:index - index of the first element to be returned from the list iterator [by a call to next] Returns:a list iterator over the elements in this list [in proper sequence], starting at the specified position in the list Throws: IndexOutOfBoundsException - if the index is out of range [index < 0 || index > size[]]
    • public List subList[int fromIndex, int toIndex]

      Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. [If fromIndex and toIndex are equal, the returned list is empty.] The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations.

      This method eliminates the need for explicit range operations [of the sort that commonly exist for arrays]. Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of elements from a list:

      list.subList[from, to].clear[]; Similar idioms may be constructed for indexOf[Object] and lastIndexOf[Object], and all of the algorithms in the Collections class can be applied to a subList.

      The semantics of the list returned by this method become undefined if the backing list [i.e., this list] is structurally modified in any way other than via the returned list. [Structural modifications are those that change the size of this list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.]

      Specified by: subList in interface List Overrides: subList in class AbstractList Parameters:fromIndex - low endpoint [inclusive] of the subListtoIndex - high endpoint [exclusive] of the subList Returns:a view of the specified range within this list Throws: IndexOutOfBoundsException - if an endpoint index value is out of range [fromIndex < 0 || toIndex > size] IllegalArgumentException - if the endpoint indices are out of order [fromIndex > toIndex]

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2020, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.