java List集合总结

版权声明：博主GitHub网址https://github.com/29DCH，欢迎大家前来交流探讨和fork。 https://blog.csdn.net/CowBoySoBusy/article/details/82219577

java集合是非常重要的一块,是每个java程序员必须掌握的内容,不仅要会使用这些集合的方法,还要对它们底层的数据结构实现原理有一定的了解。

这里就简单归纳一下List集合中关键的几个点:

List集合,有索引,元素可以重复,有序(存取一致)

用LinkedList(底层由链表实现,增删快,查询修改慢)模拟栈(队列也可模拟)

import java.util.LinkedList;

public class Test {

	/**
	 * 用LinkedList模拟栈结构
	 */
	public static void main(String[] args) {
		Stack s = new Stack();
		s.in("a");								//进栈
		s.in("b");
		s.in("c");
		s.in("d");
		while(!s.isEmpty()) {					//判断栈结构是否为空
			System.out.println(s.out());		//弹栈
		}
	}

}

class Stack {
	private LinkedList list = new LinkedList();
	
	/*
	 * 模拟进栈方法
	 */
	public void in(Object obj) {
		list.addLast(obj);
	}
	
	/*
	 * 模拟出栈
	 */
	public Object out() {
		return list.removeLast();//模拟队列时出队列应该是removeFirst(),其他的和栈的代码一样
	}
	
	/*
	 * 模拟栈结构是否为空
	 */
	
	public boolean isEmpty() {
		return list.isEmpty();
	}
}

输出:

d
c
b
a

 ArrayList(底层数组实现,增删慢,查询修改快)

ArrayList嵌套循环遍历:

import java.util.ArrayList;

public class Test {

	/**
	 * 集合嵌套之ArrayList嵌套ArrayList
	 */
	public static void main(String[] args) {
		ArrayList<ArrayList<Person>> list = new ArrayList<>();
		
		ArrayList<Person> first = new ArrayList<>();			
		first.add(new Person("a", 1));
		first.add(new Person("b", 2));
		first.add(new Person("c", 3));
		
		ArrayList<Person> second = new ArrayList<>();
		second.add(new Person("d", 4));
		second.add(new Person("e", 5));
		second.add(new Person("f", 6));
		
		list.add(first);
		list.add(second);
		
		for(ArrayList<Person> a : list) {
			for(Person p : a) {
				System.out.println(p);
			}
		}
	}

}
class Person {
	private String name;
	private int age;
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	/*@Override
	public boolean equals(Object obj) {
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}*/
	
}

输出:

Person [name=a, age=1]
Person [name=b, age=2]
Person [name=c, age=3]
Person [name=d, age=4]
Person [name=e, age=5]
Person [name=f, age=6]

ArrayList去除重复元素(重复属性值或者重复对象的成员变量值,注意不是对象的引用地址值):

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

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Test {

	/**
	    需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
		注意事项
	    * 重写equals()方法的contains方法判断是否包含,底层依赖的是equals方法
		* remove方法判断是否删除,底层依赖的是equals方法
	 */
	public static void main(String[] args) {
		ArrayList list = new ArrayList();				//创建集合对象
		list.add(new Person("张三", 23));
		list.add(new Person("张三", 23));
		list.add(new Person("李四", 24));
		list.add(new Person("李四", 24));
		list.add(new Person("李四", 24));
		list.add(new Person("李四", 24));
		
		ArrayList newList = getSingle(list);			//调用方法去除重复
		System.out.println(newList);
	}

	/*
	 * 创建新集合将重复元素去掉
	 * 1,明确返回值类型,返回ArrayList
	 * 2,明确参数列表ArrayList
	 * 
	 * 分析:
	 * 1,创建新集合
	 * 2,根据传入的集合(老集合)获取迭代器
	 * 3,遍历老集合
	 * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
	 */
	public static ArrayList getSingle(ArrayList list) {
		ArrayList newList = new ArrayList<>();					//1,创建新集合
		Iterator it = list.iterator();							//2,根据传入的集合(老集合)获取迭代器
		
		while(it.hasNext()) {									//3,遍历老集合
			Object obj = it.next();								//记录住每一个元素
			if(!newList.contains(obj)) {						//如果新集合中不包含老集合中的元素
				newList.add(obj);								//将该元素添加
			}
		}
		
		return newList;
	}
}

class Person {
	private String name;
	private int age;
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public boolean equals(Object obj) {
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
}

输出:

[Person [name=张三, age=23], Person [name=李四, age=24]] 

List迭代过程中集合修改出现并发修改异常的解决办法:

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

public class Test {

	/**
		for(元素数据类型 变量 : 数组或者Collection集合) {
			   使用变量即可，该变量就是元素
			}
		增强for循环底层依赖的是迭代器(Iterator)
	 */
	public static void main(String[] args) {
		demo1();
		demo2();
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
		
		//1,普通for循环删除,索引要--
		/*for(int i = 0; i < list.size(); i++) {
			if("b".equals(list.get(i))) {
				list.remove(i--);							//通过索引删除元素
			}
		}*/
		
		//2,迭代器删除
		/*Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			if("b".equals(it.next())) {
				//list.remove("b");							//不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
				it.remove();
			}
		}*/
		
		for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {
			if("b".equals(it2.next())) {
				//list.remove("b");							//不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
				it2.remove();
			}
		}
		//3,增强for循环,增强for循环不能删除或者修改等操作,只能遍历
		/**for (String string : list) {
			if("b".equals(string)) {
				list.remove("b");
			}
		}
		*/
		System.out.println(list);
	}

	public static void demo2() {
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("张三", 23));
		list.add(new Person("李四", 24));
		list.add(new Person("王五", 25));
		list.add(new Person("赵六", 26));
		
		for (Person person : list) {
			System.out.println(person);
		}
	}

	public static void demo1() {
		int[] arr = {11,22,33,44,55};
		for (int i : arr) {
			System.out.println(i);
		}
		
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		for (String string : list) {
			System.out.println(string);
		}
	}

}

class Person {
	private String name;
	private int age;
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public boolean equals(Object obj) {
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	
}

输出:

11

22

33

44

55

a

b

c

d

Person [name=张三, age=23]

Person [name=李四, age=24]

Person [name=王五, age=25]

Person [name=赵六, age=26]

[a, c, d]

 List还有其他一些操作比如foreach遍历,静态导入(不推荐使用),可变参数(实际就是类似传入变长数组做函数参数),AsList(数组转集合,不能增加或减少元素,可以使用其他集合中的方法),toArray(集合转数组,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size；数组的长度大于size,分配的数组长度就和指定的长度一样;基本数据类型的数组转换成集合,会将整个数组当作一个对象转换;将数组转换成集合,数组必须是引用数据类型)比较简单,就先不说了,大家自己去查资料了解一下就可以了。