java集合——List

最新推荐文章于 2024-05-31 10:46:10 发布

L04593

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量191

点赞数

文章标签： java eclipse

本文链接：https://blog.csdn.net/l04593/article/details/119545904

版权

集合——List

List接口

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

实现类：

ArrayList
LinkedList
Vector
Stack

1.ArrayList

1.1使用ArrayList方法+泛型

泛型：数据安全的作法，规定集合应该存储什么样的数据类型

1.1.1 代码实现：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test01 {
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("小明");
		list.add("小白");
		list.add("小黑");
		list.add("小红");
		list.add("小强");
		
		int size = list.size();
		System.out.println("集合大小"+size);
		
		//设置指定下标
		list.set(2, "小刚");
		
		String element1 = list.get(0);
		System.out.println("获取指定下标0上的元素:"+element1);
		
		ArrayList<String> newList1 = new ArrayList<>();
		Collections.addAll(newList1, "aaa","bbb","ccc");//利用集合工具类进行批量添加
		list.addAll(newList1);//将新集合中所有的元素添加到指定集合的末尾
		
		ArrayList<String> newList2 = new ArrayList<>();
		Collections.addAll(newList2, "ddd","eee","fff");//利用集合工具类进行批量添加
		list.addAll(3, newList2);//将新集合中所有的元素添加到指定集合上指定下标的位置
		
		ArrayList<Object> newList3 = new ArrayList<>();
		Collections.addAll(newList3, "eee","ddd","fff","ggg");
		System.out.println("判断集合中是否包含某个集合中的所有元素："+list.containsAll(newList3));
		
		//删除 - 去除交集
		
		ArrayList<String> newList4 = new ArrayList<String>();
		Collections.addAll(newList4,"fff","aaa","bbb","xxx");
		list.removeAll(newList4);
		
		//保留交集 
		ArrayList<String> newList5 = new ArrayList<String>();
		Collections.addAll(newList5, "小明","小黑","小刚","小强");
		list.retainAll(newList5);
		
		//获取开始下标(包含)到结束下标(不包含)的元素，返回新的集合	
		List<String> subList = list.subList(1, 3);
				
		//将集合转换为数组
		Object[] array = subList.toArray();
		System.out.println(Arrays.toString(array));
				
		System.out.println("-----------------");
		
		//for遍历
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println("-----------------");
		
		//foreach遍历
		for (String element : list) {
			System.out.println(element);
		}
		
		System.out.println("-----------------");
		
		//Iterator迭代
		Iterator< String> iterator = list.iterator();
		while (iterator.hasNext()) {
			String e = iterator.next();
			System.out.println(e);
		}
		
		System.out.println("-----------------");
		
		//ListIterater迭代
		ListIterator< String> listIterator = list.listIterator();
		while (listIterator.hasNext()) {
			String e = listIterator.next();
			System.out.println(e);
		}
	}
}

1.1.2 泛型

含义：

数据安全的作用

代码实现：

package com.dream.generic;

public class A {

}

package com.dream.generic;

public class B extends A {

}

package com.dream.generic;

public class MyArrayList<E> {

	public boolean add(E e){
		return true;
	}
}

package com.dream.generic;

public class Test01 {
	
	public static void main(String[] args) {
		
		MyArrayList<String> list1 = new MyArrayList<>();
		list1.add("abc");
		
		MyArrayList<Integer> list2 = new MyArrayList<>();
		list2.add(123);
	}
}

1.1.3 泛型限定

代码实现：

package com.dream.generic;

public class A {

}

package com.dream.generic;

public class B extends A {

}

package com.dream.generic;

public class MyArrayList<E> {

	public boolean add(E e){
		return true;
	}
}

package com.dream.generic;

import java.util.ArrayList;

public class Test02 {
	
	public static void main(String[] args) {
	
	}
	
	//?：任何类型
	public ArrayList<?> method01(){
		ArrayList<String> list = new ArrayList<>();
		return list;
	}
	
