List

向右看齐 2022-12-30 10:37 97阅读 0赞

# 概述： #

List是Collection的子接口同时他也是有序单列集合的顶层接口，除了继承单列集合的共性功能之外定义了有序单列集合特有的功能。学习他的特有功能，通过他的实现类【ArrayList】来学习。

# 特点： #

1、有序【指的：集合存取数据的顺序相同】

2、有索引【集合存放数据的位置有了编号，这个编号就是索引】

3、元素可重复【集合可以同时存放多个相同的数据】

# 应用 #

List   list  =  new ArrayList（）；（父接口指向子类对象）

# 特有方法： #

## add(int index ,Object o): ##

> 把指定的元素添加到指定的索引值位置

## remove(int index) : ##

> 删除指定位置的元素

## set(int index ,Object o): ##

> 给指定位置修改元素

## get(int index): ##

> 获取指定索引位置的元素

# 注意： #

优先执行特有的方法，使用的时候优先考虑特有方法

**代码示例：**

import java.util.ArrayList;
    import java.util.List;
    
    public class ListDemo {
        
    
    	public static void main(String[] args) {
        
    		//创建List集合对象
    		List list = new ArrayList();
    		//把指定的元素添加到指定的索引值位置
    		list.add(0, 10);
    		list.add(1, 20);
    		list.add(2, 30);
    		list.add(3, 40);
    		
    		//打印集合
    		System.out.println(list); //[10, 20, 30, 40]
    		
    		//删除指定位置索引
    		list.remove(2);
    		System.out.println(list); //[10, 20, 40]
    		
    		//给指定位置修改元素
    		list.set(1, 100);
    		System.out.println(list); //[10, 100, 40]
    		
    		//获取指定索引位置的元素
    		System.out.println(list.get(2)); //40
    		
    	}
    }

# List集合的遍历： #

## 概述： ##

List是Collection的子接口所以**数组法和迭代器照样可以使用**，同时List由于有索引了所以他在共性遍历的基础上增加了独有的遍历方式。

## 独有的遍历方式：for循环遍历 ##

通过for循环控制索引值的变化，通过特有方法\*\*get()\*\*方法获取集合的数据

**代码示例：**

import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class ListLoopDemo {
        
    	public static void main(String[] args) {
        
    		//创建List集合对象
    		List list = new ArrayList();
    		//添加元素
    		list.add(10);
    		list.add(20);
    		list.add(30);
    		list.add(40);
    		
    		//遍历(转换为数组进行遍历)
    		Object[] array = list.toArray();
    		for (int i = 0; i < array.length; i++) {
        
    			System.out.print(array[i] + " "); //10 20 30 40 
    		}
    		
    		System.out.println();
    		
    		//迭代器
    		//创建迭代器对象
    		Iterator iterator = list.iterator();
    		while (iterator.hasNext()) {
        
    			//获取元素对应位置的元素
    			Object obj = iterator.next();
    			System.out.print(obj + " ");  //10 20 30 40 
    		}
    		System.out.println();
    		
    		//for循环遍历
    		for (int i = 0; i < list.size(); i++) {
        
    			System.out.print(list.get(i) + " "); //10 20 30 40 
    		}
    	}
    
    }

# 并发修改异常【ConcurrentModificationException】 #

## 概述： ##

使用迭代器遍历集合的时候使用集合对象对集合进行了**增删操作**时产生的异常

## 原因： ##

使用迭代器遍历集合的时候使用集合对象对集合进行了**增删操作**

## 解决方案： ##

1、使用当前迭代器对象进行增删操作

2、不使用迭代器遍历

## 补充 ##

> **增加元素**要用当前迭代器对象调用add()方法  
>   
> **删除**集合元素，可以用集合对象调用remove(),也可以用迭代器对象调用  
>   
> **同时进行增加删除时，删除要在增加前**

\*\*代码示例： \*\*

