Java Day9 集合

1.


2.List（有序集合）
是一个接口，只能用List list = new ArrayList的形式 父类接口创建子类对象
List中的对象可以是重复的，Set的对象不可以重复
使用集合的步骤：
1.创建集合对象
2.创建元素对象
3.将元素对象添加到集合对象中
4.遍历集合
list.add(obj) 向集合添加一个对象
list.get(index) 根据索引值获取集合中的对象
list.size() 获取集合长度

package cn.itcast.demo1;

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

/*
    使用集合的步骤：
        1.创建集合对象
        2.创建元素对象
        3.将元素对象添加到集合对象中
        4.遍历集合
 */
public class Test {
    public static void main(String[] args) {
        //需求：在List集合中添加3个学生对象然后遍历
        List list = new ArrayList();
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",30);
        Student s3 = new Student("王五",40);
        Student s4 = new Student("王五",40);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        //直接打印集合
        System.out.println(list);
        //获取索引为2的元素
        //get方法是通过索引来获得对象的
        Object a = list.get(2);  //获取的是一个对象，所以左边要用Object类先创建一个对象
        System.out.println(a);


        for (int i = 0; i < list.size();i++) {
            //Object obj = list.get(i);
            System.out.println(list.get(i));
        }
    }
}

3.增强for循环和迭代器

package cn.itcast.demo2;

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

/*
       增强for格式：
            for(元素的数据类型 变量名 ： 要遍历的集合或数组对象) {
                循环体
            }
       增强for依赖于迭代器
       快捷方式 ：iter
       快捷方式 ：iter
       快捷方式 ：iter
 */
public class Test {
    public static void main(String[] args) {
        //通过增强for循环遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add(10);
        list.add(10);    //表示元素内容可以重复
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        //遍历
        for (Object obj : list ) {
            //obj是集合中的元素，其本身应该是Integer类型的数据
            //可以强制转换类型来输出Integer形式的数据
            //Integer li = (Integer)obj;
            //System.out.println(li);
            System.out.println(obj);
        }
    }
}

4.迭代器实现对集合的遍历
列表迭代器可以在遍历的同时添加、修改元素

迭代器常用方法：
    1.E next();                 返回迭代的下一个元素对象
    2.bollean  haNext();        如果仍有元素可以迭代，则返回true
    
迭代器使用步骤：
    1.根据集合对象获取对应的迭代器对象
    2.判断迭代器是否有对象
    3.如果有就获取对象
    
总结：
    1.普通的迭代器在遍历时不能添加、删除元素，否则会报，并发修改异常
    2.列表迭代器在遍历时可以修改集合中的元素，的那必须使用列表迭代器中的方法

package cn.itcast.demo3;

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

/*
    迭代器常用方法：
        1.E next();                 返回迭代的下一个元素对象
        2.bollean  haNext();        如果仍有元素可以迭代，则返回true
    迭代器使用步骤：
        1.根据集合对象获取对应的迭代器对象
        2.判断迭代器是否有元素
        3.如果有就获取对象

    总结：
        1.普通的迭代器在遍历时不能添加、删除元素，否则会报，并发修改异常
        2.列表迭代器在遍历时可以修改集合中的元素，的那必须使用列表迭代器中的方法
 */
public class Test {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);

        //遍历集合
        //1.根据集合对象获取对应的迭代器对象
        //Iterator it = list.iterator();
        //2.判断迭代器是否有对象
        //while (it.hasNext()) {
        //3.如果有就获取对象
            //Integer s = (Integer)it.next();
            //System.out.println(s);
            //System.out.println(it.next());
            //System.out.println(it.hasNext());
        //}

        //需求：判断集合中如果有字符串“b”，就在后米面加一个""java
        Iterator it = list.iterator();
        //2.判断迭代器是否有对象
        while (it.hasNext()) {
        //3.如果有就获取对象
            Integer s = (Integer)it.next();
            if ("b".equals(s)) {  //这种写法是为了规避空指针异常的问题


                list.add("java");  //这样写不可以，会触发并行错误，因为不能对集合一边遍历，一边修改
            }
            System.out.println(s);
        }
    }
}

