精华内容
下载资源
问答
  • 创建链表LinkedList

    2017-04-24 20:16:00
    链表是由若干个节点的对象组成的一种数据结构分为单链表和双链表。...使用Java.util包中的LinkedList类可以创建一个链表对象 例如 LinkedList mylist=new LinkedList();//创建一个空双链表 ...

    链表是由若干个节点的对象组成的一种数据结构分为单链表和双链表。

    单链表:每个节点含有一个数据和下一个节点对象的引用。

    双链表:每个节点含有一个数据并含有上一个节点对象的引用和下一个节点对象的引用。

    创建链表

    使用Java.util包中的LinkedList类可以创建一个链表对象

    例如

    LinkedList mylist=new LinkedList();//创建一个空双链表

    可以使用add方法向链表依次增加节点

    例如

    mylist.add("加入的数据");

     mylist可以使用方法public Object get(index i)获取第i个节点中储存的数据。存放在节点中的数据都被看作一个Object对象。

     

    例:构造一个链表并输出节点中的数据

    import java.util.LinkedList;
    
    public class LinkListOne {
        public static void main(String[] args){
            LinkedList mylist = new LinkedList();//创建空链表
            mylist.add("a");//增加节点,第一节点
            mylist.add("b");//第二个节点
            mylist.add("c");
            mylist.add("d");
            mylist.add("e");
            int number =mylist.size();//获取节点的长度
            for(int i=0;i<number;i++){
                String temp = (String) mylist.get(i);//获取节点内数据
                System.out.println("第"+i+"节点数据:"+temp);
            }
            
        }
    
    }

    执行结果

    第0节点数据:a
    第1节点数据:b
    第2节点数据:c
    第3节点数据:d
    第4节点数据:e

     

     
     
     
    好文要顶  关注我 

    转载于:https://www.cnblogs.com/gc56-db/p/6758834.html

    展开全文
  • 创建LinkedList对象,从这里开始 0、无参 public LinkedList() { } 默认的构造方法,是我们最常用的,它只是new了一个对象 1、一个参数,接受一个Collection对象 public LinkedList(Collection<? ...

    (注意:本文源码基于JDK1.8) 

    创建LinkedList对象,从构造方法开始,接下来分析构造方法

     

    无参数的构造方法分析

        public LinkedList() {
        }

    创建LinkedList对象,方法体中什么也没有做。注意:隐式的执行了super()调用基类的构造方法!

     

    传入一个参数的构造方法分析

        public LinkedList(Collection<? extends E> c) {
            this();
            addAll(c);
        }

    传入参数为Collection对象,持有了多个元素,表示创建LinkedList对象后,同时添加多个元素

    1、调用无参数的构造方法

    首先调用无参的构造方法,目的是为了显式调用父类的构造方法,另外也可以初始化持有的其他实例变量

    2、调用addAll()方法,并将传入的Collection对象c传入进去,addAll()方法会添加多个元素进去

     

    重要字段介绍

    1、继承父类的实例变量modCount

    用于fail-fast机制检测

    2、三个实例变量+一个常量

    transient int size = 0;   
    transient Node<E> first; 
    transient Node<E> last;
    private static final long serialVersionUID = 876323262645176354L;

    size:表示LinkedList对象持有的元素总数,该实例变量使用transient修饰,不参与对象的序列化

    first:表示LinkedList对象持有的第一个结点对象,不参与对象序列化

    last:表示LinkedList对象持有的最后一个结点对象,不参与对象序列化

    serialVersionUID:一个常量值,反序列化对象时,JVM使用该UID值,与加载类库中的UID作一个对比,两个值一致才会进行反序列化对象,否则抛出一个异常,类版本不一样

     

    总结

    1、LinkedList基于一个双向链表,LinkedList对象持有双向链表头结点对象的引用,实例变量first指向此Node对象

    2、LinkedList对象持有表示双向链表尾结点对象的引用,实例变量last指向此Node对象

    3、LinkedList的父类为AbstractList,与ArrayList是同一个父类,实例变量modCount定义在AbstractList类中

    展开全文
  • LinkedList

    2019-08-22 15:19:12
    LinkedListLinkedList 类是List接口的另一个重要的实现类。它的底层是用双向循环链表来实现的,所以便于将新的对象插入到指定位置,它的查询效率低,但是增删效率高...创建一个空的LinkedList 对象 LinkedList...

    LinkedList 类

    LinkedList 类是List接口的另一个重要的实现类。它的底层是用双向循环链表来实现的,所以便于将新的对象插入到指定位置,它的查询效率低,但是增删效率高,适用于增删比较频繁,查询次数较少的元素集合管理。

    LinkedList 类的构造方法

    构造方法说 明
    LinkedList ()创建一个空的LinkedList 对象
    LinkedList (Collection c)创建指定集合的LinkedList 对象

    LinkedList 类的常用方法

    方法名称说 明
    boolean add(Object o)将对象添加到 LinkedList 对象的最后
    void addFist(Object o)将对象o添加到列表的开头
    int size()返回当前LinkedList 中元素的数量
    void addList(Object o)将对象o添加到列表的结尾
    Object getFist ()返回列表开头的元素
    Object removerFist ()删除并且返回列表开头的元素
    Object getLast ()返回列表结尾元素
    Object removerLast ()删除并且返回列表尾的元素
    使用这些方法,就可以轻松的把LinkedList 当做一个堆栈、队列或者其他面向端点的数据结构

    上代码:

    package com.linkedlist;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.LinkedList;
    
    public class Text {
    	 public static  void disposeSame(ArrayList  ali){
    	public static void main(String[] args) {
    		Tes te=new Tes();
    		    te.myAdd("a");
    		    te.myAdd("b");
    		    te.myAdd("c");
    		    te.myAdd("d");
    		   	    
    		 while(!te.myisEmpty()){
    			    te.myGet();
    		 }
    	
    		LinkedList  stOne=new LinkedList();
    		            stOne.add("a");
    		            stOne.add("b");
    		            stOne.add("c");
    		            stOne.add("d");
    		LinkedList  stTwo=new LinkedList();
    		            stTwo.add("a");
    		            stTwo.add("f");
    		            stTwo.add("c");
    		            stTwo.add("v");
    		            		            
    		 Tes.out(stOne); 
    		 //Tes.moveSame(stOne,stTwo); 
    		  //Tes.findSame(stOne,stTwo); 
    	            	            
    	}
    
    }
    
    class Tes{
    	
    	
    	private LinkedList link;
    	
    	public Tes(){		
    		link=new LinkedList();		
    	}
    	
    	public void myGet(){
    /*
     pollFirst();
    获取并移除队列第一个元素,队列为空,返回null;
     pollLast();
    获取并移除队列最后一个元素,队列为空,返回null;*/
    		System.out.println(link.pollLast());
    	}
    	
    	public void myAdd(Object obj){
    		//增加对象
    		link.add(obj);		
    	}
    	
    	public boolean myisEmpty(){
    		//链表是否为空
          return link.isEmpty();
    	}
    	
    	public static void out(LinkedList st){
    		
    			while(!st.isEmpty()){
    				 System.out.println("第一个:"+st.getFirst());
    				 System.out.println("最后一个:"+st.getLast());
    				/* peek()
    				 获取但不移除此列表的头(第一个元素)"
    				 peekFirst();
    				 获取队列第一个元素,队列为空,返回null;
    				  peekLast();
    				 获取队列最后一个元素,队列为空,返回null;*/
    				 System.out.println(st.peek());
    				System.out.println("输出最后一个数据:"+st.removeLast());
    				 
    				 System.out.println("---------");
    			 }
    		
    		
    	}
    	
    	public static void findSame(LinkedList st1,LinkedList st2){
    		 st1.removeAll(st2);   
    		 System.out.println("移除相同元素后 st1:"+st1);
    		 System.out.println("st2:"+st2);
    		
    	}
    	public static void moveSame(LinkedList st1,LinkedList st2){
    		 st1.retainAll(st2);   
    		 System.out.println("找到相同元素:"+st1);
    		
    	}
    
    	
    }
    
    展开全文
  • LinkedList的使用说明

    2021-05-04 12:15:02
    LinkedList的使用说明1. LinkedList的特点2.LinkedList的主要方法3.LinkedList的遍历3.1 使用for循环遍历3.2 使用增强的for循环遍历3.3 使用迭代器(Integor)遍历 1. LinkedList的特点 ...创建LinkedList对象 List&

    1. LinkedList的特点

    集合中的List是一种有序的,可重复的集合,LinkedList是基于链表实现了List的接口。因为是基于链表实现新增元素或删除元素则效率较高。但随机访问元素的效率较低。

    2.LinkedList的主要方法

    • 创建LinkedList对象
    List<String> list = new LinkedList<>();
    

    注:List中的String代表List中的元素类型是String

    • add(E e)方法向List中添加元素, E是泛型
    • add(int index, E e)方法向List指定位置插入元素
    • get(int index)获取指定位置的元素
    • boolean contains(Object o)检查List中是否包含指定元素,包含返回true, 否则返回false
    • remove(int index)删除指定位置的元素
    • remove(Object o)删除指定元素
    • size()方法返回List中元素的数量
    • clear()清空List,删除所有元素
    • isEmpty()检查List是否为空,为空返回true,否则返回false。
    • indexOf(Object o)获取元素在List中的位置,元素不存在时返回-1。
    package collect;
    
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * [简要描述]: LinkedList的主要方法
     * [详细描述]:
     *
     * @author Smalight Lv
     * @version 1.0, 2021/5/3 07:53
     * @since JDK 1.8
     */
    public class LinkedListTest {
        public static void main(String[] args) {
    
            /*
             * 声明List变量,并创建一个LinkedList对象
             * List<String>中的String代表List中的元素是String类的对象
             */
            List<String> list = new LinkedList<>();
    
            //添加元素,把参数添加到List中
            list.add("刘备");
            list.add("关羽");
            list.add("张飞");
    
            System.out.println("List的大小是:" + list.size());
            System.out.println(list);
    
            String str = list.get(0);
            System.out.println("第0个元素是:" + str);
    
            int index = list.indexOf("张飞");
            System.out.println("张飞的位置:" + index);
    
            //将元素"诸葛亮"添加到下标为1的位置(下标从零开始)
            list.add(1, "诸葛亮");
            System.out.println("List的大小是:" + list.size());
            System.out.println(list);
    
            boolean contains = list.contains("诸葛亮");
            System.out.println("是否包含\"诸葛亮\":" + contains);
            contains = list.contains("曹操");
            System.out.println("是否包含\"曹操\":" + contains);
    
            //按位置删除元素
            list.remove(1);
            System.out.println("List的大小是:" + list.size());
            System.out.println(list);
            //按元素值删除元素
            list.remove("张飞");
            System.out.println("List的大小是:" + list.size());
            System.out.println(list);
    
            boolean isEmpty = list.isEmpty();
            System.out.println("List是否为空:" + isEmpty);
    
            //清空List
            list.clear();
            System.out.println("List的大小是:" + list.size());
            System.out.println(list);
            isEmpty = list.isEmpty();
            System.out.println("List是否为空:" + isEmpty);
    
        }
    
    }
    

    运行结果:

    List的大小是:3
    [刘备, 关羽, 张飞]0个元素是:刘备
    张飞的位置:2
    List的大小是:4
    [刘备, 诸葛亮, 关羽, 张飞]
    是否包含"诸葛亮":true
    是否包含"曹操":false
    List的大小是:3
    [刘备, 关羽, 张飞]
    List的大小是:2
    [刘备, 关羽]
    List是否为空:false
    List的大小是:0
    []
    List是否为空:true
    

    3.LinkedList的遍历

    编历是指将集合中的所有元素都访问一遍。

    3.1 使用for循环遍历

    package collect;
    
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * [简要描述]:LinkedList遍历
     * [详细描述]:
     *
     * @author Smalight Lv
     * @version 1.0, 2021/5/4 10:29
     * @since JDK 1.8
     */
    public class LinkedListTraversal {
        public static void main(String[] args) {
            List<String> list = new LinkedList<>();
    
            list.add("刘备");
            list.add("关羽");
            list.add("张飞");
    
            for(int i = 0; i < list.size(); i++){
                String str = list.get(i);
                System.out.println(str);
            }
        }
    }
    

    运行结果:

    刘备
    关羽
    张飞
    

    3.2 使用增强的for循环遍历

    package collect;
    
    
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * [简要描述]:增加for循环遍历LinkedList
     * [详细描述]:
     *
     * @author Smalight Lv
     * @version 1.0, 2021/5/4 10:39
     * @since JDK 1.8
     */
    public class LinkedListT2 {
        public static void main(String[] args) {
            List<String> list = new LinkedList<>();
    
            list.add("刘备");
            list.add("关羽");
            list.add("张飞");
    
            for (String item:list) {
                System.out.println(item);
            }
            
        }
    }
    

    运行结果:

    刘备
    关羽
    张飞
    

    3.3 使用迭代器(Integor)遍历

    package collect;
    
    import java.util.LinkedList;
    import java.util.Iterator;
    import java.util.List;
    
    /**
     * [简要描述]:使用迭代器遍历LinkedList
     * [详细描述]:
     *
     * @author Smalight Lv
     * @version 1.0, 2021/5/4 10:44
     * @since JDK 1.8
     */
    public class LinkedListT3 {
        public static void main(String[] args) {
            List<String> list = new LinkedList<>();
    
            list.add("刘备");
            list.add("关羽");
            list.add("张飞");
    
            Iterator<String> iterator = list.iterator();
            while(iterator.hasNext()){
                String str = iterator.next();
                System.out.println(str);
            }
    
        }
    }
    

    运行结果:

    刘备
    关羽
    张飞
    
    展开全文
  • LinkedList浅析

    万次阅读 2018-08-27 10:29:39
    LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口,能对它进行队列操作。 LinkedList 实现 Deque 接口,...
  • LinkedList特点和常用操作

    千次阅读 2019-12-27 10:55:17
    创建LinkedList2.访问LinkedList3.Iterator遍历4.forEach 遍历 一、在线API 在线API 二、特点 LinkedList实现了Queue、Deque接口,; ArrayList适合删除操作,因为删除不会发生移位; ArrayList可以包含重复的元素...
  • LinkedList的实现方式

    2019-08-06 20:10:07
    LinkedList是基于双向链表机制,所谓双向链表机制,就是集合中的每个元素都知道其前一个元素和其后的一个元素的位置LinkedList中,以一个内部的Entry类来代表集合中的元素,元素赋值给element...在创建LinkedList对...
  • LinkedList集合 implements List接口 特点: ...1.创建LinkedList集合对象 LinkedList<String> linkedList=new LinkedList<>(); //往集合中添加元素 linkedList.add("a"); linkedList.
  • 实例创建 LinkedList linkedList = new LinkedList(); 内部声名了Node类型的first和last属性,默认值为null,first为整个链表的第一个地址,last为整个链表的最后一个地址 list.add("hello"); 进行add操作时,把...
  • 当我们创建LinkedList对象时,内部声明了node类型的有一个first属性与last属性, 该属性一开始都为null,当我们使用add()函数去想对象里面添加属性的时候, first与last会相应的变化,简单来说就是前一个元素的...
  • 首先创建LinkedList并塞入数据LinkedList&lt;String&gt; list = new LinkedList&lt;&gt;(); list.add("James"); list.add("Irving"); list.addFirst("Curry"); ...
  • LInkedList集合底层 ...1、创建一个对象 首先看到以下代码: LinkedList l=new LinkedList(); l.add("a"); l.add("b"); l.add("c"); 首先,执行LinkedList l=new LinkedList();执行到的源码如下: trans
  • 用LinkedList模拟栈数据结构的集合并测试 A:案例演示 需求:请用LinkedList模拟栈数据结构的集合,并测试 创建一个类将Linked中的方法封装 ... //创建LinkedList对象 public void in(Obje...
  • 前提:引入java.util包语法结构:相比叫ArrayList集合类,LinkedList更加灵活,在它基础上新增了头和尾的操作,比如从开头增加,从开头删除等等创建LinkedList类:LinkedList &lt;类型&gt; 集合名=new ...
  • 创建一个linkedlist作为容器,数据源定义在main方法中 写出一下方法: 1.录入5条工人信息 2.输出所有工人信息 3.根据工人的id通过匿名内部类进行排序,并且输出,要求工人的排序不影响源数据顺序 通过存放在一个新的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,419
精华内容 41,767
关键字:

创建linkedlist