Linkedlist与ArrayList学习

最新推荐文章于 2024-06-22 18:14:23 发布
最新推荐文章于 2024-06-22 18:14:23 发布
阅读量213 收藏
点赞数
分类专栏： 一天一小步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35785121/article/details/52167328
版权

       通过上一章的学习，可以知道LinkedList实现了Deque、List等接口，链表的实现主要依靠Entry对象。上一章已经对LinkedList的队列接口方法的进行了分析与了解，本章主要分析LinkedList中List接口方法的实现；还有ArrayList的List接口方法的学习；并且分析两种方法使用的情况。

      以下为测试代码

  

public class LinkList_ArrayList {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		getAddTime(100000);
		getAddIndexTime(100000,70000);
	}
	public static void getAddTime(int count){
		ArrayList<String> arr = new ArrayList<String>();//默认长度为10
		LinkedList<String> linl = new LinkedList<String>();
		Long arr_start = new Date().getTime();
		for(int i=1;i<=count;i++){
			arr.add(i+"");//当数组空间已满，增加原有长度的1/2
			
		}
		Long arr_end = new Date().getTime();
		System.out.println("ArrayList 增加"+count+"耗时:"+(arr_end-arr_start));
		Long linl_start = new Date().getTime();
		for(int i=1;i<=count;i++){
			linl.add(i+"");//当数组空间已满，增加原有长度的1/2
			
		}
		Long linl_end = new Date().getTime();
		System.out.println("LinkedList 增加"+count+"耗时:"+(linl_end-linl_start));
	}
	public static void getAddIndexTime(int count,int index){
		ArrayList<String> arr = new ArrayList<String>();//默认长度为10
		LinkedList<String> linl = new LinkedList<String>();
		for(int i=1;i<=count;i++){
			arr.add(i+"");//当数组空间已满，增加原有长度的1/2
		}
		Long arr_start = new Date().getTime();
		for(int i=1;i<=count;i++){
			arr.add(index,i+"");//当数组空间已满，增加原有长度的1/2
		}
		Long arr_end = new Date().getTime();
		System.out.println("ArrayList  在指定位置"+index+"增加"+count+"耗时:"+(arr_end-arr_start));
		for(int i=1;i<=count;i++){
			linl.add(i+"");//当数组空间已满，增加原有长度的1/2
			
		}
		Long linl_start = new Date().getTime();
		for(int i=1;i<=count;i++){
			linl.add(index,i+"");//当数组空间已满，增加原有长度的1/2
		}
		Long linl_end = new Date().getTime();
		System.out.println("LinkedList 在指定位置"+index+"增加"+count+"耗时:"+(linl_end-linl_start));
	}

}
      运行结果为  

      ArrayList 增加100000耗时:78
      LinkedList 增加100000耗时:94

      ArrayList  在指定位置70000增加100000耗时:7738
      LinkedList 在指定位置70000增加100000耗时:192660

     为什么同一类调用不同的插入节点方法耗时差距如此之大，为什么LinkedList 在利用索引插入时为什么效率远低于ArrayList (即使在1000W个节点也一样)？我们来看一下ArrayList与LinkedList的 add(E e)方法源码

// ArrayList的源码   
public boolean add(E e) {
	ensureCapacity(size + 1);  // Increments modCount!!此方法用于增加数组大小，如果超出数组大小之后会自动增加1/2+1的长度
	elementData[size++] = e;
	return true;
    }
//LinkedList的源码
public boolean add(E e) {
<span style="white-space:pre">	</span>addBefore(e, header);
        return true;
  }

private Entry<E> addBefore(E e, Entry<E> entry) {
<span style="white-space:pre">	</span>Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
<span style="white-space:pre">	</span>newEntry.previous.next = newEntry;
<span style="white-space:pre">	</span>newEntry.next.previous = newEntry;
<span style="white-space:pre">	</span>size++;
<span style="white-space:pre">	</span>modCount++;
<span style="white-space:pre">	</span>return newEntry;
   }

        通过分析源码可以发现，对于这两个方法增加节点的方法时间复杂度都是O（1）,所以他们插入相同节点个数的时间相差无几，接下来我们可以在看一下带有索引插入节点的方法

