Java List - Naukri Code 360

Introduction

Java lists are like the notebooks you use for your college classes. Just like you jot down important points in your notebook, in Java, you use lists to store items in an orderly fashion. These lists are super handy when you want to keep track of things like your favorite songs, to-do tasks, or even scores in a game.

In this article, we're going to explore how these lists work in Java, how you can create them, and what cool stuff you can do with them.

List Interface in Java

When we talk about a List in Java, we're discussing a way to organize your data. Think of it as a line where everyone knows their place - the first, second, third, and so on. In Java, this line or List lets you store and manage a bunch of items in an order you decide. It's part of Java's Collection Framework, which is just a fancy way of saying it's a tool Java provides to work with groups of objects.

Unlike an array, a List in Java doesn't need you to tell it how big it should be right from the start. It grows and shrinks as you add or remove items. This makes it super flexible. You can insert an item, remove one, and even look up an item to see what's stored at a particular spot in the list.

In coding terms, to use a List in Java, you start by saying List<String> myList = new ArrayList<>(); if you want to store a list of text items. Don't worry about ArrayList just yet; it's one type of List we'll talk about later.

Now, let's add some items to our list:

myList.add("Apple");
myList.add("Banana");
myList.add("Cherry");

With these lines of code, we've created a list that holds three items. If you want to see what's in the second spot, you can use myList.get(1) (remember, lists in Java start counting from 0, not 1).

So, in simple terms, a List in Java helps you keep track of your items in a flexible way, letting you add, remove, and look things up as needed.

Declaration of Java List Interface

Declaring a List in Java is like telling your computer, "I'm going to make a list." You're not filling it with items yet, just setting up space for them. To do this, you use a simple line of code. It's like setting up an empty container.

Here's how you do it:

List<String> myList = new ArrayList<>();

In this line:

List<String> tells Java you're making a list that will hold text items (like words or sentences).
myList is what you decide to call your list. You can name it anything.
new ArrayList<>() sets up a new, empty list for you to start adding items to.

This line doesn't put anything in the list; it just gets it ready for you to add items later. Think of it as buying a new notebook. You've got the notebook, but you haven't written anything in it yet.

It's important to know that ArrayList is just one type of List you can use in Java. There are others, like LinkedList, but they all do the basic job of holding items in a list. Each type has its special features, but they all follow the List rules, like keeping items in order.

If you need to store items that aren't text, like numbers or your own custom objects, you can change String to another type, like Integer for whole numbers or any class name you've created.

Example of Java List

Now that we've set up our list, let's add some items to it. We'll keep it simple and use a list of fruits as our example. Here's how you can add items to your list in Java:

List<String> fruitList = new ArrayList<>();
fruitList.add("Apple");
fruitList.add("Banana");
fruitList.add("Cherry");
In this code:
fruitList.add("Apple"); adds an apple to your list.

Each add command adds a new fruit to the end of the list.

So, after these lines, your list has three items: Apple, Banana, and Cherry, in that order.

Want to check what's in your list? You can look at an item by its position. Remember, positions start at 0, not 1. So, to see the first item, you do this:

String firstFruit = fruitList.get(0); // This will be "Apple"

And if you want to know how many items are in your list, you can use:

int size = fruitList.size(); // This tells you the list has 3 items

That's how you work with a list in Java: set it up, add items, and check what you've got. It's straightforward once you get the hang of it.

Operations in a Java List Interface

Working with a Java List lets you do more than just add items. You can perform a bunch of useful operations, such as removing items, checking if an item is in the list, or finding out the list's size. Let's go over some of these operations:

Adding Items

We've already seen how to add items to a list with the add method. It's as simple as list.add("Item");.

Removing Items

If you want to remove something from your list, use the remove method. You can remove an item by its position in the list or by specifying the item itself. For example, list.remove("Banana"); will remove the first occurrence of "Banana" from your list.

Checking for an Item

