JAVA的集合归类

集合可分为三种：List，Set，Map。
一.List
List是有序存储的。
List的创建:
List<类型> list=new ArrayList<>()
list.add(a) 将a存入list集合中。
list.remove(i)将集合中索引i的数据删除。
List有3种遍历方法：

package com.zhongruan.example;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo1 {
    public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        a.add("a");
        a.add("s");
        a.add("d");
        a.add("c");
        a.add("r");
        /*  第一种方法  遍历
        for (String s : a) {
            System.out.println(s);
        }
         */
        /*   第二种方法 遍历
        for(int i=0;i<a.size();i++){
            System.out.println(a.get(i));
        }
         */
        //第三种 遍历加添加
        ListIterator<String> listIterator = a.listIterator();
        while (listIterator.hasNext()){
            String s1 = listIterator.next();
            if("c".equals(s1)){
                listIterator.add("ssss");
            }
        }
        for (String s : a) {
            System.out.println(s);
        }
    }
}	

list案例：

package com.zhongruan.example;
import java.util.ArrayList;
import java.util.List;
public class test1 {
    /*
    1.自定义MyList类，实现存取元素的功能。
- 定义add方法，可以保存元素，添加MyList尾部。
- 定义remove方法，可以获取到最后添加的元素，并从MyList中移除该元素。
- 定义show方法，可以展示MyList中的元素。
     */

    public static void main(String[] args) {
        MyList mylist=new MyList();
        for(int i=0;i<3;i++){
            mylist.add(i);
        }
        System.out.println("添加元素后：");
        mylist.show();
        Integer remove= mylist.remove();
        System.out.println("获取元素：");
        System.out.println(remove);

        System.out.println("获取元素后：");
        mylist.show();
    }

    static class MyList{
        List<Integer> list = new ArrayList<>();

       public void add(int i) {
            list.add(i);
       }

        public void show() {
            System.out.println(list);
        }

        public Integer remove() {
            Integer remove = list.remove(list.size() - 1);
           return remove;
        }
    }
}

二.Set
set是无序存储的，不允许有重复元素。
HashSet能自动删除重复的元素。
HashSet（不按输入顺序输出）。
LinkedHashSet（可按输入顺序输出）。
HashSet存储类时，要在类中添加equals（）函数与hascode（）函数。
TreeSet能使元素排序，也可保留重复的元素。
TreeSet的三种方法：
1.comparable接口用于类。（外部类）
2.comparator接口用于main函数的类中。（直接内部类）
3直接使用new Comparator<>()函数。（匿名内部类）
HashSet的案例：

package com.zhognruan.example;
import java.util.HashSet;
import java.util.Random;
public class Demo1 {
    public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        Random r = new Random();
        while(set.size()<10){
            set.add(r.nextInt(20)+1);
        }
        for (Integer s : set) {
            System.out.println(s);
        }

    }
}

TreeSet案例：
Person类的创建

package com.zhognruan.example;
import java.util.Objects;
public class Person /*implements Comparable<Person>*/{
    private String name;
    private int age;

    public Person() {

    }

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

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

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

    /*@Override
    public int compareTo(Person o) {
        return o.getName().equals(this.getName()) ? 0 : this.getAge() - o.getAge();
    }*/
}

package com.zhognruan.example;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class Demo3 {
    public static void main(String[] args) {
//        Set<Person> set = new TreeSet<>(new Demo());
        Set<Person> set=new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getName().equals(o2.getName())?0:o1.getAge()-o2.getAge();
            }
        });
        set.add(new Person("shaj", 20));
        set.add(new Person("asdad", 567));
        set.add(new Person("asdsa", 23));
        set.add(new Person("shasdsa", 55));
        set.add(new Person("zdd", 30));
        for (Person person : set) {
            System.out.println(person);
        }

    }
}
/*class Demo implements Comparator<Person> {

    @Override
    public int compare(Person o1, Person o2) {
        return o1.getName().equals(o2.getName())?0:o1.getAge()-o2.getAge();
    }
}*/

三.Map
Collections操作集合工具类。
常见的几个小方法：
A:public static void sort(List list)
B:public static int binarySearch(List<?> list,T key)
C:public static T max(Collection<?> coll)
D:public static void reverse(List<?> list)
E:public static void shuffle(List<?> list)
其中，Collections.shuffle(list);是打乱list集合中的元素，而sort是给集合中的元素排序。
Map主要是以键值对的形式存放到集合中，Map集合的键是唯一的，值是可重复的，属于双列集合，一般都是根据键来找值。
Map集合的遍历
方式A:键找值
a:获取所有键的集合
b:遍历键的集合,得到每一个键
Map案例：

package com.zhongruan.example;
import java.util.*;
public class Demo3 {
    /*
        需求
        按照斗地主的规则，完成洗牌发牌的动作。
        具体规则：
        1. 组装54张扑克牌将
        2.  54张牌顺序打乱
        3.  玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌
        4.  查看三人各自手中的牌（按照牌的大小排序）、底牌
     */
    public static void main(String[] args) {
        Map<Integer, String> poker = new HashMap<>();
        int count = 1;
        poker.put(count++, "大王");
        poker.put(count++, "小王");
        List<String> color = new ArrayList<>();
        List<String> num = new ArrayList<>();
        Collections.addAll(color, "红桃", "黑桃", "梅花", "方块");
        Collections.addAll(num, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        for (String n : num) {
            for (String c : color) {
                String s = c + n;
                poker.put(count++, s);
            }
        }
        List<Integer> list = new ArrayList<>();
        Set<Integer> set = poker.keySet();
        list.addAll(set);
        List<Integer> dipai = new ArrayList<>();
        List<Integer> p1 = new ArrayList<>();
        List<Integer> p2 = new ArrayList<>();
        List<Integer> p3 = new ArrayList<>();
        Collections.shuffle(list);
        for (int i = 0; i < list.size(); i++) {
            if (i >= 51) {
                dipai.add(list.get(i));
            } else if (i % 3 == 0) {
                p1.add(list.get(i));
            } else if (i % 3 == 1) {
                p2.add(list.get(i));
            } else if (i % 3 == 2) {
                p3.add(list.get(i));
            }
        }
        Collections.sort(p1);
        Collections.sort(p2);
        Collections.sort(p3);
        List<String> dipai1 = new ArrayList<>();
        List<String> player1 = new ArrayList<>();
        List<String> player2 = new ArrayList<>();
        List<String> player3 = new ArrayList<>();
        for (Integer i1 : dipai) {
            dipai1.add(poker.get(i1));
        }
        for (Integer i2 : p1) {
            player1.add(poker.get(i2));
        }
        for (Integer i3 : p2) {
            player2.add(poker.get(i3));
        }
        for (Integer i4 : p3) {
            player3.add(poker.get(i4));
        }
        System.out.println("底牌：" + dipai1);
        System.out.println("玩家1：" + player1);
        System.out.println("玩家2：" + player2);
        System.out.println("玩家3：" + player3);
    }
}