package cn.itcast.demo3;

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

public class Test1 {
    public static void main(String[] args) {
        //需求：测试列表迭代器
        //需求：通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //需求：判断集合中如果有字符串“b”，就在后米面加一个""java
        //1.根据集合对象获取对应的列表迭代器对象
        ListIterator lit = list.listIterator();
        //2.判断迭代器是否有对象
        while (lit.hasNext()) {
            //3.如果有就获取对象
            String s1 = (String)lit.next();
            if ("b".equals(s1)) {
                //list.add("java");   这样写是不可以的，必须调用列表迭代器
                lit.add("java");
            }
            System.out.println(s1);
        }
        System.out.println(list);
    }
}

5.泛型
只存储指定类型的元素
List list = new ArrayList<>();

package cn.itcast.demo4;

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

//泛型好处：类型安全（写其它类型的会直接报错）、避免了类型转换
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //list.add(10);   //会直接报错

        //遍历
        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }
    }
}

6.Collections工具类

package cn.itcast.demo5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*
    Collections概述:
        针对集合进行操作的工具类。
    成员方法
        max(Collection<T>);         返回集合的最大元素
        sort(List<T>):              根据元素的自然顺序，将指定列表按升序排序
        reverse(List<T);            反转List築合元素
        shuffle(List<D);            使用默认的随机源随机置换指定的列表

 */
public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(40);
        list.add(50);
        list.add(20);
        list.add(40);
        for (Integer i : list) {
            System.out.println(i);
        }

        Integer max = Collections.max(list);
        System.out.println(max);

        Collections.sort(list);
        System.out.println(list);

        Collections.reverse(list);
        System.out.println(list);

        Collections.shuffle(list);
        System.out.println(list);
    }
}

7.Set集合
不可重复 子类对象为HashSet

package cn.itcast.demo6;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

package cn.itcast.demo6;

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
    set集合的特点：无序（元素存取顺序不一致）、唯一性
    Set集合保证元素的唯一性依赖: equals() 和 hashCode()两个方法
 */
public class Test {
    public static void main(String[] args) {
        //需求：往set集合里添加5个学生对象
        //1.创建Set集合对象
        Set<Student> set = new HashSet<>();//注意记得用泛型  里面的类型用Student

        //2.创建元素对象
        Student s1 = new Student("张三",10);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("李四",20);
        Student s4 = new Student("王五",30);

        //3.向集合添加元素对象
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);

        //4.集合遍历
        /*
            为什么Set集合没有“去重”?
                因为Set集合保证元素的唯一性依赖: equals() 和 hashCode()两个方法
                因为没有在Student类中重写这两个方法，默认调用的是0bject类中的这两个方法
                而0bject类中的equals()方法默认比较的是地址值是否相同

         */
        System.out.println(set);
        //通过迭代器遍历
        Iterator<Student> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //通过增强for循环遍历
        for (Student stu : set) {
            System.out.println(stu);
        }
    }
}

8.Map集合
双列集合，元素由键值对构成

package cn.itcast.demo7;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
    遍历步骤:
        1.获取所有键的集合，                 keySet()
        2.遍历所有的键，获取到每一个键.        迭代器，增强for.
        3.根据鍵，获取指定的值。              get(); .

 */