	//? extends A
	//?：表示A的子类或者A类
	public ArrayList<? extends A> method02(){
//		ArrayList<B> list = new ArrayList<>();
		ArrayList<A> list = new ArrayList<>();
		return list;
	}
	
	//? super A
	//?：表示A的父类或A类
	public ArrayList<? super A> method03(){
//		ArrayList<Object> list = new ArrayList<>();
		ArrayList<A> list = new ArrayList<>();
		return list;
	}

}

2.迭代器

2.1 foreach底层原理

注意：

foreach底层由迭代器实现

代码实现：

package com.study.iterater;

import java.util.ArrayList;
import java.util.ListIterator;

public class Test01 {
	public static void main(String[] args) {
		
		//foreach 底层由迭代器实现
		
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("小明1");
		list.add("小明2");
		list.add("小明3");
		list.add("小明4");
		list.add("小明5");
		
		for (String e : list) {
			System.out.println(e);
		}
		
		//底层实现
//		String e;
//		for(Iterator<String> it = list.iterator();it.hasNext();System.out.println(e)){
//			e = it.next();
//		}
	}
}

2.2 Iterator迭代器

需求：

package com.study.iterater;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Test02 {

	public static void main(String[] args) {
		
ArrayList<String> list = new ArrayList<String>();
		
		list.add("小明1");
		list.add("小明2");
		list.add("小明3");
		list.add("小明4");
		list.add("小明5");
		
		Iterator<String> iterator = list.iterator();
		//遍历到“小明2”删除元素
		while(iterator.hasNext()) {
			
			String element1 = iterator.next();
			if(element1.equals("小明2")) {
				//list.remove(element1);
				/**
				 * java.util.ConcurrentModificationException
				 原因： ArrayList继承自AbstractList的
				 操作数ModCount会每次执行remove等方法后自增；同时，Iterator迭代器是
				 ArrayList内部中的一个接口，它有一个内部实现类Itr,初始expectedModCount = modCount
				 因此，list.remove(element1)执行过后，ModCount+1，expectedModCount不变
				 两者不相等，经判断后报异常
				 为什么要这样设计？
				 遍历是浏览数据，删除是改变数据，在浏览数据时不能删除数据，保证数据的一致性不会有脏数据的出现
				 */
				iterator.remove();
				/**
				 * iterator.remove()可以删除成功的原因是：
				 * 利用外部类对象调用remove方法（调用的ArrayList的remove方法）
                	ArrayList.this.remove(lastRet);
                	cursor游标初始为0，自增往下 lastRet 迭代元素下标，即先判断cursor对应拥有元素
                	lastRet才自增
                	cursor = lastRet;
                	lastRet = -1;
                    保证操作数和内部操作数一致
                	expectedModCount = modCount;
				 */
			
			}
		}
		for (String element : list) {
			System.out.println(element);
		}
    }
}

运行结果：

小明1
小明3
小明4
小明5

2.3 ListIterator迭代器

ListIterator迭代器区别于Iterator 它可以使用add()等方法

代码实现：

package com.study.iterater;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Test02 {

	public static void main(String[] args) {
		
ArrayList<String> list = new ArrayList<String>();
		
		list.add("小明1");
		list.add("小明2");
		list.add("小明3");
		list.add("小明4");
		list.add("小明5");
		
		ListIterator<String> listIterator = list.listIterator();
		//ListIterator指定遍历到位置添加元素
		while(listIterator.hasNext()) {
			String element2 = listIterator.next();
			if(element2.equals("小明3")){
				listIterator.add("小白");
			}
		}
		for (String element2 : list) {
			System.out.println(element2);
		}
		System.out.println("---------------");
		
		//使用ListIterator 倒叙
		ListIterator<String> listIterator2 = list.listIterator(list.size());
		while(listIterator2.hasPrevious()) {
			
			String element3 = listIterator2.previous();
			System.out.println(element3);
		}
        //指定替换元素
		ListIterator<String> listIterator3 = list.listIterator();
		while(listIterator3.hasNext()) {
			String element4 = listIterator3.next();
			if(element4.equals("小白")) {
				listIterator3.set("小黑");
			}
		}
		for (String element : list) {
			System.out.println(element);
		}
        //指定下标开始遍历
        ListIterator<String> listIterator4 = list.listIterator(1);
		while(listIterator4.hasNext()){
			String element = listIterator4.next();
			System.out.println(element);
		}
	}
}