// ArrayList的源码  
    public void add(int index, E element) {
<span style="white-space:pre">	</span>if (index > size || index < 0)
<span style="white-space:pre">	</span>    throw new IndexOutOfBoundsException(
<span style="white-space:pre">		</span>"Index: "+index+", Size: "+size);


<span style="white-space:pre">	</span>ensureCapacity(size+1);  // Increments modCount!!
<span style="white-space:pre">	</span>System.arraycopy(elementData, index, elementData, index + 1,
<span style="white-space:pre">			</span> size - index);
<span style="white-space:pre">	</span>elementData[index] = element;
<span style="white-space:pre">	</span>size++;
    }

<pre name="code" class="java">//LinkedList的源码
    public void add(int index, E element) {
        addBefore(element, (index==size ? header : entry(index)));
    } 

 

 private Entry<E> entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
    }

 

    private Entry<E> addBefore(E e, Entry<E> entry) {
<span style="white-space:pre">	</span>Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
<span style="white-space:pre">	</span>newEntry.previous.next = newEntry;
<span style="white-space:pre">	</span>newEntry.next.previous = newEntry;
<span style="white-space:pre">	</span>size++;
<span style="white-space:pre">	</span>modCount++;
<span style="white-space:pre">	</span>return newEntry;
    }
          通过观察源码可以发现对于ArrayList，在使用索引插入节点元素的时候，其方法的时间复杂度为O(1)，影响其效率的主要原因是数组的复制过程，而 
LinkedList在使用索引插入元素的时候，其时间复杂度为O(1),但是当他调用entry(index)方法会有一个遍历链表的过程，这个方法的时间复杂度为O((n+2)/4)要远大于O(1)，所以在使用索引插入元素的时候，LinkedList效率远低于ArrayList。 

 

          在List接口中有如下几个常用方法：
 

 

 isEmpty()
 

         contains(Object o)
 

         remove(Object o)
 

         containsAll(Collection<?> c)
 

         addAll(int index, Collection<? extends E> c)
 

         removeAll(Collection<?> c)
 

        retainAll(Collection<?> c)
 

        get(int index)
 

        set(int index, E element)
 

        add(int index, E element)
 

        remove(int index)
 

        indexOf(Object o)
 

        通过查看两个类的源码可以发现contains(Object o)， containsAll(Collection<?> c)其中在containsAll中调用了contains，而contains有调用了indexOf(Object o)方法，所以indexOf(Object o)的执行效率影响着这三个方法，我们来看下面的代码
 

      
 

public static void getIndexOfTime(int count,int count_con,int index){
		ArrayList<String> arr = new ArrayList<String>();//默认长度为10
		LinkedList<String> linl = new LinkedList<String>();
		ArrayList<String> con = new ArrayList<String>();
		for(int i=1;i<=count;i++){
			arr.add(i+"");//当数组空间已满，增加原有长度的1/2
			
		}
		for(int i=1;i<=count;i++){
			linl.add(i+"");//当数组空间已满，增加原有长度的1/2
			
		}
		for(int i=1;i<=count_con;i++){
			int p = 400000;
			con.add((p+i)+"");//当数组空间已满，增加原有长度的1/2
		}
		Long start_indexof = new Date().getTime();
		arr.indexOf(index+"");
		Long end_indexof = new Date().getTime();
		System.out.println("ArrayList方法indexOf 在"+count+"条数据中，第"+index+"个位置需要耗时"+(end_indexof-start_indexof));
		Long startlinl_indexof = new Date().getTime();
		linl.indexOf(index+"");
		Long endlinl_indexof = new Date().getTime();
		System.out.println("LinkedList方法indexOf 在"+count+"条数据中，第"+index+"个位置需要耗时"+(endlinl_indexof-startlinl_indexof));
		Long start_contains = new Date().getTime();
		arr.contains(index+"");
		Long end_contains = new Date().getTime();
		System.out.println("ArrayList方法contains 在"+count+"条数据中，第"+index+"个位置需要耗时"+(end_contains-start_contains));
		Long startlinl_contains = new Date().getTime();
		linl.contains(index+"");
		Long endlinl_contains = new Date().getTime();
		System.out.println("LinkedList方法contains 在"+count+"条数据中，第"+index+"个位置需要耗时"+(endlinl_contains-startlinl_contains));
		Long start_containsAll = new Date().getTime();
		arr.containsAll(con);
		Long end_containsAll = new Date().getTime();
		System.out.println("ArrayList方法containsAll 在"+count+"条数据中，第"+index+"个位置需要耗时"+(end_containsAll-start_containsAll));
		Long startlinl_containsAll = new Date().getTime();
		linl.containsAll(con);
		Long endlinl_containsAll = new Date().getTime();
		System.out.println("LinkedList方法containsAll 在"+count+"条数据中，第"+index+"个位置需要耗时"+(endlinl_containsAll-startlinl_containsAll));
			
	}
 

