package studyweek5容器;

import java.util.HashMap;
import java.util.Map;

public class HashMapTest {
    public static void main(String[] args) {
        //实例化HashMap容器
        //put方法的特点，遇到相同Key的元素，会用新的Value把旧的Value替换掉，并且把旧的Value返回
        Map<String,String> map=new HashMap();
        String value=map.put("a","A");
        System.out.println(value);//原来Map中没有Key，所以返回空

        String value2=map.put("a","B");
        System.out.println(value2);//B会把

    }
}

2.2 get方法获取元素

方法一：通过Key获取Value值

        //1、通过Key获取Value值
        //如果Key已知，使用get方法十分方便
        String value3=map.get("a");
        System.out.println(value3);

方法二：通过KeySet方法获取元素

        //2、通过KeySet方法获取容器中所有的元素，可以使用KeySet方法和get方法一并完成。
        map.put("b","B");
        map.put("c","C");
        map.put("d","D");
        map.put("e","E");
        Set<String> keys= map.keySet();//不用实例化对象
        map.keySet();
        for(String key:keys){
            String v1=map.get(key);
            System.out.println(key+"——"+v1);
        }

方式三：通过entrySet方法获取Map.Entry类型获取元素

//3、通过entrySet方法获取Map.Entry类型获取元素（用Map接口的内部接口Entry）
        //把一堆K——V对拆散了放在Set当中
        Set<Map.Entry<String,String>> entrySet=map.entrySet();
        for(Map.Entry<String,String> entry:entrySet){
            String key=entry.getKey();
            String v=entry.getValue();
            System.out.println(key+"---"+v);
        }

2.3 并集操作

     //并集操作
        Map<String,String> map2=new HashMap<>();
        map2.put("f","F");
        map2.put("c","cc");//并集操作时，如果两个map有相同的Key，该Map里的K——V会被复制过来的Map的K——V覆盖。
        map2.putAll(map);
        Set<String> keys2=map2.keySet();
        for(String key:keys2){
            String v2=map2.get(key);
            System.out.println(key+"——"+v2);
        }

2.4 删除元素

        //删除元素
        String v=map.remove("e");
        System.out.println(v);//返回被删除的Value值
        Set<String> keys3=map.keySet();
        for(String key:keys3){
            System.out.println(key+"---"+map.get(key));
        }

2.5 判断key和value是否存在

        //判断key和value是否存在
        System.out.println(map.containsKey("a"));//判断key是否存在
        System.out.println(map.containsValue("BBB"));//判断value是否存在

3、TreeMap

TreeMap和HashMap同样实现了Map接口，所以，对于API的用法来说是没有区别的。HashMap效率高于TreeMap；TreeMap是可以对键进行排序的一种容器，在需要对键排序时可选用TreeMap。TreeMap底层是基于红黑树实现的。

在使用TreeMap时需要给定排序规则：

元素自身实现比较规则

通过比较器实现比较规则

3.1 元素自身实现比较规则

//在HashSetUser中重写compareTo方法
@Override
    public int compareTo(HashSetUsers o) {
        if(this.userage>o.getUserage()){ //由大到小
            return 1;
        }
        if(this.userage==o.userage){
            return this.username.compareTo(o.getUsername());
        }
        return -1;
    }

package studyweek5容器;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapTest {
    public static void main(String[] args) {
        //实例化TreeMap
        Map<HashSetUsers,String> map=new TreeMap<>();
        HashSetUsers u1=new HashSetUsers("张三",18);
        HashSetUsers u2=new HashSetUsers("李四",20);
        HashSetUsers u3=new HashSetUsers("王五",18);
        map.put(u1,"张三");
        map.put(u2,"李四");
        map.put(u3,"王五");
        Set<HashSetUsers> keys=map.keySet();
        for(HashSetUsers key:keys){
            System.out.println(key+"-------"+map.get(key));
        }

    }
}

3.2 通过比较器实现比较规则

package studyweek5容器;

import java.util.Objects;

public class Student {
    private String name;
    private int 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);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    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;
    }
}

      Map<Student,String> treeMap=new TreeMap<>(new StudentComparator());
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",20);
        Student s3=new Student("王五",18);
        treeMap.put(s1,"张三");
        treeMap.put(s2,"李四");
        treeMap.put(s3,"王五");
        Set<Student> keys1=treeMap.keySet();
        for(Student key:keys1){
            System.out.println(key+"-------"+treeMap.get(key));
        }

4、Iterator迭代器

4.1 Iterator 迭代器接口介绍

Collection接口继承了Iterable接口，在该接口中包含一个名为iterator的抽象方法，所有实现了Collection接口的容器类对该方法做了具体实现。iterator方法会返回一个Iterator接口类型的迭代器对象，在该对象中包含了三个方法用于实现对单例容器的迭代处理。Iterator对象的工作原理：

Iterator接口定义了如下方法：

booleanhasNext();//判断游标当前位置是否有元素，如果有返回true，否则返回false；

Objectnext();//获取当前游标所在位置的元素，并将游标移动到下一个位置；

voidremove();//删除游标当前位置的元素，在执行完next后该操作只能执行一次；

4.2 使用Iterator迭代List接口类型容器

package studyweek5容器;

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

public class IteratorListTest {
    public static void main(String[] args) {
        //实例化容器
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        //获取元素（使用迭代器获取）
        //获取迭代器对象
        Iterator<String> iterator=list.iterator();
        /*boolean flag=iterator.hasNext();
        if(flag){
            String value=iterator.next();
            System.out.println(value);
        }*/  //iterator不具备循环条件，因此以上代码只能获取一个元素

        //方式一:在迭代器中，通过while循环获取元素
        while(iterator.hasNext()){
            String value=iterator.next();
            System.out.println(value);
        }
        //方式一:在迭代器中，通过for循环获取元素
        for(Iterator<String> it=list.iterator();it.hasNext();){
            String value=it.next();
            System.out.println(value);
        }
    }

4.3 使用Iterator迭代Set接口类型容器

package studyweek5容器;

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

public class IteratorSetTest {
    public static void main(String[] args) {
        Set<String> set=new HashSet<>();
        set.add("a");
        set.add("b");
        set.add("c");
        //获取迭代器对象
        //通过while循环
        Iterator<String> iterator =set.iterator();
        while(iterator.hasNext()){
            String value=iterator.next();
            System.out.println(value);
        }
        //通过for循环
        for(Iterator<String> it=set.iterator();it.hasNext();){
            String value=it.next();
            System.out.println(value);
        }
    }
}

4.3 在迭代器中删除元素

package studyweek5容器;

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

public class IteratorRemoveTest {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //如果想在for循环里删除元素一定要加上判断
        /*for(int i=0;i< list.size();i++){
            if("c".equals(list.get(i))){
                list.remove(i);
            }
            System.out.println(list.get(i));
        }*/
        int flag=-1;
        for (int i=0;i< list.size();i++){
            if("c".equals(list.get(i))){
                flag=i;
            }
            if(flag>-1){
                list.remove(flag);
            }
        }
        for(String str:list){
            System.out.println(str);
        }


        //在迭代器中删除元素
        Iterator<String> iterator=list.iterator();
        while(iterator.hasNext()){
            String value=iterator.next();
            if("c".equals(value)){
                iterator.remove();
            }
        }

        for(Iterator<String> it=list.iterator();it.hasNext();){
            System.out.println(it.next());

        }
    }
}

5、Collections 工具类

5.1 对LIst容器进行排序处理

package studyweek5容器;

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

public class CollectionsSortTest {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("c");
        list.add("d");
        list.add("b");
        list.add("a");

        //通过Collection工具类的中的sort方法完成排序
        Collections.sort(list);
        for(String str:list){
            System.out.println(str);
        }
    }
}

5.2 对List类型容器进行随机排序

package studyweek5容器;

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

public class CollectionsSortTest {
    public static void main(String[] args) {
        List<String> list2=new ArrayList<>();
        list2.add("a");
        list2.add("b");
        list2.add("c");
        list2.add("d");
        //通过Collection工具类的中的shuffle方法完成乱序处理
        Collections.shuffle(list2);
        for(String str:list2){
            System.out.println(str);
        }
        System.out.println("---------------------");
    }
}