运行结果：

小明1
小明3
小白
小明4
小明5
---------------
小明5
小明4
小白
小明3
小明1
---------------
小明1
小明3
小黑
小明4
小明5
---------------
小明3
小黑
小明4
小明5

3.LinkedList

LinkedList与ArrayList使用方法基本一致（插入，删除等）

3.1 LinkedList 队列模式

代码实现：

package com.study.linkedlist;

import java.util.LinkedList;

public class Test01 {
	public static void main(String[] args) {
		
		LinkedList<String > list = new LinkedList<String>();
		
		list.add("小明1");
		list.add("小明2");
		list.add("小明3");
		list.add("小明4");
		list.add("小明5");
		
		while(!list.isEmpty()) {
			
			//队列模式，先进先出
			// 删除第一个元素，并返回
			String element1 = list.removeFirst();
			System.out.println(element1);
			//小明1 小明2 小明3 小明4 小明5
			
		}
    }
}

3.2 LinkedList栈模式

代码实现：

package com.study.linkedlist;

import java.util.LinkedList;

public class Test01 {
	public static void main(String[] args) {
		
		LinkedList<String > list = new LinkedList<String>();
		
		list.add("小明1");
		list.add("小明2");
		list.add("小明3");
		list.add("小明4");
		list.add("小明5");
		
		while(!list.isEmpty()) {
			
			//栈模式，先进先出
			//删除最后一个元素，并返回
			String element2 = list.removeLast();
			System.out.println(element2);
			//小明5 小明4 小明3 小明2 小明1
			
		}
	}
}

4.Vector

Vector实现List接口，可以使用List中的方法（插入，删除等）

4.1 了解Vector中的老方法

package com.dream.vector_class;

import java.util.Enumeration;
import java.util.Vector;

public class Test02 {
	
	public static void main(String[] args) {
	
		Vector<String> v = new Vector<>();
		
		//添加元素
		v.addElement("小白1");
		v.addElement("小白2");
		v.addElement("小白3");
		v.addElement("小白4");
		v.addElement("小白5");
		v.addElement("小白6");
		
		//删除
		v.removeElement("小白2");//依据元素删除元素
		v.removeElementAt(2);//依据下标山存储元素
		
		//遍历
		Enumeration<String> elements = v.elements();
		while(elements.hasMoreElements()){
			String nextElement = elements.nextElement();
			System.out.println(nextElement);
		}	
	}
}

5.Stack

特点：

栈模式 - 先进后出

代码实现：

package com.dream.stack_class;

import java.util.Stack;

public class Test01 {
	
	public static void main(String[] args) {

		Stack<String> stack = new Stack<>();
		
		//添加元素 - 将元素压入栈顶
		v.addElement("小白1");
		v.addElement("小白2");
		v.addElement("小白3");
		v.addElement("小白4");
		v.addElement("小白5");
		v.addElement("小白6");
		
		System.out.println("距离栈顶的位置(从1开始)：" + stack.search("小白2"));
		
		while(!stack.empty()){
			//获取栈顶第一个元素，并返回
			//String element = stack.peek();
			
			//删除栈顶第一个元素，并返回
			String element = stack.pop();
			System.out.println(element);
		}
		
		System.out.println(stack.size());
	}

}

L04593

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java集合——List

集合——ListList接口特点：有序且可重复（因为List接口中添加了许多针对下标操作的方法）实现类：ArrayListLinkedListVectorStack1.ArrayList1.1使用ArrayList方法+泛型泛型：数据安全的作法，规定集合应该存储什么样的数据类型1.1.1 代码实现：import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;impor
复制链接

扫一扫