To see if your list contains a specific item, use the contains method. It returns true if the item is in the list. For example, list.contains("Apple"); checks if "Apple" is in your list.

Finding the Size

The size method tells you how many items are in your list. For example, list.size(); might return 3 if there are three items in your list.

Clearing the List

If you want to remove all items and start with an empty list again, use the clear method. Just call list.clear();, and your list will be empty.

Getting an Item

To get an item at a specific position, use the get method with the position number. Remember, the first position is 0. So, list.get(0); gives you the first item.

These operations make lists in Java very flexible. You can manage your items exactly how you need, whether you're adding, removing, or checking what's in your list.

Complexity of List Interface in Java

When we talk about complexity in Java Lists, we're not discussing how hard it is to use them. Instead, we're talking about how efficiently they perform different tasks. It's like when you're choosing between taking a bike or a car to school. The bike might be quicker for short distances without much traffic, but the car is better for longer distances or when you need to carry a lot of stuff.

In Java Lists, the efficiency or "complexity" of operations like adding, removing, or searching for items can vary. It depends on what kind of list you're using. The two most common types are ArrayList and LinkedList.

ArrayList

Imagine you have a line of people. Adding someone at the end of the line is easy, just like adding an item to an ArrayList (O(1) complexity, which is super quick). But if you want to insert someone in the middle, everyone behind them needs to step back (O(n) complexity, which can take more time if the line is long).

LinkedList

Now, think of a chain where each person holds the hand of the person next to them. Adding someone in the middle is easier because only two people need to let go and then grab the new person's hands (O(1) for adding at specific points if you know where you're adding, but finding that spot can take longer, O(n)).

So, the "complexity" means how long these operations take, especially as your list gets bigger. In general, for an ArrayList:

Adding items at the end is quick (O(1)).
Searching for an item (O(n)) and adding or removing items in the middle (O(n)) can take more time.

And for a LinkedList:

Adding or removing items, especially at the start or in the middle, can be quicker (O(1) for the operation itself, but finding the spot takes O(n)).
But, searching for an item still takes longer (O(n)), just like in an ArrayList.

Understanding this helps you choose the right type of list based on what tasks you'll do most. If you'll add or remove items a lot, a LinkedList might be better. But if you're mostly adding items at the end or searching through your list, an ArrayList could be more efficient.

Iterating over List Interface in Java

Iterating over a list in Java means going through each item one by one. It's like when you're checking each item on your shopping list at the store to make sure you haven't missed anything. In Java, there are a few ways to do this with a List.

Using a for loop

The most common way to go through a list is with a for loop. You start at the beginning and move to the end, looking at each item one by one.

for(int i = 0; i < myList.size(); i++) {
    String item = myList.get(i);
    // You can work with 'item' here
}

Enhanced for loop (for-each loop)

This is a simpler way to go through each item without worrying about the index.

for(String item : myList) {
    // 'item' is each item in the list, one at a time
}

Using an iterator

An iterator is a tool that Java provides to go through a collection like a list. It gives you a way to move through the items and even remove them as you go.

Iterator<String> iterator = myList.iterator();
while(iterator.hasNext()) {
    String item = iterator.next();
    // Work with 'item' here
}

Using Java 8 Streams

If you're using Java 8 or later, you can use streams for a more modern approach. This lets you do more complex operations like filtering or mapping items as you go through them.

myList.stream().forEach(item -> {
    // Work with 'item' here
});

Each of these methods has its use cases. For simple tasks, a for loop or enhanced for loop works great. If you need more control, especially to remove items as you go, an iterator is useful. And for more complex operations, streams provide a powerful tool.

Methods of the List Interface

In Java, the List interface comes with a bunch of methods that let you manage your list effectively. Each method has a specific job, making it easier for you to work with the list, whether you want to add items, remove them, or look something up. Here's a rundown of some key methods and what they do:

add(E e)

