java集合框架（一）——Collection补充知识

 

目录

一、集合的并发修改异常

二、可变参数

三、Collections

四、综合案例：斗地主

---

一、集合的并发修改异常

1.  使用迭代器遍历集合时，又同时删除集合中的数据，程序就会出现并发修改异常的错误

2.  由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误（没有能够拿到迭代器对象）；

        增强 for 循环是迭代器的语法糖：增强 for 循环背后使用的是迭代器，它自动调用迭代器的next 和 hasNext 方法来遍历集合；

        简化写法：增强 for 循环提供了一种更简洁的语法，使得遍历集合变得简单直观，无需显式地使用迭代器对象；

        删除元素的问题：在使用迭代器遍历时，可以直接调用迭代器的 remove 方法来删除当前遍历到的元素，这是安全的，因为迭代器会处理内部状态的更新。但是，增强 for 循环并没有提供直接删除元素的方法。

3.  怎么保证遍历集合同时删除数据时不出bug?

1.使用迭代器遍历集合，但用迭代器自己的删除方法删除数据即可。

2.如果能用for循环遍历时:可以倒着遍历并删除;或者从前往后遍历，但删除元素后做 i -- 操作。

	public static void main(String[] args) {
	    List<String> list = new ArrayList<>();
	    list.add("王里里");
	    list.add("小李子");
	    list.add("陈某");
	    list.add("牛万");
	    list.add("欧若拉");
	    list.add("陈传承");
	
	    // 删除里面有李的名字
	    //用迭代器循环
	    Iterator<String> it = list.iterator();
	    while (it.hasNext()) {
	        String name = it.next();
	        if (name.contains("李")) {
	            it.remove();
	        }
	    }
    }

下面是使用for循环遍历集合并删除数据的写法 ：

	for (int i = 0; i < list.size(); i++) {
	    String name = it.next();
	    if (name.contains("李")) {
	        list.remove(name);
	        i--;
	    }
	}

二、可变参数

1. 可变参数：特殊形参，定义在方法、构造器形参列表里，格式是：数据类型…参数名称

2. 可变参数的特点和好处：

   特点：可以不传数据，可以传一个或者多个数据给它，也可以传一个数组给它

   好处：常常用来灵活接受数据

	public static void main(String[] args) {
	    test(); //不传数据
	    test(10); //传一个数据
	    test(10,20,30); //多个数据
	    test(new int[]{10,30,50,90,80});
	}
	
	//tip: 一个形参列表中，只能有一个可变参数 也不可以是两个不一样的数据类型
	//可变参数必须在形参列表的最后面
	public static void test(int...nums){
	    //可变参数在方法内部，本质就是一个数组
	    System.out.println(nums.length);
	    System.out.println(Arrays.toString(nums));
	    System.out.println("--------------------------");
	}

三、Collections

1. Collections 是一个用来操作集合的工具类

2. Collections 是一个静态方法

	public static void main(String[] args) {
	    //1. public static <T> boolean addAll(Collection<? super T> c,T...elements):为集合批量添加数据
	    List<String> names = new ArrayList<>();
	    Collections.addAll(names,"张三","李四","王五","张麻子");
	    System.out.println(names); //[张三, 李四, 王五, 张麻子]
	
	    //2. public static void shuffle(<List<T> list): 打乱List集合中的元素顺序 （每执行一次都会打乱顺序）
	    Collections.shuffle(names);
	    System.out.println(names);
	
	    //3. public static <T> void sort(List<T> list): 对List集合中的元素进行升序排序
	    List<Integer> list = new ArrayList<>();
	    list.add(8);
	    list.add(4);
	    list.add(5);
	    list.add(1);
	    list.add(6);
	    list.add(10);
	    Collections.sort(list);
	    System.out.println(list);
	
	    //4. public static <T> void sort(List<T> list,Comparator<? super T> c): 对List集合中元素，按照比较器对象指定的规则进行排序 
	    //自定义排序有两种写法，具体之前有写，这里用比较器对象指定规则
	    List<Student> students = new ArrayList<>();
	    students.add(new Student("小红",25,175.2));
	    students.add(new Student("小刘",22,165.9));
	    students.add(new Student("小蔡",30,166.3));
	    students.add(new Student("小英",27,180.2));
	    
	    Collections.sort(students, new Comparator<Student>() {
	        @Override
	        public int compare(Student o1, Student o2) {
	            return Double.compare(o1.getHeight(),o2.getHeight());
	        }
	    });
	   
	   //Collections.sort(students, (o1, o2) ->  Double.compare(o1.getHeight(),o2.getHeight()));
	
	    System.out.println(students);
	}

四、综合案例：斗地主

 先创建一个Card类，constructor、get、set方法，重写toString方法

 private String number;

 private String color;

 private int size;

	public class Room {
	    //要有一副牌
	    List<Card> allCard = new ArrayList<>();
	
	    public Room() {
	        //在开始创建房间时就加载，做出 54 张牌，放入集合allCard里面
	        //点数
	        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
	        //花色
	        String[] color = {"♣","♠","♥","♦"};
	        //大小
	        int size = 0;
	
	        //遍历点数，再遍历花色，组织牌
	        for (String number : numbers) {
	            size++;
	            for (String s : color) {
	                //得到一张牌
	                Card c = new Card(number,s,size);
	                allCard.add(c); //存入牌
	            }
	        }
	
            //大小王
	        Card c1 = new Card("","😎",++size);
	        Card c2 = new Card("","😉",++size);
	
	        Collections.addAll(allCard,c1,c2);
	        System.out.println("牌整理好： " + allCard);
	
	    }
	
	    //游戏启动
	    public void start() {
	        //洗牌
	        Collections.shuffle(allCard);
	        System.out.println("洗牌后： " + allCard);
	
	        //发牌:三个玩家
	        List<Card> l1 = new ArrayList<>();
	        List<Card> l2 = new ArrayList<>();
	        List<Card> l3 = new ArrayList<>();
	
	        for (int i = 0; i < allCard.size() - 3; i++) {
	            Card c = allCard.get(i);
	            if (i % 3 == 0) {
	                l1.add(c);
	            } else if (i % 3 == 1) {
	                l2.add(c);
	            }else if (i % 3 == 2){
	                l3.add(c);
	            }
	        }
	
	        //对三个玩家的牌进行排序
	        sortCard(l1);
	        sortCard(l2);
	        sortCard(l3);
	
	        //看牌
	        System.out.println("l1；" + l1);
	        System.out.println("l2；" + l2);
	        System.out.println("l3；" + l3);
	
	        List<Card> lastCard = allCard.subList(allCard.size() - 3,allCard.size());
	        System.out.println("底牌：" + lastCard);
	        l2.addAll(lastCard);
	        System.out.println("l2抢到地主后： " + l2);
	        sortCard(l2);
	        System.out.println("l2重新排序: " + l2);
	    }
	
	    private void sortCard(List<Card> cards) {
	        cards.sort(new Comparator<Card>() {
	            @Override
	            public int compare(Card o1, Card o2) {
	                return o1.getSize() - o2.getSize();
	            }
	        });
	    }
	}