Java工具类--List集合（一）

/**
 * list集合使用
 * List
 *  |--Vector
 *  |--ArrayList
 *  |--LinkedList
 * 有序的 collection（也称为序列）。对列表中每个元素的插入位置进行精确地控制。
 * 可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
 * 特有方法：
 * 1，添加、2，删除、3，修改、4，获取、5，迭代器使用（重点）
 *
 */
public class ListDemo {

	public static void main(String[] args) {
		List<String> li =  new ArrayList<>();
		List<Personnel> lp = new ArrayList<Personnel>();
		System.out.println("操作字符：");
		fonctions(li);
		//迭代器
		iteratorf(li);
		System.out.println("\n操作对象：");
		fonctiono(lp);
		//迭代器
		iteratorw(lp);
		System.out.println("\nlistIterator使用：");
		listIterators(lp);
	}

	private static void fonctions(List<String> li) {
		//添加数据
		li.add("小明");
		li.add("小鹏");
		li.add("小芳");
		li.add("小莉");
		System.out.println("打印数据源："+li);

		//根据位置添加
		li.add(1, "周武");
		System.out.println("角标插入数据："+li);

		//角标删除
		System.out.println("角标删除数据："+li.remove(1));
		System.out.println("删除后数据："+li);

		//修改
		System.out.println("修改数据："+li.set(1, "shange"));
		System.out.println("修改后数据："+li);

		//获取数据
		System.out.println("获取数据："+li.get(2));


	}
	private static void fonctiono(List<Personnel> lp) {
		Personnel p = new Personnel("xiaofang",18);
		lp.add(new Personnel("zhangsan",10));
		lp.add(new Personnel("lisi",20));
		lp.add(new Personnel("wangwu",30));
		lp.add(p);
		System.out.println("打印对象数据源："+lp);

		//根据位置添加
		lp.add(1, new Personnel("大鹏",30));
		System.out.println("打印对象角标插入位置数据："+lp);

		//角标删除
		System.out.println("角标删除数据："+lp.remove(2));
		System.out.println("删除后数据："+lp);

		//修改
		System.out.println("修改数据："+lp.set(3,new Personnel("小芳",28)));
		System.out.println("修改后数据："+lp);

		//获取数据
		System.out.println("获取数据："+lp.get(2));

	}

	private static void iteratorf(List<String> li) {
		System.out.println("for循环迭代数据：");
		for (Iterator<String> it = li.iterator();it.hasNext();) {
			/**
			 * String s = it.next(); //此时出现ConcurrentModificationException异常
			 * if(s.equals(s)){
			 *		li.add("xxx");
			 *  }else
			 */
			System.out.println(it.next());
		}
	}

	private static void iteratorw(List<Personnel> lp) {
		System.out.println("while循环迭代数据：");		
		Iterator<Personnel> ip = lp.iterator();
		while(ip.hasNext()){
			System.out.println(ip.next());
		}
	}

	/**
	 * 在使用Iterator迭代器中，操作list集合时，会出现ConcurrentModificationException异常。
	 * list集合中，特有listIterator迭代器。
	 */
	private static void listIterators(List<Personnel> lp) {
		System.out.println("listIterators迭代器数据源："+lp);
		ListIterator<Personnel> lt = lp.listIterator();
		while(lt.hasNext()){
			Personnel p = lt.next();
			if(p.getName().equals("zhangsan")){
				p.setName("赵六");
				p.setAge(30);
				//替换
				lt.set(p);
				//添加不替换
				lt.add(p);
			}
			
		}
		System.out.println("listIterators迭代器操作后数据："+lp);
	}
}

运行结果：
操作字符：
打印数据源：[小明, 小鹏, 小芳, 小莉]
角标插入数据：[小明, 周武, 小鹏, 小芳, 小莉]
角标删除数据：周武
删除后数据：[小明, 小鹏, 小芳, 小莉]
修改数据：小鹏
修改后数据：[小明, shange, 小芳, 小莉]
获取数据：小芳
for循环迭代数据：
小明
shange
小芳
小莉

操作对象：
打印对象数据源：[zhangsan:10, lisi:20, wangwu:30, xiaofang:18]
打印对象角标插入位置数据：[zhangsan:10, 大鹏:30, lisi:20, wangwu:30, xiaofang:18]
角标删除数据：lisi:20
删除后数据：[zhangsan:10, 大鹏:30, wangwu:30, xiaofang:18]
修改数据：xiaofang:18
修改后数据：[zhangsan:10, 大鹏:30, wangwu:30, 小芳:28]
获取数据：wangwu:30
while循环迭代数据：
zhangsan:10
大鹏:30
wangwu:30
小芳:28

listIterator使用：
listIterators迭代器数据源：[zhangsan:10, 大鹏:30, wangwu:30, 小芳:28]
listIterators迭代器操作后数据：[赵六:30, 赵六:30, 大鹏:30, wangwu:30, 小芳:28]

接口 List<E>

所有超级接口：

Collection<E>,  Iterable<E>

boolean	add(E e)            向列表的尾部添加指定的元素（可选操作）。
void	add(int index, E element)            在列表的指定位置插入指定元素（可选操作）。
boolean	addAll(Collection<? extends E> c)            添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extends E> c)            将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear()            从列表中移除所有元素（可选操作）。
boolean	contains(Object o)            如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)            如果列表包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)            比较指定的对象与列表是否相等。
E	get(int index)            返回列表中指定位置的元素。
int	hashCode()            返回列表的哈希码值。
int	indexOf(Object o)            返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
boolean	isEmpty()            如果列表不包含元素，则返回 true。
Iterator<E>	iterator()            返回按适当顺序在列表的元素上进行迭代的迭代器。
int	lastIndexOf(Object o)            返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
ListIterator<E>	listIterator()            返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E>	listIterator(int index)            返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
E	remove(int index)            移除列表中指定位置的元素（可选操作）。
boolean	remove(Object o)            从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c)            从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean	retainAll(Collection<?> c)            仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element)            用指定元素替换列表中指定位置的元素（可选操作）。
int	size()            返回列表中的元素数。
List<E>	subList(int fromIndex, int toIndex)            返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Object[]	toArray()            返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
<T> T[]	toArray(T[] a)            返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

接口 ListIterator<E>
所有超级接口：Iterator<E>

void	add(E e)            将指定的元素插入列表（可选操作）。
boolean	hasNext()            以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
boolean	hasPrevious()            如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E	next()            返回列表中的下一个元素。
int	nextIndex()            返回对 next 的后续调用所返回元素的索引。
E	previous()            返回列表中的前一个元素。
int	previousIndex()            返回对 previous 的后续调用所返回元素的索引。
void	remove()            从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void	set(E e)            用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。