Examples of Java collection List method and traversal method

Features of List Collection

Ordered: the order of elements stored and retrieved is consistent
There are indexes: elements can be manipulated through indexes
Repeatable: The stored elements can be repeated

List collection method

The methods of Collection are all inherited, and you can use the methods in Collection
In addition, because List collections have indexes, there are many more methods for indexing operations.

Notice:

There is overloading in the above methods in the List collection. One is to inherit the parameters that need to be provided by the Collection are the given specific objects, and the other is that the parameters that List itself need to be provided are indexes, so the following problems arise.

For example: remove(1), is it necessary to delete whether the generic is an element 1 in the <Integer> collection, or to delete the element on the 1 index

Answer: Priority is given to calling methods with the same type of formal parameters and actual parameters.

Code demo:

import ;
import ;

public class Test5 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        (1);
        (2);
        (3);
        (list);//[1, 2, 3]

        //1 is int type, so the call formal parameter is int type that deletes the element at the specified index.        (1);
        (list);//[1, 3]

        //Change 1 to Integer type        Integer i = (1);
        //1 in the i variable is the reference data type, so the call formal parameter is Object type to delete the specified element.        (i);
        (list);//[3]

    }
}

How to traverse List collections

In addition to the same iterator traversal, enhanced for traversal, lambda traversal, there are also ordinary for traversal, and list iterator traversal.

Normal for traversal

Code Demo

public class Test6 {
    public static void main(String[] args) {
        //Ordinary for traversal        List<String> list = new ArrayList<>();
        ("aaa");
        ("bbb");
        ("ccc");

        for (int i = 0; i < (); i++) {
            String str = (i);
            (str);
        }
        //aaa
        //bbb
        //ccc
    }
}

List iterator traversal

illustrate

ListIterator inherits from iterator Iterator.

Get list iterator

Common methods

Code Demo

import ;
import ;
import ;

public class Test6 {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        ("aaa");
        ("bbb");
        ("ccc");

        //Travel printing        ListIterator<String> lit1 = ();
        while (()) {
            String str = ();
            (str);
        }
        //aaa
        //bbb
        //ccc

        //Traveling addition: add ddd behind aaaa        ListIterator<String> lit2 = ();
        while (()) {
            String s = ();
            if (("aaa")) {
                ("ddd");
            }
        }
        (list);//[aaa, ddd, bbb, ccc]

    }
}

The underlying principle of ArrayList collection

The underlying data structure is an array, which is fast in query and slow in addition and deletion.

1. Create an array with default length of 0 at the bottom using the set created by empty parameters.
2. When adding the first element, the underlying layer will create a new array of length 10.
3. When the storage is full, the capacity will be expanded by 1.5 times.
4. If multiple elements are added at once, and 1.5 times cannot be put down, the length of the newly created array shall be subject to actuality.

The underlying principle of LinkedList collection

The underlying data structure is a two-way linked list, which is slow to query and fast to add and delete, but if the operation is the head and tail elements, the speed is also extremely fast.
Therefore, LinkedList itself has many unique APIs that directly operate the head and tail elements. Therefore, in addition to the methods inherited from Collection and List, there are also the following methods

Summarize

This is the end of this article about the methods and traversal methods of Java collection List. For more related Java collection List content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!