<pre name="code" class="java">        getIndexOfTime（500000,5,500000）运行结果为
 

 

 

                ArrayList方法indexOf 在500000条数据中，第500000个位置需要耗时3 
 

                LinkedList方法indexOf 在500000条数据中，第500000个位置需要耗时9 
 

                ArrayList方法contains 在500000条数据中，第500000个位置需要耗时4 
 

                LinkedList方法contains 在500000条数据中，第500000个位置需要耗时7 
 

               ArrayList方法containsAll 在500000条数据中，第500000个位置需要耗时17 
 

               LinkedList方法containsAll 在500000条数据中，第500000个位置需要耗时26
 

 

         和我们预测的一样两个检测包含的方法的效率依赖于indexOf，而ArrayList底层时数组实现所以起indexOf效率要高于LinkedList。接下来我们分析List中三个删除方法在两个链表中的效率。下面为测试代码
 

 

	public static void getRemoveTime(int count,int element,int index){
		ArrayList<String> arr = new ArrayList<String>();//默认长度为10
		LinkedList<String> linl = new LinkedList<String>();
		ArrayList<String> con = new ArrayList<String>();
		for(int i=1;i<=count;i++){
			arr.add(i+"");//当数组空间已满，增加原有长度的1/2
			
		}
		for(int i=1;i<=count;i++){
			linl.add(i+"");
			
		}
		for(int i=1;i<=10;i++){
			int p = 250000;
			con.add((p+i)+"");//当数组空间已满，增加原有长度的1/2
		}
	
		Long start_remove = new Date().getTime();
		arr.remove(index);
		Long end_remove = new Date().getTime();
		System.out.println("ArrayList方法remove 在"+count+"条数据中，第"+index+"个位置需删除元素要耗时"+(end_remove-start_remove));
		Long startlinl_remove = new Date().getTime();
		linl.remove(index);
		Long endlinl_remove = new Date().getTime();
		System.out.println("LinkedList方法remove 在"+count+"条数据中，第"+index+"个位置需删除元素要耗时"+(endlinl_remove-startlinl_remove));
		Long start_remove_OBJ = new Date().getTime();
		arr.remove(element+"");
		Long end_remove_OBJ = new Date().getTime();
		System.out.println("ArrayList方法remove  OBJ 在"+count+"条数据中，删除"+element+"元素要耗时"+(end_remove_OBJ-start_remove_OBJ));
		Long startlinl_remove_OBJ = new Date().getTime();
		linl.remove(element+"");
		Long endlinl_remove_OBJ = new Date().getTime();
		System.out.println("LinkedList方法remove OBJ 在"+count+"条数据中，删除"+element+"位置需插入元素要耗时"+(endlinl_remove_OBJ-startlinl_remove_OBJ));
		Long start_removeAll = new Date().getTime();
		arr.removeAll(con);
		Long end_removeAll = new Date().getTime();
		System.out.println("ArrayList方法removeAll 在"+count+"条数据中，删除容器元素要耗时"+(end_removeAll-start_removeAll));
		Long startlinl_removeAll = new Date().getTime();
		linl.removeAll(con);
		Long endlinl_removeAll = new Date().getTime();
		System.out.println("LinkedList方法removeAll 在"+count+"条数据中，删除容器元素要耗时"+(endlinl_removeAll-startlinl_removeAll));
		
	}
 

          getRemoveTime(500000,240000,250000)，运行结果（最后一个参数选择250000而不是0或者490000） 

 

ArrayList方法remove 在500000条数据中，第250000个位置需删除元素要耗时0
 LinkedList方法remove 在500000条数据中，第250000个位置需删除元素要耗时8
 ArrayList方法remove  OBJ 在500000条数据中，删除280000元素要耗时3
 LinkedList方法remove OBJ 在500000条数据中，删除280000位置需插入元素要耗时5
 ArrayList方法removeAll 在500000条数据中，删除容器元素要耗时53
 LinkedList方法removeAll 在500000条数据中，删除容器元素要耗时47
 

