List接口的实现类（ ArrayList，LinkedList，Vector，Stack）

这里写目录标题

List接口
- ArrayList:（一维数组）
- LinkedList:（双向链表）
- - LinkedList的使用：
  - - LinkedList的特有的方法：
    - [LinkedList 的队列模式（先进先出）：](#LinkedList 的队列模式（先进先出）：)
    - [LinkedList 的栈模式（先进后出或后进先出）:](#LinkedList 的栈模式（先进后出或后进先出）:)
- Vector:（一维数组+线程安全）
- - Vector的使用：
  - - Vector的老方法:
- Stack:
- - [研究Stack的特点 -- 栈模式（先进后出）](#研究Stack的特点 -- 栈模式（先进后出）)

List接口

特点：有序且可重复（因为List接口中添加了许多针对下标操作的方法）

实现类：

ArrayList

LinkedList

Vector

Stack

ArrayList:（一维数组）

初入集合：

java 复制代码

public class Test01 {
	public static void main(String[] args) {
		
		ArrayList list = new ArrayList();
		
        //一个集合可以存储多个类型的数据，
        //但是平时不会将多个数据类型的数据存入一个集合中，因为不好管理
		list.add(100);//Integer.valueOf(100)
		list.add(123.123);//Double.valueOf(123.123)
		list.add("abc");
		
	}

ArrayList的使用:

初入泛型：

集合一旦定义了泛型，就规定了集合存储元素的类型，所以说泛型是一种数据安全的做法。

java 复制代码

public static void main(String[] args) {
		
		//创建ArrayList集合的对象
    	//ArrayList<String> list = new ArrayList<String>();
		ArrayList<String> list = new ArrayList<>();
    
    	//添加元素
		list.add("abc");
    	//集合一旦定义了泛型，就规定了集合存储元素的类型，所以说泛型是一种数据安全的做法。
    	//只能存储String类型的数据
    	//list.add(123);
}

ArrayList的方法：

java 复制代码

public class Test02 {

	public static void main(String[] args) {
		
		//创建ArrayList集合的对象
		ArrayList<String> list = new ArrayList<>();
		
		//添加元素
		list.add("小红");
		list.add("小明");
		list.add("小黑");
		list.add("小白");
		list.add("小蓝");
		list.add("小绿");
		list.add("小灰");
		
		//设置指定下标上的元素
		list.set(1, "OYO");
		
		//获取指定下标上的元素
		String str = list.get(1);
		System.out.println("获取指定下标上的元素：" + str);//OYO
		
		//获取元素个数
		int size = list.size();
		System.out.println("获取元素个数：" + size);//7
		
		//将元素添加到指定下标的位置
		list.add(4, "土间埋");
		
		ArrayList<String> newList1 = new ArrayList<>();
        //利用Collections工具类给集合做批量添加
		Collections.addAll(newList1, "aaa","bbb","ccc","ccc");
        //将newList1中所有的元素添加到list集合的末尾
		list.addAll(newList1);
		
        
		ArrayList<String> newList2 = new ArrayList<>();
        //利用Collections工具类给集合做批量添加
		Collections.addAll(newList2, "xxx","yyy","zzz","zzz");
        //将newList2中所有的元素添加到list集合指定下标的位置
		list.addAll(4, newList2);
        
        
		//清空集合中所有的元素
		//list.clear();
		
		System.out.println("判断集合中是否包含指定元素：" + list.contains("小红"));//true
		System.out.println("判断集合中是否包含子集合中所有的元素：" + list.containsAll(newList1));//true
		
		System.out.println("获取集合中第一次出现该元素的下标：" + list.indexOf("ccc"));//13
		System.out.println("获取集合中最后一次出现该元素的下标：" + list.lastIndexOf("ccc"));//14
		
		System.out.println("判断集合中是否没有元素：" + list.isEmpty());//false
		
		list.remove(0);//根据下标删除元素
		list.remove("小白");//根据元素删除元素
		list.removeAll(newList1);//删除list中包含newList1的元素（去除交集）
		
		list.retainAll(newList2);//保留list中包含newList2的元素（保留交集）
		
		List<String> subList = list.subList(1, 3);//截取开始下标(包含)到结束下标(排他)处的元素，返回新的List集合
		

		
		
	}

集合与数组之间的转换：

java 复制代码

		//将集合转成数组
		Object[] objs = subList.toArray();
		System.out.println(Arrays.toString(objs));
		
		//将集合转成数组
		String[] ss = new String[2];
		//集合转成数组
		subList.toArray(ss);
		//数组转成字符串，方便输出。
		System.out.println(Arrays.toString(ss));

遍历数据：

java 复制代码

		//遍历数据 -- for循环
		for (int i = 0; i < list.size(); i++) {
            //list.get() 获取指定下标上的元素
			System.out.println(list.get(i));
		}
		
		System.out.println("--------------------------------");
		
		//遍历数据 -- foreach
		for (String element : list) {
			System.out.println(element);
		}
		
		System.out.println("--------------------------------");
		
		//遍历数据 -- Iterator
		Iterator<String> it = list.iterator();
		while(it.hasNext()){//判断是否有可迭代的元素
			
			String element = it.next();//返回下一个元素
			System.out.println(element);
		}
		
		System.out.println("--------------------------------");
		
		//遍历数据 -- ListIterator
		ListIterator<String> listIterator = list.listIterator();
		while(listIterator.hasNext()){//判断是否有可迭代的元素
			
			String element = listIterator.next();//返回下一个元素
			System.out.println(element);
		}

LinkedList:（双向链表）

LinkedList的使用：

LinkedList和ArrayList使用是一模一样的，这要归功于Conllection和List接口，因为接口是定义标准的！！！

只不过LinkedList和ArrayList底层实现原理是不一样的，LinkedList底层使用双向链表 去实现对于数据的操作(增删改查)

LinkedList的特有的方法：

java 复制代码

public static void main(String[] args) {
		
		LinkedList<String> list = new LinkedList<>();
		
		list.add("小红");
		list.add("abc");
		list.add("小明");
		list.add("abc");
		list.add("小蓝");
		list.add("abc");
		list.add("小绿");
		
		//将元素添加到首部
		list.addFirst("小黑");
		list.offerFirst("小白");
		list.push("小灰");
		
		
		//将元素添加到尾部
		list.addLast("xxx");
		list.offerLast("yyy");
		list.offer("zzz");
		
		System.out.println("获取第一个元素：" + list.element());
		System.out.println("获取第一个元素：" + list.getFirst());
		System.out.println("获取第一个元素：" + list.peek());
		System.out.println("获取第一个元素：" + list.peekFirst());

		System.out.println("获取最后一个元素：" + list.getLast());
		System.out.println("获取最后一个元素：" + list.peekLast());
		
		list.pop();//删除第一个元素
		list.poll();//删除第一个元素
		list.pollFirst();//删除第一个元素
		list.removeFirst();
		
		list.pollLast();//删除最后一个元素
		list.removeLast();//删除最后一个元素		
		
		list.removeFirstOccurrence("abc");//删除第一次出现的元素
		list.removeLastOccurrence("abc");//删除最后一个出现的元素
		
		//倒序遍历
//		Iterator<String> descendingIterator = list.descendingIterator();
//		while(descendingIterator.hasNext()){//hasNext()底层是判断是否有上一个元素
    		//next()底层是获取上一个元素
//			String element = descendingIterator.next();
//			System.out.println(element);
//		}
		
		System.out.println("----------------------------");
		
		for (String element : list) {
			System.out.println(element);
		}
		
	}

LinkedList 的队列模式（先进先出）：

java 复制代码

public static void main(String[] args) {
		
		LinkedList<String> list = new LinkedList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		while(!list.isEmpty()){
			
			String element = list.removeFirst();//删除第一个元素，并返回
			System.out.println(element);
			
		}
    /*
    结果：
    aaa
    bbb
    ccc
    ddd
    eee
    */
		
		System.out.println("获取元素个数：" + list.size());//0
	}

LinkedList 的栈模式（先进后出或后进先出）:

java 复制代码

public static void main(String[] args) {
		
		LinkedList<String> list = new LinkedList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		while(!list.isEmpty()){
			
			String element = list.removeLast();//删除最后一个元素，并返回
			System.out.println(element);
			
		}
    /*
    结果：
    eee
    ddd
    ccc
    bbb
    aaa
    */
		
		System.out.println("获取元素个数：" + list.size());//0
	}

Vector:（一维数组+线程安全）

Vector的使用：

Vector和ArrayList使用是一模一样的，这要归功于Conllection和List接口，因为接口是定义标准的！！！

只不过Vector和ArrayList底层实现原理是不一样的，Vector底层使用一维数组+线程安全 去实现对于数据的操作(增删改查)

Vector的老方法:

Vector的历史：

Vector是元老级别的类（JDK1.0），集合框架是JDK1.2开始才推出的概念，当时大部分程序员已经习惯Vector去存储数据，为了更好的推广集合框架和保留Vector，Java让Vector又多实现了List接口

经验：老的方法大多数使用element这个单词

java 复制代码

public class Test02 {

   public static void main(String[] args) {
      
      Vector<String> v = new Vector<>();
      
      v.addElement("aaa");
      v.addElement("bbb");
      v.addElement("ccc");
      v.addElement("ddd");
      v.addElement("eee");
      
      //清空
      //v.removeAllElements();
      
      v.removeElementAt(0);//根据下标删除元素
      v.removeElement("ccc");//根据元素删除元素
      
      v.setElementAt("666", 1);//将元素设置到指定下标的位置
      
       
       //迭代器
      Enumeration<String> elements = v.elements();
      while(elements.hasMoreElements()){
         
         String element = elements.nextElement();
         System.out.println(element);
      }
      
   }

Stack:

研究Stack的特点 -- 栈模式（先进后出）

该类继承Vector，所以Stack可以使用父类所有的非私有的方法。

java 复制代码

public class Test01 {

   public static void main(String[] args) {
      
      Stack<String> stack = new Stack<>();
      
      //将元素添加到栈顶
      stack.push("111");
      stack.push("222");
      stack.push("333");
      stack.push("444");
      stack.push("555");
      
      System.out.println("获取栈顶元素：" + stack.peek());//555
      
      int search = stack.search("222");
      System.out.println("获取元素距离栈顶的个数（基于1）：" + search);//4
      
      //遍历取出元素
      while(!stack.empty()){
         
         //删除栈顶元素，并返回
         String element = stack.pop();
         System.out.println(element);
      }
   }

List接口的实现类（ ArrayList，LinkedList，Vector，Stack）

这里写目录标题

List接口

ArrayList:（一维数组）

初入集合：

ArrayList的使用:

初入泛型：

ArrayList的方法：

集合与数组之间的转换：

遍历数据：

LinkedList:（双向链表）

LinkedList的使用：

LinkedList的特有的方法：

LinkedList 的 队列模式（先进先出）：

LinkedList 的 栈模式（先进后出 或 后进先出）:

Vector:（一维数组+线程安全）

Vector的使用：

Vector的老方法:

Stack:

研究Stack的特点 -- 栈模式（先进后出）

LinkedList 的队列模式（先进先出）：

LinkedList 的栈模式（先进后出或后进先出）: