List集合详细介绍

迈不过友情╰ 2023-10-12 15:23 61阅读 0赞

##  ##

**目录**

List集合概述

一.List集合的特点

二.遍历方式

三.LinkedList实现堆栈容器

四.增长因子

--------------------

## List集合概述 ##

List集合是一个元素有序（每个元素都有对应的顺序索引，第一个元素索引为0）、且可重复的集合。

####  ####

## 一.List集合的特点 ##

**1.list集合容器具备增删改查  
2.有序  
3.元素可重复**

package com.liao.tast;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * list集合的特点 
     * 
     * 1.list集合容器具备增删改查
     * 2.有顺序
     * 3.元素可以重复
     * @author liao
     *
     */
    public class Dome1 {
    	public static void main(String[] args) {
    		List list = new ArrayList();
    		//增加
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		
    		
    		System.out.println(list);
    		//删除
    		list.remove("b");
    		System.out.println(list);
    		//修改
    		list.set(1, "v");
    		//查看
    		System.out.println(list);
    		
    	}
    
    }

## 二.遍历方式 ##

**1.forir  
2.foreach  
3.迭代器 iteration**

package com.liao.tast;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    /**
     * List的循环方式
     * 1.forir 
     * 2.foreach
     * 3.迭代器 iteration
     * 
     * 
     * @author Administrator
     *
     */
    public class Dome2 {
    
    	public static void main(String[] args) {
    		List list = new ArrayList();
    		// 增加
    		list.add("a");
    		list.add("b");
    		list.add("c");
    
    		// forir遍历
    		for (int i = 0; i < list.size(); i++) {
    			System.out.println(list.get(i));
    		}
    		// foreach遍历
    		for (Object object : list) {
    			System.out.println(object);
    		}
    
    		// 迭代器遍历
    		Iterator it = list.iterator();
    		while (it.hasNext()) {
    			System.out.println(it.next());
    		}
    	}
    	
    	
    	
    }

##  **三.LinkedList实现堆栈容器** ##

package com.liao.tast;
    /**
     * LinkedList实现堆栈容器
     * @author liao
     *
     */
    
    import java.util.LinkedList;
    
    public class Dome3 {
    	
    	
    	public static void main(String[] args) {
    		/**
    		 * LinkedList特点 
    		 * 链表方式
    		 * 查询修改速度慢  增加删除快
    		 * 
    		 */
    		LinkedList ll = new LinkedList();
    		//增加
    		ll.add("a");
    		ll.add("b");
    		ll.add("c");
    		//实例化DuiZhan
    		DuiZhan dz = new DuiZhan(ll);
    		
    		//弹栈
    		System.out.println(dz.pop());
    		System.out.println(dz.pop());
    		System.out.println(dz.pop());
    	}
    }
    	//创建一个类DuiZhan
    	class DuiZhan {
    		private LinkedList ll;
    
    		public DuiZhan(LinkedList ll) {
    			super();
    			this.ll = ll;
    		}
    		
    		//压栈 弹栈
    		public Object pop(){
    			return ll.removeLast();
    			
    		}
    	}

运行结果：

![03cf0db0adb948888e1759d62d4e0228.png][]

**堆栈特点：先进后出，意思是先进去的数据会最后输出**

## 四.增长因子 ##

**1.数组长度不可改变 但是集合长度可以扩容**

优化前：数据到达长度上限就会一直增长扩容就会导致会影响性能

package com.liao.tast;
    /**
     * list调优
     * ArrayList
     * @author Administrator
     *	ArrayList扩容因子1.5   增长因子0.5
     */
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    //ArrayList特点：查询修改快 增加删除慢
    public class Dome4 {
    public static void main(String[] args) throws Exception, Exception  {
    	//定义ArrayList数组
        //没有优化前
    	ArrayList list = new ArrayList();
    	for (int i = 0; i < 100; i++) {
    		list.add(list);
    		System.out.print(i+"\r");
    		getCurrentArrayLength(list);
    	}
    	
    }
    //获取当前数组的长度
    private static void getCurrentArrayLength(ArrayList list) throws Exception, SecurityException {
    	Field f = list.getClass().getDeclaredField("elementData");
    	f.setAccessible(true); 
    	Object[] object = (Object[]) f.get(list);
    	System.out.println("当前容器长度"+object.length);
    }
    	
    	
    	
    	
    	
    	
    }

运行结果：

![e5b6f7862eaf4978a2489d35a4c3194a.png][]

--------------------

**优化后**：指定长度就可以优化

package com.liao.tast;
    /**
     * list调优
     * ArrayList
     * @author Administrator
     *	ArrayList扩容因子1.5   增长因子0.5
     */
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    //ArrayList特点：查询修改快 增加删除慢
    public class Dome4 {
    public static void main(String[] args) throws Exception, Exception  {
    	//定义ArrayList数组
        //优化后
    	ArrayList list = new ArrayList(50);//到50在进行扩容
    	for (int i = 0; i < 100; i++) {
    		list.add(list);
    		System.out.print(i+"\r");
    		getCurrentArrayLength(list);
    	}
    	
    }
    //获取当前数组的长度
    private static void getCurrentArrayLength(ArrayList list) throws Exception, SecurityException {
    	Field f = list.getClass().getDeclaredField("elementData");
    	f.setAccessible(true); 
    	Object[] object = (Object[]) f.get(list);
    	System.out.println("当前容器长度"+object.length);
    }
    	
    	
    	
    	
    	
    	
    }

运行结果：

![3de298ac20584b5785631b7cf35e4ced.png][]

**结论：数组长度每次增加到最大值就会扩容**

[03cf0db0adb948888e1759d62d4e0228.png]: https://img-blog.csdnimg.cn/03cf0db0adb948888e1759d62d4e0228.png
[e5b6f7862eaf4978a2489d35a4c3194a.png]: https://img-blog.csdnimg.cn/e5b6f7862eaf4978a2489d35a4c3194a.png
[3de298ac20584b5785631b7cf35e4ced.png]: https://img-blog.csdnimg.cn/3de298ac20584b5785631b7cf35e4ced.png