接下来将getRemoveTime方法做一下调整
 

 

public static void getRemoveTime(int count,int element,int index){
		ArrayList<String> arr = new ArrayList<String>();//默认长度为10
		LinkedList<String> linl = new LinkedList<String>();
		ArrayList<String> con = new ArrayList<String>();
		ArrayList<String> con_linl = new ArrayList<String>();
		for(int i=1;i<=count;i++){
			arr.add(i+"Hellow Word ArrayList!");//当数组空间已满，增加原有长度的1/2
			
		}
		for(int i=1;i<=count;i++){
			linl.add(i+"Hellow Word LinkedList!");
			
		}
		for(int i=1;i<=1;i++){
			int p = 2000000;
			con.add((p+i)+"Hellow Word ArrayList!");//当数组空间已满，增加原有长度的1/2
		}
		for(int i=1;i<=1;i++){
			int p = 2000000;
			con_linl.add((p+i)+"Hellow Word LinkedList!");//当数组空间已满，增加原有长度的1/2
		}
		Long start_remove = new Date().getTime();
		arr.remove(index);
		Long end_remove = new Date().getTime();
		System.out.println("ArrayList方法remove 在"+count+"条数据中，第"+index+"个位置需删除元素要耗时"+(end_remove-start_remove));
		Long startlinl_remove = new Date().getTime();
		linl.remove(index);
		Long endlinl_remove = new Date().getTime();
		System.out.println("LinkedList方法remove 在"+count+"条数据中，第"+index+"个位置需删除元素要耗时"+(endlinl_remove-startlinl_remove));
		Long start_remove_OBJ = new Date().getTime();
		arr.remove(element+"Hellow Word ArrayList!");
		Long end_remove_OBJ = new Date().getTime();
		System.out.println("ArrayList方法remove  OBJ 在"+count+"条数据中，删除"+element+"元素要耗时"+(end_remove_OBJ-start_remove_OBJ));
		Long startlinl_remove_OBJ = new Date().getTime();
		linl.remove(element+"Hellow Word LinkedList!");
		Long endlinl_remove_OBJ = new Date().getTime();
		System.out.println("LinkedList方法remove OBJ 在"+count+"条数据中，删除"+element+"元素要耗时"+(endlinl_remove_OBJ-startlinl_remove_OBJ));
		Long start_removeAll = new Date().getTime();
		arr.removeAll(con);
		Long end_removeAll = new Date().getTime();
		System.out.println("ArrayList方法removeAll 在"+count+"条数据中，删除容器元素要耗时"+(end_removeAll-start_removeAll));
		Long startlinl_removeAll = new Date().getTime();
		linl.removeAll(con_linl);
		Long endlinl_removeAll = new Date().getTime();
		System.out.println("LinkedList方法removeAll 在"+count+"条数据中，删除容器元素要耗时"+(endlinl_removeAll-startlinl_removeAll));
		
	}
 

 
运行getRemoveTime(3000000,1,1000)得到如下运行结果 

 

ArrayList方法remove 在3000000条数据中，第1000个位置需删除元素要耗时2
 LinkedList方法remove 在3000000条数据中，第1000个位置需删除元素要耗时0
 ArrayList方法remove  OBJ 在3000000条数据中，删除1元素要耗时2
 LinkedList方法remove OBJ 在3000000条数据中，删除1元素要耗时0
 ArrayList方法removeAll 在3000000条数据中，删除容器元素要耗时119
 LinkedList方法removeAll 在3000000条数据中，删除容器元素要耗时97
 
 

修改运行参数getRemoveTime(3000000,200000,2000000);得到一下运行结果
 