Adds an item to the end of the list. If you have a list of fruits, add("Mango") would put "Mango" at the end.

add(int index, E element)

Inserts an item at a specified position in the list. Using add(1, "Orange") would put "Orange" at position 1, moving other items back.

remove(Object o)

Removes the first occurrence of the specified item from the list. If your list has "Banana", remove("Banana") takes it out.

remove(int index)

Removes the item at the specified position. remove(2) takes out the third item in the list.

get(int index)

Fetches the item at the specified position. get(0) gets you the first item in the list.

set(int index, E element)

Replaces the item at the specified position with a new one. set(0, "Strawberry") changes the first item to "Strawberry".

indexOf(Object o)

Finds the position of the first occurrence of the specified item. If you want to know where "Apple" is, indexOf("Apple") tells you.

size()

Gives you the total number of items in the list. size() might return 5 if there are 5 items.

clear()

Empties the list, removing all items. After clear(), the list has no items.

isEmpty()

Checks if the list has no items. isEmpty() returns true if the list is empty.

contains(Object o)

Checks if the list has a specific item. contains("Kiwi") checks if "Kiwi" is in the list.

These methods make it straightforward to work with lists in Java, giving you the power to manage your data effectively.

Java List vs Set

When working with collections in Java, you might wonder when to use a List and when to go for a Set. Both List and Set are interfaces in Java's Collection framework, but they serve different purposes based on their characteristics.

Order

The main feature of a List is that it maintains the order of elements. It means if you add elements to a List, you can retrieve them in the same order. This is not the case with a Set. A Set is designed to not keep the order; instead, it focuses on uniqueness.

Duplicates

Lists allow duplicate elements. You can have multiple "Apple" entries in a List, and it won't complain. Sets, on the other hand, are all about uniqueness. They do not allow duplicate elements. If you try to add a duplicate in a Set, it just ignores the new entry.

Choice

So, when do you choose a List over a Set? If you care about the order of elements or need to store duplicates, a List is your go-to. If you need a collection with unique elements and don't care about the order, a Set is better.

Performance

Because Sets enforce uniqueness, operations like adding, removing, and checking if an item exists can be faster compared to Lists, especially for large collections. This is because Sets often use more efficient ways to store and look up elements (like hashing).

Examples

In practice, you'd use a List for things like a sequence of events, line items in an order, or anything where the order matters. A Set is ideal for a collection of unique items like a deck of cards or a guest list where each name is unique.

Frequently Asked Questions

Can I access elements in a Java List by their index?

Yes, you can access elements in a Java List by their index. Use the get(int index) method, where index is the position of the element you want. Remember, the index starts at 0, so the first element is at index 0, the second at index 1, and so on.

How do I remove an element from a Java List?

To remove an element from a Java List, you can use either remove(int index) to remove an element at a specific position or remove(Object o) to remove a specific object from the list. If there are duplicates, remove(Object o) will remove the first occurrence.

What happens if I try to add a duplicate element to a Java Set?

If you try to add a duplicate element to a Java Set, the Set will not add the duplicate. Sets are designed to hold unique elements, so adding a duplicate has no effect. The original element remains, and the Set size does not increase.

Conclusion

In conclusion, understanding and utilizing Java Lists effectively is crucial for managing ordered collections of elements, especially when sequence and the ability to include duplicates matter. We've explored the essentials of the List interface, from declaration and initialization to performing various operations like adding, removing, and accessing elements. We also touched on the complexities associated with different List implementations and the importance of choosing the right one for your specific needs. Iterating over Lists, utilizing their methods, and distinguishing between Lists and Sets form the foundation of effective Java collection management.

You can refer to our guided paths on the Coding Ninjas. You can check our course to learn more about DSA, DBMS, Competitive Programming, Python, Java, JavaScript, etc. Also, check out some of the Guided Paths on topics such as Data Structure and Algorithms, Competitive Programming, Operating Systems, Computer Networks, DBMS, System Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.