android 集合架构四- LinkedList

最新推荐文章于 2024-05-04 22:38:12 发布
最新推荐文章于 2024-05-04 22:38:12 发布
阅读量567 收藏
点赞数
分类专栏： 开发 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiannanyijiayi/article/details/47442227
版权

直接上源码，通过阅读源码，我们自然就知道LinkedList实现的原理

 private static final class Link<ET> {
        ET data;

        Link<ET> previous, next;

        Link(ET o, Link<ET> p, Link<ET> n) {
            data = o;
            previous = p;
            next = n;
        }
    }
使用结点来存储数据 

    private static final class LinkIterator<ET> implements ListIterator<ET> {
        int pos, expectedModCount;

        final LinkedList<ET> list;

        Link<ET> link, lastLink;

        LinkIterator(LinkedList<ET> object, int location) {
            list = object;
            expectedModCount = list.modCount;
            if (location >= 0 && location <= list.size) {
                // pos ends up as -1 if list is empty, it ranges from -1 to
                // list.size - 1
                // if link == voidLink then pos must == -1
                link = list.voidLink;
                if (location < list.size / 2) {
                    for (pos = -1; pos + 1 < location; pos++) {
                        link = link.next;
                    }
                } else {
                    for (pos = list.size; pos >= location; pos--) {
                        link = link.previous;
                    }
                }
            } else {
                throw new IndexOutOfBoundsException();
            }
        }

        public void add(ET object) {
            if (expectedModCount == list.modCount) {
                Link<ET> next = link.next;
                Link<ET> newLink = new Link<ET>(object, link, next);
                link.next = newLink;
                next.previous = newLink;
                link = newLink;
                lastLink = null;
                pos++;
                expectedModCount++;
                list.size++;
                list.modCount++;
            } else {
                throw new ConcurrentModificationException();
            }
        }

        public boolean hasNext() {
            return link.next != list.voidLink;
        }

        public boolean hasPrevious() {
            return link != list.voidLink;
        }

        public ET next() {
            if (expectedModCount == list.modCount) {
                LinkedList.Link<ET> next = link.next;
                if (next != list.voidLink) {
                    lastLink = link = next;
                    pos++;
                    return link.data;
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();
        }

        public int nextIndex() {
            return pos + 1;
        }

        public ET previous() {
            if (expectedModCount == list.modCount) {
                if (link != list.voidLink) {
                    lastLink = link;
                    link = link.previous;
                    pos--;
                    return lastLink.data;
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();
        }

        public int previousIndex() {
            return pos;
        }

        public void remove() {
            if (expectedModCount == list.modCount) {
                if (lastLink != null) {
                    Link<ET> next = lastLink.next;
                    Link<ET> previous = lastLink.previous;
                    next.previous = previous;
                    previous.next = next;
                    if (lastLink == link) {
                        pos--;
                    }
                    link = previous;
                    lastLink = null;
                    expectedModCount++;
                    list.size--;
                    list.modCount++;
                } else {
                    throw new IllegalStateException();
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }

        public void set(ET object) {
            if (expectedModCount == list.modCount) {
                if (lastLink != null) {
                    lastLink.data = object;
                } else {
                    throw new IllegalStateException();
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }
    }

上面是实现了自己的遍历Iterator，有点类似指针 

 private class ReverseLinkIterator<ET> implements Iterator<ET> {
        private int expectedModCount;

        private final LinkedList<ET> list;

        private Link<ET> link;

        private boolean canRemove;

        ReverseLinkIterator(LinkedList<ET> linkedList) {
            list = linkedList;
            expectedModCount = list.modCount;
            link = list.voidLink;
            canRemove = false;
        }

        public boolean hasNext() {
            return link.previous != list.voidLink;
        }

        public ET next() {
            if (expectedModCount == list.modCount) {
                if (hasNext()) {
                    link = link.previous;
                    canRemove = true;
                    return link.data;
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();

        }

        public void remove() {
            if (expectedModCount == list.modCount) {
                if (canRemove) {
                    Link<ET> next = link.previous;
                    Link<ET> previous = link.next;
                    next.next = previous;
                    previous.previous = next;
                    link = previous;
                    list.size--;
                    list.modCount++;
                    expectedModCount++;
                    canRemove = false;
                    return;
                }
                throw new IllegalStateException();
            }
            throw new ConcurrentModificationException();
        }
    }
 此类是倒叙遍历，倒叙删除集合

  

 /**
     * Constructs a new empty instance of {@code LinkedList}.
     */
    public LinkedList() {
        voidLink = new Link<E>(null, null, null);
        voidLink.previous = voidLink;
        voidLink.next = voidLink;
    }
给最后一个节点赋值 

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

默认添加一个集合主要还是看addAll 方法 

 @Override
    public boolean addAll(Collection<? extends E> collection) {
        int adding = collection.size();
        if (adding == 0) {
            return false;
        }
        Collection<? extends E> elements = (collection == this) ?
                new ArrayList<E>(collection) : collection;

        Link<E> previous = voidLink.previous;
        for (E e : elements) {
            Link<E> newLink = new Link<E>(e, previous, null);
            previous.next = newLink;
            previous = newLink;
        }
        previous.next = voidLink;
        voidLink.previous = previous;
        size += adding;
        modCount++;
        return true;
    }

添加集合，首先检验这个集合的长度，假如为0 返回false，取最后一个不为null的previous ，然后在 循环里面，new 一个新的newLink，把 newlink 赋值为 previous.next，然后再把newlink赋值给previous ，这样就能再下次循环中给newlink的next复制了，循环结束后，赋值最后一个为voidLink,此时size 以及相关变量也修改。

 public void add(int location, E object) {
        if (location >= 0 && location <= size) {
            Link<E> link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            Link<E> previous = link.previous;
            Link<E> newLink = new Link<E>(object, previous, link);
            previous.next = newLink;
            link.previous = newLink;
            size++;
            modCount++;
        } else {
            throw new IndexOutOfBoundsException();
        }
    }

首先要明白，LinkedList 是一环形的链表，最后的voidLink.next 指向首link，所以计算一下location的位置，是偏前还是偏后，假如是在前半列，直接使用voidLink的next 去寻找要添加位置当前的link，假如是在后半列，使用voidLink的 previous，这样可以减少寻找的次数。

 public boolean add(E object) {
        return addLastImpl(object);
    }

    private boolean addLastImpl(E object) {
        Link<E> oldLast = voidLink.previous;
        Link<E> newLink = new Link<E>(object, oldLast, voidLink);
        voidLink.previous = newLink;
        oldLast.next = newLink;
        size++;
        modCount++;
        return true;
    }
默认添加数据，是添加在列表的末尾的位置 

<pre name="code" class="java"> public boolean addAll(int location, Collection<? extends E> collection) {
        if (location < 0 || location > size) {
            throw new IndexOutOfBoundsException();
        }
        int adding = collection.size();
        if (adding == 0) {
            return false;
        }
        Collection<? extends E> elements = (collection == this) ?
                new ArrayList<E>(collection) : collection;

        Link<E> previous = voidLink;
        if (location < (size / 2)) {
            for (int i = 0; i < location; i++) {
                previous = previous.next;
            }
        } else {
            for (int i = size; i >= location; i--) {
                previous = previous.previous;
            }
        }
        Link<E> next = previous.next;
        for (E e : elements) {
            Link<E> newLink = new Link<E>(e, previous, null);
            previous.next = newLink;
            previous = newLink;
        }
        previous.next = next;
        next.previous = previous;
        size += adding;
        modCount++;
        return true;
    }


 在特定位置添加集合，还是得找到此刻特定位置的link，逻辑和上面相同，略过... 

 

 

 public void addFirst(E object) {
        addFirstImpl(object);
    }

    private boolean addFirstImpl(E object) {
        Link<E> oldFirst = voidLink.next;
        Link<E> newLink = new Link<E>(object, voidLink, oldFirst);
        voidLink.next = newLink;
        oldFirst.previous = newLink;
        size++;
        modCount++;
        return true;
    }
 

 在列表头加入数据，上面已经提过，此列表是一个环形的列表，应该利用 voieLink.next 就是第一条数据 

 

 

 @Override
    public void clear() {
        if (size > 0) {
            size = 0;
            voidLink.next = voidLink;
            voidLink.previous = voidLink;
            modCount++;
        }
    }
清理数据，只需要把voidLink 的previous 和next 赋值为null 就可以了 

 

 

 @Override
    public E remove(int location) {
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            Link<E> previous = link.previous;
            Link<E> next = link.next;
            previous.next = next;
            next.previous = previous;
            size--;
            modCount++;
            return link.data;
        }
        throw new IndexOutOfBoundsException();
    }

    @Override
    public boolean remove(Object object) {
        return removeFirstOccurrenceImpl(object);
    }
 

  删除特定位置的元素，这个也是根据voidLink 来寻找在特定位置的数据 

 

方法就不再一一列举了，LinkedList 原理是一个环形的闭合链表，并且我们是通过最后一条数据来寻找特定位置的数据，无论是增删改查都是通过voidLink这个元素来遍历元素的，和ArrsyList比较 查找数据比较慢，但是添加和删除数据是较快的。
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 

 

 


 
 

                

        

        

    

  


    

      

        

            

              
                
                  tiannanyijiayi
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Android: 数组、List(LinkedList、ArrayList、Vector/Stack)

				
			

			

				

					TK - Kung
				

				

					12-04
					
					2632
					
				

			

		

		

			
				
LinkedList：

1、添加元素：

如果不指定索引的话，元素将被添加到链表的最后.
public boolean add(Object element)
public boolean add(int index, Object element)
也可以把链表当初栈或者队列来处理:
public boolean addFirst(Object element)
public boolean addLast(Object element)
addLast()方法和不带索引的add()方法实现的效果一样


			
		

	



                

            
              



	

		

			

				
					
android LinkedList的基本用法

				
			

			

				

					谢岩的博客
				

				

					08-03
					
					5833
					
				

			

		

		

			
				
今天，讲讲android LinkedList的使用。


LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
LinkedList的构造函数如下
1. public LinkedList():  ——生成空的链表
2. public LinkedList(Collection col):  复制构造函数
1、获取链表的第一个和最后一个元素
im

			
		

	



              


  
              

                


	

		

			

				
					
Android LinkedList★★

				
			

			

				

					zenmela2011的专栏
				

				

					04-05
					
					1067
					
				

			

		

		

			
				
1. LinkedList

①LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。
②LinkedList 实现 List 接口，能对它进行队列操作；实现 Deque 接口，即能将LinkedList当作双端队列使用；实现了Cloneable接口，即覆盖了函数clone()，能克隆；实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
③LinkedList 是非同步的。

2.LinkedList.

			
		

	





	

		

			

				
					
Android LinkedList 分析

				
			

			

				

					寻梦者
				

				

					04-13
					
					731
					
				

			

		

		

			
				
简介
LinkedList是Collection下的一个list实现，它是一个以双向链表实现的List，除了作为List使用，还可以当做队列和栈来使用，下面我们就来看看具体的实现细节。
继承关系图

通过上面的继承关系图，我们知道它实现了List接口，还实现了Queue和Deque接口，所以还能作为双端队列进行使用，最后还实现了Serializable 接口，说明也是可序列化的。
源代码分析

模...

			
		

	



		

			
		



	

		

			

				
					
android 中 ArrayList 、LinkList、List 区别

				
			

			

				

					weixin_30505485的博客
				

				

					04-19
					
					285
					
				

			

		

		

			
				
1.大学数据结构中ArrayList是实现了基于动态数组的数据结构，LinkList基于链表的数据结构。 

2.对于随机访问get和set，ArrayList优于LinkList，因为LinkedList要移动指针。 

3.对于新增和删除操作add和remove，LinkList比较占优势，因为ArrayList要移动数据。

从上面三点可以看出：

ArrayList和Lin...

			
		

	





	

		

			

				
					
android-java-前端-面经-工具集合

				
			

			

				

					03-15
				

			

		

		

			
				
 - **集合框架**：ArrayList、LinkedList、HashMap、HashSet等数据结构的实现原理及使用场景。  - **并发编程**：线程的创建、同步机制（synchronized、volatile、Lock接口）以及并发设计模式。  - **IO/NIO**：文件...

			
		

	





	

		

			

				
					
Android------面试简答题

					
热门推荐

				
			

			

				

					leehbhs的博客
				

				

					08-03
					
					2万+
					
				

			

		

		

			
				
一。.简单概述SVN与Git的区别？
1.GIT是分布式的，SVN不是
2.GIT把内容按元数据方式存储，而SVN是按文件

3.GIT分支和SVN的分支不同

4.GIT没有一个全局的版本号，而SVN有

5.GIT的内容完整性要优于SVN
二.简述listview的优化策略？
1.复用convertView，减少findViewById的次数

2.ListView中数

			
		

	





	

		

			

				
					
Android项目开发如何设计整体架构？完整PDF

				
			

			

				

					m0_57066131的博客
				

				

					05-26
					
					238
					
				

			

		

		

			
				
Android开发的现状
目前，移动开发已经处于饱和的阶段，Android开发也不如当年盛况，已经不再像前几年前那么火爆。正如一种编程语言如果经历过盛极一时，那么必然有这样的一条曲线，像我们学的正弦曲线先急速上升，然后到达顶点，然后再下降，最后再趋近一个平稳的值。
可以看到，从2016年的下半年开始，移动互联网基本处于缓慢发展的阶段，很多大佬称之为互联网的下半场。如果移动互联网的前半场是粗放式的强地盘阶段，那么下半场就是守地盘的阶段，这一阶段，会出现众多的寡头。
在技术上，相比之前之前面试只问Android

			
		

	





	

		

			

				
					
Android 开发面试题集合整理（内含答案），2021最新网易Android面经

				
			

			

				

					m0_64603743的博客
				

				

					12-12
					
					3844
					
				

			

		

		

			
				
从另一个组件跳转到目标 activity ，需要通过 intent 进行跳转。具体
Intent intent=new Intent(this,activity.class),startActivity(intent)
2.ArrayList和LinkedList各自特点，应用场景（一加）

参考答案：
ArrayList和LinkedList都是实现了List接口的容器类，用于存储一系列的对象引用。他们都可以对元素的增删改查进行操作，那么他们区别、优缺点应用场景都有哪些呢？我们通过源码和数据结构...

			
		

	





	

		

			

				
					
android-interview:Android面试题

				
			

			

				

					03-22
				

			

		

		

			
				
 - **集合框架**：掌握ArrayList、LinkedList、HashMap、HashSet等数据结构的特性与使用场景。  - **线程与并发**：理解Thread、Runnable接口，同步机制（synchronized关键字，wait/notify，Lock接口）以及并发工具...

			
		

	





	

		

			

				
					
使用LinkedList模拟堆栈

				
			

			

				

					11-09
				

			

		

		

			
				
使用LinkedList模拟堆栈操作，包括进栈、出栈，入队、出队

			
		

	





	

		

			

				
					
android区别——ArrayList和LinkedList

				
			

			

				

					chuntiandejiaobu10的专栏
				

				

					08-29
					
					4455
					
				

			

		

		

			
				
LinkedList和ArrayList的差别主要来自于Array和LinkedList数据结构的不同。ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦。而LinkedList 采用的将对象存放在独立的空间中，且在每个空间中还保存下一个链接的索引，但是缺点就是查找非常麻烦，需要从第一个索引开始。


这两者都是实现了Lis

			
		

	





	

		

			

				
					
基于LinkedList高性能android列表适配器

				
			

			

				

					huazai30000的专栏
				

				

					03-06
					
					426
					
				

			

		

		

			
				
高性能的LinkedList的android适配器数据结构！

			
		

	





	

		

			

				
					
Redis源码剖析(跳表)

				
			

			

				

					wangrenhaioylj的博客
				

				

					10-04
					
					195
					
				

			

		

		

			
				
在树形结构中，常见的平衡树有AVL树和红黑树，但是由于AVL树过于平衡，导致维护平衡所需的代价过大，使用的不多，不过其中几种旋转算法还是值得学习的。取而代之的是较为平衡的红黑树，STL中的map和set都是采用红黑树实现的，插入和查找效率为O(logN)。 
而跳表也是一种较为平衡的...

			
		

	





	

		

			

				
					
Android LinkedList的部分源码解析

				
			

			

				

					wozuihaole的博客
				

				

					09-07
					
					359
					
				

			

		

		

			
				
写这篇文章主要是因为我自认为我画了一幅很好看的双向链表图，O(∩_∩)O哈哈~
LinkedList是链式存储方式的线性表，LinkedList中的元素有前区和后继，头尾前区后继互指所以是双向循环链表


private static final class LinkET> {
    ET data;

    LinkET> previous, next;

    Link(ET o

			
		

	





	

		

			

				
					
2024年Android最全LinkedList源码解析(手把手带你熟悉链表)，2024年最新2024年华为面试题

					
最新发布

				
			

			

				

					2401_84558467的博客
				

				

					05-04
					
					972
					
				

			

		

		

			
				
注意看下图箭头方向,这样节点2就可以直接断开,节点1和节点3直接连接,这里也可以很明显的看出,链表增删很快,只需要断开前后节点就可以。两个节点断开只需要将自己的上一个节点的右节点指向自己的下一个节点左节点,同时自己的下一个节点的左节点,指向上一个节点的右节点。//判断左节点是否为空,如果为空说明当前节点为(头结点)第一个节点。//判断右节点是否为空,如果为空说明当前为(尾节点)最后一个节点。//判断右节点是否为空,如果为空说明当前为(尾节点)最后一个节点。

			
		

	





	

		

			

				
					
android的ArrayList和LinkedList的应用场景和源码分析

				
			

			

				

					蓝冷然的博客
				

				

					06-26
					
					1270
					
				

			

		

		

			
				
android的ArrayList和LinkedList的应用场景和源码分析简介结论源码分析构造函数ArrayListLinkedListadd方法ArrayListLinkedListadd(int index, E object)方法ArrayListLinkedList
简介
ArrayList和LinkedList都是AbstractList的子类，都实现了List接口。而且都是日常开发中...

			
		

	





	

		

			

				
					
Android 技能图谱学习路线系列-Java基础之ArrayList与LinkedList

				
			

			

				

					u014742338的博客
				

				

					09-29
					
					137
					
				

			

		

		

			
				
Java中ArrayList与LinkedList的区别


对于实现方式，ArrayList的实现是基于数组，LinkedList的实现是基于双向链表。


对于查询操作，ArrayList优于LinkedList，ArrayList可以根据下标以O(1)时间复杂度对元素进行查询。而LinkedList的每一个元素都依靠地址指针和它后一个元素连接在一起，在这种情况下，查找某个元素的时间复杂度是O...

			
		

	





	

		

			

				
					
什么是 LinkedList

				
			

			

				

					weixin_34337381的博客
				

				

					02-24
					
					1975
					
				

			

		

		

			
				
一.  概述
LinkedList 是 Java 集合中比较常用的数据结构，与 ArrayList 一样，实现了 List 接口，只不过 ArrayList 是基于数组实现的，而 LinkedList 是基于链表实现的。所以 LinkedList 插入和删除方面要优于 ArrayList，而随机访问上则 ArrayList 性能更好。
除了 LIst 接口之外，LinkedList 还实现了 De...

			
		

	





	

		

			

				
					
Android面试必备：操作系统架构与内存管理

				
			

			

				

					
				

			

		

		

			
				
 - **集合类**：包括ArrayList、LinkedList、HashSet、HashMap等，它们各自有不同的特性和适用场景，如ArrayList适合随机访问，LinkedList适合频繁插入和删除。  - **Socket基础**：Socket是网络通信的基础，它提供...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值