import java.util.ArrayList;
    import java.util.List;
    import java.util.ListIterator;
    
    public class ListArrayList {
        
    	public static void main(String[] args) {
        
    		//需求：  测试列表迭代器
    		//1、创建集合对象
    		List list = new ArrayList();
    		//2、创建元素对象
    
    		//3、将元素对象添加到集合对象中
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		//4、遍历对象
    		//需求： 判断集合中如果有字符“a”，就在其后添加一个新的字符串“java”
    		//1、根据集合对象获取列表迭代器对象
    		ListIterator li = list.listIterator();
    		//2、判断迭代器中是否有元素
    		while (li.hasNext()) {
        
    		    //3、有就获取元素
    		    String s = (String)li.next();
    		    if ("b".equals(s)) {
         //正常应该为s.equals("b"),
    		                        // 但是因为s为变量，a为常量，所以当s为null时，
    		                        // 会发生空指针异常，这样写可以规避：空指针异常
    		        //能走到这里说明集合中有元素b
    		       // list.add("java"); //ConcurrentModificationException
    		                             //(并发修改异常，就是不能一边遍历一边添加元素)
    		       li.add("java");  //操作要在列表迭代器中，不然会报 并发修改异常
    		    }
    		    System.out.println(s);  // a b c
    		}
    
    		System.out.println("--------");
    		//打印新的集合中的值
    		System.out.println(list);  // a b java c
    	}
    
    }

# List的实现类 #

## 1、ArrayList ##

### 概述： ###

ArrayList就是单纯的为了实现List接口的功能而创建类，**他没有自己独有的功能**，功能**全部是Collection和List接口的功能**，**遍历方式就是List接口的遍历方式。**

### 特点： ###

> **查询快，增删慢**

### 存储方式： ###

底层由**数组**这个数据结构组成的，数组的结构是一个整体，当我们查询集合的数 据的时候通过索引直接定位到数据所在的数据结构的位置，所以查询速度相对较快，当我们对集合进行增删操作的时候要在对应的位置增加或删除小空间，数组的部分空间整体的下移或上移相对较慢

## 2、LinkedList ##

### 概述： ###

是List的实现类，除了实现List的所有功能还具有自己独有的方法，他主要提供对集合头部和尾部元素操作的功能，这个集合平时使用的时候很少使用这个集合的共性功能，多数时候使用自己独有的功能

### 特点： ###

> **查询慢，增删快**

### 存储方式： ###

他底层是有链表数据结构组成的，内部结构不是一个整体，他是通过地址指向链接的，查询集合中的元素的时候需要一个一个的节点去查看，所以查询比较慢，当我们集合进行增删的时候，只需要把操作节点的地址链接打断，重新链接新的地址指向就ok相对增删比较快

### 特有方法： ###

#### addFirst(Object o): ####

> 添加元素到集合的头部

#### addLast(Object o): ####

> 添加元素到集合的尾部

#### removeFirst()： ####

> 删除集合的首部元素

#### removeLast(): ####

> 删除集合的尾部元素

#### getFirst()： ####

> 获取首部元素

#### getLast()： ####

> 获取尾部元素

#### pop(): ####

> 弹出集合的首部元素【弹出元素时把此元素从集合中删除】

#### push(): ####

> 将元素压入集合的首部位置

**代码示例：**

import java.util.LinkedList;
    import java.util.List;
    
    public class LinkedListDemo {
        
    	public static void main(String[] args) {
        
    		//创建对象
    		LinkedList list = new LinkedList();
    		//添加元素
    		list.add("张三");
    		list.add("李四");
    		list.add("王五");
    		System.out.println(list);
    		
    		//添加元素到集合的头部
    		list.addFirst("Java");
    		System.out.println(list); //[Java, 张三, 李四, 王五]
    		
    		//添加元素到集合的尾部
    		list.addLast("Java");
    		System.out.println(list); //[Java, 张三, 李四, 王五, Java]
    		
    		//删除集合的首部元素
    		list.removeFirst();
    		System.out.println(list); //[张三, 李四, 王五, Java]
    		
    		//删除集合的尾部元素
    		list.removeLast();
    		System.out.println(list); //[张三, 李四, 王五]
    		
    		//获取首部元素
    		System.out.println(list.getFirst()); //张三
    		
    		//获取尾部元素
    		System.out.println(list.getLast()); //王五
    		
    		//弹出集合的首部元素【弹出元素时把此元素从集合中删除】
    		System.out.println(list); //[张三, 李四, 王五]
    		System.out.println(list.pop()); //张三
    		System.out.println(list); //[李四, 王五
    		
    		//将元素压入集合的首部位置(和addFirst()相同)
    		System.out.println(list); //[李四, 王五]
    		list.push("java");
    		System.out.println(list);  //[java, 李四, 王五]
    	}
    
    }