ArrayList方法remove 在3000000条数据中，第2000000个位置需删除元素要耗时0
 LinkedList方法remove 在3000000条数据中，第2000000个位置需删除元素要耗时42
 ArrayList方法remove  OBJ 在3000000条数据中，删除2000000元素要耗时15
 LinkedList方法remove OBJ 在3000000条数据中，删除2000000元素要耗时61
 ArrayList方法removeAll 在3000000条数据中，删除容器元素要耗时116
 LinkedList方法removeAll 在3000000条数据中，删除容器元素要耗时92
 

        比较后两次的运行结果可以看出，当被移除元素越靠近链表中央LinkedList的效率越低(由于起遍历特点导致的)；而ArrayList被移除元素越靠后效率越高(元素越靠后移动元素的个数越少，操作时间也越短)。通过着三个例子也可以看出，ArrayList与LinkedList的效率涉及到链表的遍历耗时与删除节点的操作时间，尤其是后者对于不同的服务器计算能力不同可能会有差异，所以需要根据实际情况来判断使用那种链表(但一般来数如果链表长度越大，ArrayList的删除效率会远低于LinedList，因为数组的移位操作比较耗时)
 

      LinkedList 元素越靠近链表中央，效率越低由于起遍历特点决定的，能够从下面的源码看出来
 

 

    private Entry<E> entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
    }
 

            ArrayList元素越靠近链表尾端，效率越高由于起调用这个方法
 

          System.arraycopy(elementData, index+1, elementData, index,numMoved)。
           对于get(int index)，set(int index, E element)两个方法由于没有涉及到元素的移动只有遍历和修改节点内容所以ArrayList的效率要高于LinkedList
          在两个类中，所有的方法都没有进行同步处理，所以这两个类都是线程非安全的，不支持多线，如果需要同步处理则需要进行外部同步。
          Vector为适量队列，他也实现了List接口，并且底层与ArrayList一样也是由动态数组实现，但他内部做了同步处理，线程安全。
          Stack继承自Vector，实现先进后出的功能，内部同样做了同步处理，线程安全。
 


 
 

     
 

               
 


 
 
 

 
 
 

 

 
 
  

 

 

 

 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 


 

                

        

        

    

  


    

      

        

            

              
                
                  weixin_35785121
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Java学习之路之LinkedList与ArrayList的区别

				
			

			

				

					BaiPuPuls的博客
				

				

					08-08
					
					214
					
				

			

		

		

			
				
Java学习之路之LinkedList与ArrayList的区别。

			
		

	



                

              
                



	

		

			

				
					
Java集合系列(LinkedHashMap+LinkedList+ArrayList)

				
			

			

				

					06-20
				

			

		

		

			
				
Java 集合系列(LinkedHashMap+LinkedList+ArrayList)  Java 集合系列是 Java 语言中的一种数据结构，用于存储和操作数据。今天，我们将介绍 Java 集合系列中的三个重要成员：LinkedHashMap、LinkedList 和 ArrayList...

			
		

	



                


  
              

                


	

		

			

				
					
ArrayList和LinkedList的总结学习

				
			

			

				

					l_x_l_x_的博客
				

				

					11-23
					
					338
					
				

			

		

		

			
				
一、ArrayList 
1.ArrayList默认开辟10个大小的空间; 
2.底层由数组实现; 
3.当ArrayList容量不足的时候会自动进行扩容，每次以1.5倍的速度扩容JDK 1.6    int newCapacity = oldCapacity + (oldCapacity >> 1);  
JDK 1.8    int newCapacity = oldCapacity*3/2+1

			
		

	





	

		

			

				
					
ArrayList 与 LinkedList

				
			

			

				

					jiaomubai的博客
				

				

					05-23
					
					1940
					
				

			

		

		

			
				
ArrayList、LinkedList、ArrayList 与 LinkedList 的区别

			
		

	



		

			
		



	

		

			

				
					
LinkedList与ArrayList的区别

				
			

			

				

					zhaomengxia123的博客
				

				

					06-29
					
					341
					
				

			

		

		

			
				
1.ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表的数据结构

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

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

ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用

时间复杂度：

ArrayList的内部实现是基于基础的对象数组的，因此，它使用get方法访问列表中的任意

			
		

	





	

		

			

				
					
ArrayList和LinkedList详解

				
			

			

				

					RRLOVEXX20210818的博客
				

				

					06-22
					
					1432
					
				

			

		

		

			
				
ArrayList是 Java 集合框架中的一个基本组件，它实现了List接口。作为一个基于数组实现的动态数组类，ArrayList提供了动态调整大小的能力，同时支持随机访问，是 Java 中使用非常广泛的数据结构之一。

			
		

	





	

		

			

				
					
LinkedList 与 ArrayList 的简单比较

				
			

			

				

					nahfang的博客
				

				

					04-09
					
					341
					
				

			

		

		

			
				
两种容器的简单比较

			
		

	





	

		

			

				
					
LinkedList 与 ArrayList 的区别

				
			

			

				

					此心光明事上练的博客
				

				

					11-30
					
					220
					
				

			

		

		

			
				
