存入和取出的相继一致澳门永利备用网址,存入和取出的逐一一致

package demo;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        function1();// 添加
        function2();// 获取头尾
        function3();// 移除并返回开头

    }

    public static void function1() {
        LinkedList<String> link = new LinkedList<String>();
        link.addLast("a");
        link.addLast("b");
        link.addLast("c");
        link.addLast("d");

        link.addFirst("1");
        link.addFirst("2");
        link.addFirst("3");
        System.out.println(link);
        // [3, 2, 1, a, b, c, d]
    }

    public static void function2() {
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");
        if (!link.isEmpty()) {
            String first = link.getFirst();
            String last = link.getLast();
            System.out.println(first);// 1
            System.out.println(last);// 4
        }
    }

    public static void function3() {
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");
        String first = link.removeFirst();
        String last = link.removeLast();
        System.out.println(first);// 1
        System.out.println(last);// 4
        System.out.println(link);// [2, 3]
    }
}

LinkedList提供了大量的来踪去迹操作

 

List接口的有意方法(与索引有关):

示例:

仓库存储结构通俗解释:子弹压进弹夹,先压进去的在底下,后压进去的在地点,开枪的时候,下面的子弹先弹出来,下面的后出来(先进后出)

     查找时候由于必要通过连日的节点,速度慢,但是增删的时候,原理是间接操作地址,不转移自我的布局,所以速度高速

持有非常首要的三大特点:

装有紧要的三大特征:

示例:

队列存储结构通俗解释:坐动车排队安检,各种人相继检查,唯有前边的人查完,才能轮到后面的人(先进先出)

 

多少存储的常用结构有:堆栈,队列,数组,链表,那里几乎介绍下:

 

链表结构:每一种要素分为两有些,一部分笔录上一个成分地址,另一有的存储当前因素的新闻,使得每一趟个要素像自高铁链一样连接

1.一如既往聚集:存入和取出的相继一致

LinkedList集合则选拔了单向链表的数据结构,所以增删快,查询慢,同样线程差别台,运行速度快

List接口继承自Collection接口

 

 

 

LinkedList集合则采纳了单向链表的数据结构,所以增删快,查询慢,同样线程不联合,运行速度快

 

链表结构:每个要素分为两局地,一部分记下上一个因素地址,另一片段存储当前因素的新闻,使得每五回个成分像自高铁链一样连接

数组结构:已经触发过很频繁,通过索引查找块,可是出于定长,所以增删慢

空参创造起来容量10,可变数组,原理是System的复制数组方法,以及一些任何的操作后举行扩容

 

 

package demo;

import java.util.List;
import java.util.ArrayList;

//List接口继承Collection接口,下有很多实现类
//例如ArrayList
public class ListDemo {
    public static void main(String[] args) {
        function1();//添加
        function2();//删除
        function3();//修改
    }
    public static List<String> function(){
        //创建集合
        List<String> list = new ArrayList<>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        return list;
    }
    public static void function1(){
        List<String> list = function();
        System.out.println(list);
        //[abc1, abc2, abc3, abc4]
        list.add(1, "abc");//在1索引上添加
        System.out.println(list);
        //[abc1, abc, abc2, abc3, abc4]
    }
    public static void function2(){
        List<String> list = function();
        System.out.println(list);
        //[abc1, abc2, abc3, abc4]
        String s = list.remove(1);
        System.out.println(s);//输出:abc2
        System.out.println(list);
        //[abc1, abc3, abc4]
    }
    public static void function3(){
        List<String> list = function();
        System.out.println(list);
        //[abc1, abc2, abc3, abc4]
        String s = list.set(2, "abc");
        System.out.println(s);//输出:abc3
        System.out.println(list);
        //[abc1, abc2, abc, abc4]
    }
}

 

库房存储结构通俗解释:子弹压进弹夹,先压进去的在底下,后压进去的在下面,开枪的时候,上面的枪弹先弹出来,下面的后出来(先进后出)

 

 

队列存储结构通俗解释:坐高铁排队安检,各个人挨家挨户检查,唯有前边的人查完,才能轮到后面的人(先进先出)