public class Test {
    public static void main(String[] args) {
        //需求：向Map集合中添加三个元素，并遍历打印
        //1.创建集合对象
        Map<Integer,Student> map = new HashMap();

        //2.创建元素对象
        Student s1 = new Student("张三",10);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",30);

        //3.将元素对象添加到set集合
        map.put(1,s1);
        map.put(3,s2);
        map.put(2,s3);
        System.out.println(map);
        //根据键，获取值
        System.out.println(map.get(2));

        //4.遍历集合
     /*  //4.1.获取所有键的集合，                 keySet()
        Set<Integer> keys = map.keySet();
        //4.2.遍历所有的键，获取到每一个键.        迭代器，增强for.
        //获取迭代器对象
        Iterator<Integer> iterator = keys.iterator();
        //判断是否还有元素(这里指的是键值)
        while (iterator.hasNext()) {
            //先获取key
            //System.out.println(map.get(iterator.next()));
            Integer key = iterator.next();
            //4.3.根据鍵，获取指定的值。              get();
            //用get方法通过key获取value值
            Student value = map.get(key);
            //输出value
            System.out.println(value);
        }*/


        //增强for实现
        //获取所有的键
        Set<Integer> it = map.keySet();
        for (Integer key : it) {
            //key就是双列集合的每一个键
            //System.out.println(map.get(key));
            Student value = map.get(key);
            System.out.println(value);

        }

    }
}

9.集合实例–斗地主

package cn.itcast.demo8;

import java.util.*;

public class SendPokerTest {
    public static void main(String[] args) {
        //1.买牌
        //1.1 定义一个双列集合，键：牌的编号；值：具体的牌：   规则：编号越小，牌越小
        Map<Integer, String> pokers = new HashMap<>();
        //1.2 定义一个单列集合,存储牌的编号
        List<Integer> list = new ArrayList();
        //1.3 具体的买牌动作
        //普通牌，52
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] colors = {"♦","♣","♥","♠"};
        int num = 0;
        //通过循环嵌套 造普通牌
        for (String number : numbers) {
            for (String color : colors) {
                String poker = color + number;
                //System.out.println(poker);
                //将牌的编号、具体的牌放到双列集合中
                pokers.put(num,poker);
                //将牌的编号放到单列集合中
                list.add(num);
                //每添加一张牌，编号自增1
                num++;
            }
        }
        //大小王
        pokers.put(num,"大王");
        list.add(num++);
        pokers.put(num,"小王");
        list.add(num);

        //打印牌
        System.out.println(pokers);
        System.out.println(list);
        /*直接用两个for循环的方法尝试
        for (int i =0; i < 13; i++) {
            for (int j = 0; j < 4; j++) {
                colors[i].concat(num[j]);
            }
        }*/



        //2.洗牌
        Collections.shuffle(list);
        System.out.println("牌的编号" + list);

        //3.发牌
        //3.1 新建3个集合和一个底牌集合
        List<Integer> A = new ArrayList<>();
        List<Integer> B = new ArrayList<>();
        List<Integer> C = new ArrayList<>();
        List<Integer> D = new ArrayList<>();
        //3.2 按照模进行分类
        for (int i = 0; i < list.size(); i++) {
            Integer integer = list.get(i);
            if (i >= list.size() - 3) {
                D.add(integer);
            } else if (i % 3 == 0) {
                A.add(integer);
            } else if (i % 3 == 1) {
                B.add(integer);
            } else if (i % 3 == 2) {
                C.add(integer);
            }
        }
        //3.3 遍历4个集合
        System.out.println(A);
        System.out.println(B);
        System.out.println(C);
        System.out.println(D);


        System.out.println(printPoker(A,pokers));
        System.out.println(printPoker(B,pokers));
        System.out.println(printPoker(C,pokers));
        System.out.println(printPoker(D,pokers));
    }

    //4.看牌
    //4.1 创建一个看牌方法
    public static String printPoker(List<Integer> num, Map<Integer,String> pokers) {
        Collections.sort(num);
        StringBuilder sb = new StringBuilder();
        for (Integer nums : num) {
            String poker = pokers.get(nums);
            sb.append(poker + " ");
        }
        //将拼接结果返回
        String str = sb.toString();
        return str.trim();

    }
}