List集合循环遍历删除修改保存内容的测试：以及报错：ConcurrentModificationException

package com.taotao.cart.controller;

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

import com.taotao.manager.pojo.TbItem;
/**
 * List 集合中保存数据的修改和移除
 * -----------------测试一-------------------
 *   * 测试使用增强for循环删除和修改List保存对象
	 * 	1 移除list内的对象：
	 * 		1.1 循环删除多个对象时：报错java.util.ConcurrentModificationException
	 * 		1.2 只删除一个对象，然后使用break停止循环，则不报错
	 * 	2 修改内容不报错
 * -----------------测试二-------------------
 * 	 * 测试使用普通for循环删除和修改List保存对象
	 * 	1 移除list内的对象：
	 * 		1.1 升序循环
	 * 			1.1.1 循环删除多个对象时：不报错，但是数据有较大误差
	 * 			1.1.2 只删除一个对象，然后使用break停止循环:则不报错，且数据正确
	 * 		1.2 降序循环
	 * 			删除多个或一个都不报错，且数据准确
	 * 	2 修改内容不报错
 * 
 * -----------------测试三-------------------
 * 	 * 测试使用Iterator循环删除和修改List保存对象
	 * 	1 使用list移除其内的对象：
	 * 		1.1 移除多个 :报错java.util.ConcurrentModificationException
	 * 		1.2 移除一个 :不报错，数据正常
	 * 	2 使用Iterator移除list中的对象： 
	 * 		2.1 移除多个 :正确不报错
	 * 		2.2 移除一个:正确不报错
	 * 	3 修改内容不报错: 正确不报错
 * @Description 
 * @ClassName Tes
 * @Author [浅醉]
 * @Date 2019年2月27日 下午2:12:07
 */
