java笔记之list集合LinkedList<三>

LinkedList:链表实现, 增删快, 查找慢

由于LinkedList:在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.

由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。

但查询时需要一个一个的遍历, 所以效率较低。

1：特有方法介绍

addFirst(E e)

addLast(E e)

getFirst()

getLast()

removeFirst()

removeLast()

如果集合中没有元素，获取或者删除元素抛：NoSuchElementException

public class linkedLixt {

    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        link.add("你");
        link.add("是");
        link.add("我");
        link.add("的");
        link.add("眼");
        System.out.println("初始化链表："+link);
        link.addFirst("hello");
        link.addLast("world");
        System.out.println(" 增加头和尾之后的链表: " + link);
    }

}

输出结果：

初始化链表：[你, 是, 我, 的, 眼]
增加头和尾之后的链表: [hello, 你, 是, 我, 的, 眼, world]

public class linkedLixt {

    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        link.add("你");
        link.add("是");
        link.add("我");
        link.add("的");
        link.add("眼");    
        System.out.println("取出第一个  ："+link.getFirst());
        System.out.println("取出最后一个  ："+link.getLast());
    }

}

输出结果：

取出第一个 ：你
取出最后一个 ：眼

public class linkedLixt {

    public static void main(String[] args) {
        LinkedList link = new LinkedList();
        link.add("你");
        link.add("是");
        link.add("我");
        link.add("的");
        link.add("眼");
        System.out.println("移除第一个  ："+link.removeFirst());
        System.out.println("移除最后一个  ："+link.removeLast());
        System.out.println("移除后的："+link);
    }

}

输出结果：

移除第一个 ：你
移除最后一个 ：眼
移除后：[是, 我, 的]

2：数据结构

2.1：栈 （1.6）

先进后出

push() 

pop()

2.2：队列（双端队列1.5）

先进先出

offer()

poll()

练习数据结构的特点：堆栈练习

import java.util.LinkedList;

class Stacklist{
    LinkedList stacklist;
    public Stacklist() {
        stacklist=new LinkedList();        
    }
    public void add(Object o){//添加方法
        stacklist.push(o);
    }
    public Object remove(){//移除方法
        return stacklist.pop();    
    }
    public int size(){//获取容量
        return stacklist.size();
    }
}
public class linklisted {
    public static void main(String[] args) {
        Stacklist stacklist=new Stacklist();
        stacklist.add("路飞");
        stacklist.add("娜美");
        stacklist.add("索隆");
        System.out.println("堆栈存储效果：");
        while (stacklist.size()>0) {
            System.out.println(stacklist.remove());
        }
    }
}

输出结果：

堆栈存储效果：
索隆
娜美
路飞

队列结构练习：

import java.util.LinkedList;

class QueueList{
    LinkedList queuelist;
    public QueueList() {
        queuelist=new LinkedList();        
    }
    public void add(Object o){//添加方法
        queuelist.offer(o);
    }
    public Object remove(){//移除方法
        return queuelist.poll();    
    }
    public int size(){//获取容量
        return queuelist.size();
    }
}
public class OfferPull {

    public static void main(String[] args) {
        QueueList queueList=new QueueList();
        queueList.add("佐助");
        queueList.add("鸣人");
        queueList.add("鼬");
        int size=queueList.size();
        System.out.println("先进先出效果：");
        for (int i = 0; i < size; i++) {
            System.out.println(queueList.remove());
        }
    }
}

输出结果：

先进先出效果：
佐助
鸣人
鼬

3：返回逆序的迭代器对象      

descendingIterator()   返回逆序的迭代器对象

import java.util.Iterator;
import java.util.LinkedList;
public class Demo04 {
    public static void main(String[] args) {
        LinkedList list =new LinkedList ();
        list.add("张良");
        list.add("卫庄");
        list.add("盖聂");
        Iterator it=list.descendingIterator();
        System.out.println("剑术排名：");
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

输出结果：

剑术排名：
盖聂
卫庄
张良