LinkedList set

package List;
import java.util.LinkedList;
public class LinkedListDemo02 {
    public static void main(String[] args) {
        //linkedList Sets inherit from List aggregate , Its underlying data structure is a two-way linked list ,ArrayList There are no unique methods in the collection , It has some unique methods ( Chicken ribs ), These special methods are specially used to operate the head and tail nodes 
        // A one-way linked list consists of nodes one by one . Each node has two areas , Pointer field and content field , The pointer field defaults to ^, If the next element has content , Then store the address value of the next element ; The content field stores the content of the current element 
        // characteristic : Additions and deletions quickly , Slow query 
        // Because it's an unordered list , So add elements directly to the memory space , Let the pointer field in the original set point to the address of the added element ,
        // Remove elements , Directly find the element corresponding to the index , The pointer field in the deleted element stores the address value of the next element and gives it to its previous element , That is, let the pointer field of the upper element point to the pointer field of the lower element .
        // The query is slow because , His nodes are stored randomly . Query elements can only be searched backwards from the first node , Until we find it . The storage of arrays in space is continuous , So the query is faster 

        // The two-way linked list has three areas , Forefinger needle field 、 Data fields 、 Back pointer field .
        // The advantages of a two-way linked list over a one-way linked list are : It can find elements from the beginning of the node , You can also find from the tail node , You can query from which side the element is close , This improves the query ability in disguise 
        // shortcoming 1: When deleting elements , One way linked list only needs to notify the previous node , Now you need to notify the previous node and the next node , So the addition and deletion will be slower than the one-way linked list 
        // shortcoming 2: Because each node in the bidirectional linked list stores three areas , So it will occupy more memory 

        System.out.println("==================== Unique method =====================");
        // Reason why linkedList The unique methods in the set compare chicken ribs , Because it is inherited from List and Collection All methods can realize these functions , Of course, developers are not cerebral palsy , These methods will run faster 
        LinkedList<String> strList = new LinkedList<>();
        strList.add(" Liu Xuande ");
        strList.add(" Zhang Yide ");
        strList.add(" Guan Yunchang ");
        strList.add(" Cao mengde ");
        strList.add(" Sun Zhongmou ");

        // A unique method to obtain the head node and tail node 
        //public E getFirst() :  Get the header element 
        System.out.println(" Head node :" + strList.getFirst()); // replace :get(0);
        //public E getLast() :  Get the tail node element 
        System.out.println(" Caudal node :" + strList.getLast()); // Replace :get(strList.size() - 1);

        // The unique method of adding head nodes and tail nodes 
        //public void addFirst(E e) :  Add a new header node element 
        strList.addFirst(" Zhuge Kongming "); // replace :add(0," Zhuge Kongming ")
        //public void addLast(E e) :  Add tail node element 
        strList.addLast(" Sima yi "); // Replace :add(" Sima yi ");
        System.out.println(" The content of the set after adding the head and tail nodes is :" + strList);

        // A unique method of deleting head and tail nodes 
        //public E removeFirst() :  Delete header node ( Returns the deleted element )
        strList.removeFirst(); // replace :remove(0)
        //public E removeLast() :  Delete tail node ( Returns the deleted element )
        strList.removeLast(); // replace :remove(strList.size() - 1)
        System.out.println(" After deleting the head and tail nodes, the content of the collection is :" + strList);

        // Pop up the first element ( eject : Get and delete ) Unique method 
        String popElement = strList.pop();
        System.out.println(" The element that pops up is :" + popElement);
        System.out.println(" The set content after the pop-up element is :" + strList);
    }
}