public class Tes {
	public static void main(String[] args) {
		//test1();
		//test2();
		test3();
	}
	/**
	 * 测试使用增强for循环删除和修改List保存对象
	 * 	1 移除list内的对象：
	 * 		1.1 循环删除多个对象时：报错java.util.ConcurrentModificationException
	 * 		1.2 只删除一个对象，然后使用break停止循环，则不报错
	 * 	2 修改内容不报错
	 * 
	 */
	public static void test1(){
		List<Person> list = new ArrayList();
		Person p1 = new Person("张三", 1);
		Person p2 = new Person("李四", 2);
		Person p3 = new Person("王二", 3);
		
		list.add(p1);
		list.add(p2);
		list.add(p3);
		System.out.println(list.size());
		for(Person temp : list){
			
			
			/*-----------1.1 循环删除多个数据报错------------*/
			//list.remove(temp); 循环删除多个数据报错
			
			/*-----------1.2  删除一个数据，然后停止循环，则不报错------------*/
			if(temp.getName().equals("李四")){
				list.remove(temp);
				break;   
			}
			/*-----------1.3  修改数不报错------------*/
			//temp.setName("liili"); 
		}
		for(Person temp : list){
			System.out.println(temp.getName());
			
		}
		System.out.println(list.size());
	}
	/**
	 * 测试使用普通for循环删除和修改List保存对象
	 * 	1 移除list内的对象：
	 * 		1.1 升序循环
	 * 			1.1.1 循环删除多个对象时：不报错，但是数据有较大误差
	 * 			1.1.2 只删除一个对象，然后使用break停止循环:则不报错，且数据正确
	 * 		1.2 降序循环
	 * 			删除多个或一个都不报错，且数据准确
	 * 	2 修改内容不报错
	 * 
	 */
	public static void test2(){
		List<Person> list = new ArrayList();
		Person p1 = new Person("张三", 1);
		Person p2 = new Person("李四", 2);
		Person p3 = new Person("王二", 3);
		
		list.add(p1);
		list.add(p2);
		list.add(p3);
		System.err.println("操作前list集合大小："+list.size());
		
		/*----------1.1.1 循环删除多个对象时：不报错，但是数据有较大误差------------*/
		
		/*for(int i = 0;i<list.size();i++){
			System.out.println("list的实时大小："+list.size());
			System.out.println("被删除的数据："+list.get(i).getName());
			list.remove(i);
		}*/
		/* 结果： 并没有全部删除，仍剩下一个数据 李四。
		 * 		是因为在循环删除时list集合大小变化了，而且数据的下标也变化了:
		 * 		张三的下标是0，当删除后李四的下标变成了0；王二的变成了1 ，故删除了王二，留下了李四。这是有错误的。
		 	3
			被删除的数据：张三
			被删除的数据：王二
			1
		 */
		
		/*----------1.1.2 只删除一个对象，然后使用break停止循环，则不报错，且数据正确------------*/
		
		/*for(int i = 0;i<list.size();i++){
			if(list.get(i).getName().equals("李四")){
				System.out.println("被删除的数据："+list.get(i).getName());
				list.remove(i);
				break;
			}
		}*/
		
		/*----------1.2.1 降序循环 :循环删除多个数据，不报错，数据准确------------*/
		/*for(int i = list.size()-1;i>-1;i--){
			System.out.println("list的实时大小："+list.size());
			System.out.println("被删除的数据："+list.get(i).getName());
			list.remove(i);
		}
		*/
		
		/*----------1.2.2 降序循环 :删除一个数据，break。不报错，数据准确------------*/
		for(int i = list.size()-1;i>-1;i--){
			if(list.get(i).getName().equals("李四")){
				System.out.println("被删除的数据："+list.get(i).getName());
				list.remove(i);
				break;
			}
		}
		
		
		
		System.err.println("操作后list集合大小："+list.size());
	}
	/**
	 * 测试使用Iterator循环删除和修改List保存对象
	 * 	1 使用list移除其内的对象：
	 * 		1.1 移除多个 :报错java.util.ConcurrentModificationException
	 * 		1.2 移除一个 :不报错，数据正常
	 * 	2 使用Iterator移除list中的对象： 
	 * 		2.1 移除多个 :正确不报错
	 * 		2.2 移除一个:正确不报错
	 * 	3 修改内容不报错: 正确不报错
	 * 
	 */
	public static void test3(){
		List<Person> list = new ArrayList();
		Person p1 = new Person("张三", 1);
		Person p2 = new Person("李四", 2);
		Person p3 = new Person("王二", 3);
		
		list.add(p1);
		list.add(p2);
		list.add(p3);
		System.err.println("操作前list集合大小："+list.size());
		
		/*----------1.1 使用list移除其内多个对象： java.util.ConcurrentModificationException------------*/
		/*Iterator<Person> iterator = list.iterator();
		int i = 0;
		while(iterator.hasNext()){
			Person person = iterator.next();
			list.remove(person);
		}*/
		
		
		/*----------1.2 使用list移除其内一个对象：不报错，数据正常------------*/
		Iterator<Person> iterator = list.iterator();
		while(iterator.hasNext()){
			Person person = iterator.next();
			if(person.getName().equals("李四")){
				list.remove(person);
				break;
			}
		}
		
		
		/*----------2.1 使用iterator移除其内多个对象：不报错，数据正常 ------------*/
		/*Iterator<Person> iterator = list.iterator();
		while(iterator.hasNext()){
			System.out.println("list实施大小："+list.size());
			Person person = iterator.next();
			iterator.remove();
		}*/
		
		/*----------2.2 使用iterator移除其内一个对象：不报错，数据正常 ------------*/
	/*	Iterator<Person> iterator = list.iterator();
		while(iterator.hasNext()){
			Person person = iterator.next();
			if(person.getName().equals("李四")){
				iterator.remove();
				break;
			}
		}*/
		
		
		/*----------3 使用iterator循环是时，修改数据: 正确不报错------------*/
		/*Iterator<Person> iterator = list.iterator();
		while(iterator.hasNext()){
			Person person = iterator.next();
			person.setName("lili");
		}
		
		Iterator<Person> iterator2 = list.iterator();
		while(iterator2.hasNext()){
			Person person2 = iterator2.next();
			System.out.println(person2.getName());
		}*/
		
		System.err.println("操作后list集合大小："+list.size());
	}
}
class Person{
	private String name;
	private Integer id;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public Person(String name, Integer id) {
		super();
		this.name = name;
		this.id = id;
	}
}