LinkedList和ArrayList最明显的区别在于它们存储对象的方式。

ArrayList更适合于存储和访问数据，因为它与普通数组非常相似。

LinkedList更适合操作数据，比如进行大量的插入和删除操作。

除了存储对象之外，LinkedList还存储相邻元素内存地址（或链接）。

它被称为LinkedList，是因为每个元素都包含到相邻元素的链接。


LinkedList<String> c = new LinkedList<String>();
c.add("Re

			
		

	





	

		

			

				
					
LinkedList和ArrayList异同

				
			

			

				

					qq_42280451的博客
				

				

					05-23
					
					683
					
				

			

		

		

			
				
相同点:1.LinkedList跟ArrayList都是有序的;2.

			
		

	





	

		

			

				
					
LinkedList与ArrayList

				
			

			

				

					tiegenZ的博客
				

				

					08-04
					
					424
					
				

			

		

		

			
				
LinkedList与ArrayList的区别

			
		

	





	

		

			

				
					
linkedList 与 arrayList 区别 适用场景

				
			

			

				

					怀揣梦想，一颗执着于技术的心从未磨灭，内心住着一颗顽强的小强时刻提醒自己层层突破自我，同时也成就他人
				

				

					05-08
					
					402
					
				

			

		

		

			
				
增加和删除：LinkedList在添加和删除元素（add和remove操作）时效率更高，因为它只需要修改相关节点的指针即可，而不需要移动大量数据。而ArrayList在添加或删除元素时，可能需要移动操作点之后的所有元素，以保持数组的连续性。此外，由于LinkedList可以在任意位置进行高效的添加/删除操作，因此也适用于需要有序集合并对元素进行排序的场景。随机访问：ArrayList在随机访问元素（get和set操作）时效率更高，因为元素在内存中是连续存储的，可以通过下标直接访问。但使用相对不那么方便。

			
		

	





	

		

			

				
					
Java中ArrayList和LinkedList区别

				
			

			

				

					12-22
				

			

		

		

			
				
在Java编程语言中，ArrayList和LinkedList都是集合框架中两种重要的列表实现，它们分别基于不同的数据结构，具有不同的特性和性能特点。以下是对这两个类的详细分析：  1. 数据结构：  - ArrayList是基于动态数组的...

			
		

	





	

		

			

				
					
java中ArrayList与LinkedList对比详情

				
			

			

				

					08-30
				

			

		

		

			
				
Java 中 ArrayList 与 LinkedList 对比详情  在 Java 中，ArrayList 和 LinkedList 是两个常用的集合实现方式，它们都实现了 Collection 接口，但是它们之间存在着一些关键的差异。本文将通过实例对比 Java 中 ...

			
		

	





	

		

			

				
					
comsol模拟不同形状晶粒的煤体、岩体、土体的水力压裂、煤层压裂相场本构模型，内含不同尺寸的骨料、晶粒 
案例文件众多，包含不

					
最新发布

				
			

			

				

					10-10
				

			

		

		

			
				
comsol模拟不同形状晶粒的煤体、岩体、土体的水力压裂、煤层压裂相场本构模型，内含不同尺寸的骨料、晶粒。
案例文件众多，包含不同尺寸方形晶粒、圆形晶粒、椭圆形晶粒、微小晶粒等。



			
		

	





	

		

			

				
					
病房管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip

				
			

			

				

					10-09
				

			

		

		

			
				
病房管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）
启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B

			
		

	





	

		

			

				
					
技术资料分享非常好的通俗易懂的开关电源原理与维修5.zip

				
			

			

				

					10-09
				

			

		

		

			
				
技术资料分享非常好的通俗易懂的开关电源原理与维修5.zip

			
		

	





	

		

			

				
					
使用固体氧化物燃料电池供电的数据中心的废热来冷却其服务器的集成系统的设计Matlab代码.rar

				
			

			

				

					10-09
				

			

		

		

			
				
1.版本：matlab2014/2019a/2024a

 2.附赠案例数据可直接运行matlab程序。 

3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 

4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 

			
		

	





	

		

			

				
					
用于开发和测试大脑情感唤醒特征（BAAS）的代码.rar

				
			

			

				

					10-09
				

			

		

		

			
				
1.版本：matlab2014/2019a/2024a

 2.附赠案例数据可直接运行matlab程序。 

3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 

4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值