LinkedList提供了大批量的前因后果操作

package demo;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        function1();// 添加
        function2();// 获取头尾
        function3();// 移除并返回开头

    }

    public static void function1() {
        LinkedList<String> link = new LinkedList<String>();
        link.addLast("a");
        link.addLast("b");
        link.addLast("c");
        link.addLast("d");

        link.addFirst("1");
        link.addFirst("2");
        link.addFirst("3");
        System.out.println(link);
        // [3, 2, 1, a, b, c, d]
    }

    public static void function2() {
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");
        if (!link.isEmpty()) {
            String first = link.getFirst();
            String last = link.getLast();
            System.out.println(first);// 1
            System.out.println(last);// 4
        }
    }

    public static void function3() {
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");
        String first = link.removeFirst();
        String last = link.removeLast();
        System.out.println(first);// 1
        System.out.println(last);// 4
        System.out.println(link);// [2, 3]
    }
}

List接口的数目存储结构:

数码存储的常用结构有:堆栈,队列,数组,链表,那里大约介绍下:

List接口继承自Collection接口

2.此接口的用户可以对列表中各种成分插入地点准确的决定:可以通过索引操作

List的许多子类存储元素所采用的协会方式是见仁见智的,因而导致了不少会晤有了个其他个性:

List接口的数据存储结构:

ArrayList集合选择了数组结构存储形式,所以查询快,增删慢,由于线程不安全,运行速度飞速,

package demo;

import java.util.List;
import java.util.ArrayList;

//List接口继承Collection接口,下有很多实现类
//例如ArrayList
public class ListDemo {
    public static void main(String[] args) {
        function1();//添加
        function2();//删除
        function3();//修改
    }
    public static List<String> function(){
        //创建集合
        List<String> list = new ArrayList<>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        return list;
    }
    public static void function1(){
        List<String> list = function();
        System.out.println(list);
        //[abc1, abc2, abc3, abc4]
        list.add(1, "abc");//在1索引上添加
        System.out.println(list);
        //[abc1, abc, abc2, abc3, abc4]
    }
    public static void function2(){
        List<String> list = function();
        System.out.println(list);
        //[abc1, abc2, abc3, abc4]
        String s = list.remove(1);
        System.out.println(s);//输出:abc2
        System.out.println(list);
        //[abc1, abc3, abc4]
    }
    public static void function3(){
        List<String> list = function();
        System.out.println(list);
        //[abc1, abc2, abc3, abc4]
        String s = list.set(2, "abc");
        System.out.println(s);//输出:abc3
        System.out.println(list);
        //[abc1, abc2, abc, abc4]
    }
}

 

 

再有一个Vector集合,数组结构,是JDK最早的成团,方法和ArrayList基本相同,运行速度慢,所未来来被ArrayList代替,那里不介绍了

     查找时候是因为须要经过连日的节点,速度慢,然则增删的时候,原理是一向操作地址,不改动自己的构造,所以速度连忙

2.此接口的用户可以对列表中每一种成分插入地方准确的决定:能够透过索引操作

数组结构:已经接触过很频仍,通过索引查找块,然则由于定长,所以增删慢

3.可以储存重复成分

 List集合遍历格局有二种:迭代器遍历,普通for循环遍历,增强for循环遍历

List接口的有意方法(与索引有关):

List的重重子类存储成分所运用的构造格局是见仁见智的,由此导致了很多会聚有了独家的特点:

 

ArrayList集合采纳了数组结构存储格局,所以查询快,增删慢,由于线程不安全,运行速度很快,

空参创造起来容量10,可变数组,原理是System的复制数组方法,以及部分其余的操作后展开扩容

3.可以储存重复元素

1.一如既往聚集:存入和取出的逐条一致

 

 List集合遍历形式有三种:迭代器遍历,普通for循环遍历,增强for循环遍历

还有一个Vector集合,数组结构,是JDK最早的汇聚,方法和ArrayList基本相同,运行速度慢,所未来来被ArrayList代替,那里不介绍了