package Set.TreeSet;

import java.util.*;

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

  public Student() {
  }

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

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return this.age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getGender() {
    return this.gender;
  }

  public void setGender(String gender) {
    this.gender = gender;
  }

  public Student name(String name) {
    setName(name);
    return this;
  }

  public Student age(int age) {
    setAge(age);
    return this;
  }

  public Student gender(String gender) {
    setGender(gender);
    return this;
  }

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

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

  @Override
  public String toString() {
    return "{" +
        " name='" + getName() + "'" +
        ", age='" + getAge() + "'" +
        ", gender='" + getGender() + "'" +
        "}";
  }
}

class ComparatorImpl implements Comparator<Student> {

  @Override
  public int compare(Student o1, Student o2) {
    return o1.getAge() - o2.getAge() == 0 ? o1.getName().compareTo(o2.getName()) : o1.getAge() - o2.getAge();
  }
}

public class TreeSetDemo3 {
  public static void main(String[] args) {

    TreeSet<Student> treeset = new TreeSet<>(new ComparatorImpl());

    Student[] students = new Student[] {
        new Student("张三", 18, "男"),
        new Student("李四", 20, "男"),
        new Student("王五", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女")
    };

    initTreeSet(treeset, students);

    traverseTreeSet(treeset);

  }

  private static void traverseTreeSet(TreeSet<Student> treeset) {
    for (Student student : treeset) {
      System.out.println(student + "\n");
    }
  }

  private static void initTreeSet(TreeSet<Student> treeset, Student[] students) {
    for (Student student : students) {
      treeset.add(student);
    }
  }

}

运行结果

{ name='孙七', age='18', gender='女'}

{ name='张三', age='18', gender='男'}

{ name='王五', age='18', gender='女'}

{ name='李四', age='20', gender='男'}

{ name='赵六', age='20', gender='男'}

package Set.TreeSet;

import java.util.*;

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

  public Student() {
  }

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

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return this.age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getGender() {
    return this.gender;
  }

  public void setGender(String gender) {
    this.gender = gender;
  }

  public Student name(String name) {
    setName(name);
    return this;
  }

  public Student age(int age) {
    setAge(age);
    return this;
  }

  public Student gender(String gender) {
    setGender(gender);
    return this;
  }

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

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

  @Override
  public String toString() {
    return "{" +
        " name='" + getName() + "'" +
        ", age='" + getAge() + "'" +
        ", gender='" + getGender() + "'" +
        "}";
  }
}

public class TreeSetDemo4 {
  public static void main(String[] args) {

    TreeSet<Student> treeset = new TreeSet<>(new Comparator<Student>() {

      @Override
      public int compare(Student o1, Student o2) {
        return o1.getAge() - o2.getAge() == 0 ? o1.getName().compareTo(o2.getName()) : o1.getAge() - o2.getAge();

      }

    });

    Student[] students = new Student[] {
        new Student("张三", 18, "男"),
        new Student("李四", 20, "男"),
        new Student("王五", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女")
    };

    initTreeSet(treeset, students);

    traverseTreeSet(treeset);

  }

  private static void traverseTreeSet(TreeSet<Student> treeset) {
    for (Student student : treeset) {
      System.out.println(student + "\n");
    }
  }

  private static void initTreeSet(TreeSet<Student> treeset, Student[] students) {
    for (Student student : students) {
      treeset.add(student);
    }
  }

}

运行结果

{ name='孙七', age='18', gender='女'}

{ name='张三', age='18', gender='男'}

{ name='王五', age='18', gender='女'}

{ name='李四', age='20', gender='男'}

{ name='赵六', age='20', gender='男'}

package Collections.shuffle;

import java.util.*;

public class shufleDemo {
  public static void main(String[] args) {
    Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    Collections.shuffle(Arrays.asList(numbers));
    System.out.println(Arrays.toString(numbers));
  }
}

运行结果
[2, 7, 8, 6, 4, 1, 5, 3, 9]

package Collections.Sort;

import java.util.*;

public class SortDemo1 {
  public static void main(String[] args) {
    Integer[] integers = new Integer[] { 9, 2, 8, 1, 5, 1 };

    List<Integer> list = new ArrayList<>();

    initList(list, integers);

    Collections.sort(list);

    System.out.println(list);

  }

  private static void initList(List<Integer> list, Integer[] integers) {
    for (Integer integer : integers) {
      list.add(integer);
    }
  }
}

运行结果

[1, 1, 2, 5, 8, 9]

package Collections.Sort;

import java.util.*;

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

  public Student() {
  }

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

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return this.age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getGender() {
    return this.gender;
  }

  public void setGender(String gender) {
    this.gender = gender;
  }

  public Student name(String name) {
    setName(name);
    return this;
  }

  public Student age(int age) {
    setAge(age);
    return this;
  }

  public Student gender(String gender) {
    setGender(gender);
    return this;
  }

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

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

  @Override
  public String toString() {
    return "{" +
        " name='" + getName() + "'" +
        ", age='" + getAge() + "'" +
        ", gender='" + getGender() + "'" +
        "}";
  }
}

public class SortDemo2 {
  public static void main(String[] args) {
    List<Student> list = new ArrayList<>();
    Student[] students = new Student[] {
        new Student("张三", 18, "男"),
        new Student("李四", 20, "男"),
        new Student("王五", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女")
    };

    initList(list, students);

    Collections.sort(list,
        Comparator.comparing(Student::getAge).thenComparing(Student::getName).thenComparing(Student::getGender));

    traverseList(list);

  }

  private static void traverseList(List<Student> list) {
    Iterator<Student> iterator = list.iterator();
    while (iterator.hasNext()) {
      Student student = iterator.next();
      System.out.println(student + "\n");
    }
  }

  private static void initList(List<Student> list, Student[] students) {
    for (Student student : students) {
      list.add(student);
    }
  }
}

运行结果
{ name='孙七', age='18', gender='女'}

{ name='孙七', age='18', gender='女'}

{ name='张三', age='18', gender='男'}

{ name='王五', age='18', gender='女'}

{ name='李四', age='20', gender='男'}

{ name='赵六', age='20', gender='男'}

{ name='赵六', age='20', gender='男'}

package Collections.Sort;

import java.util.*;

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

  public Student() {
  }

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

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return this.age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getGender() {
    return this.gender;
  }

  public void setGender(String gender) {
    this.gender = gender;
  }

  public Student name(String name) {
    setName(name);
    return this;
  }

  public Student age(int age) {
    setAge(age);
    return this;
  }

  public Student gender(String gender) {
    setGender(gender);
    return this;
  }

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

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

  @Override
  public String toString() {
    return "{" +
        " name='" + getName() + "'" +
        ", age='" + getAge() + "'" +
        ", gender='" + getGender() + "'" +
        "}";
  }
}

public class SortDemo3 {
  public static void main(String[] args) {
    List<Student> list = new ArrayList<>();
    Student[] students = new Student[] {
        new Student("张三", 18, "男"),
        new Student("李四", 20, "男"),
        new Student("王五", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女")
    };

    initList(list, students);

    Collections.sort(list, new Comparator<Student>() {

      @Override
      public int compare(Student o1, Student o2) {

        return o1.getAge() - o2.getAge() == 0 ? o1.getName().compareTo(o2.getName()) : o1.getAge() - o2.getAge();
      }
    });

    traverseList(list);

  }

  private static void traverseList(List<Student> list) {
    Iterator<Student> iterator = list.iterator();
    while (iterator.hasNext()) {
      Student student = iterator.next();
      System.out.println(student + "\n");
    }
  }

  private static void initList(List<Student> list, Student[] students) {
    for (Student student : students) {
      list.add(student);
    }
  }
}


运行结果
{ name='孙七', age='18', gender='女'}

{ name='孙七', age='18', gender='女'}

{ name='张三', age='18', gender='男'}

{ name='王五', age='18', gender='女'}

{ name='李四', age='20', gender='男'}

{ name='赵六', age='20', gender='男'}

{ name='赵六', age='20', gender='男'}

package Collections.Sort;

import java.util.*;

class Student implements Comparable<Student> {
  private String name;
  private int age;
  private String gender;

  public Student() {
  }

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

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return this.age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getGender() {
    return this.gender;
  }

  public void setGender(String gender) {
    this.gender = gender;
  }

  public Student name(String name) {
    setName(name);
    return this;
  }

  public Student age(int age) {
    setAge(age);
    return this;
  }

  public Student gender(String gender) {
    setGender(gender);
    return this;
  }

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

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

  @Override
  public String toString() {
    return "{" +
        " name='" + getName() + "'" +
        ", age='" + getAge() + "'" +
        ", gender='" + getGender() + "'" +
        "}";
  }

  @Override
  public int compareTo(Student o) {

    return this.age - o.getAge() == 0 ? this.name.compareTo(o.getName()) : this.age - o.getAge();

  }
}

public class SortDemo4 {
  public static void main(String[] args) {
    List<Student> list = new ArrayList<>();
    Student[] students = new Student[] {
        new Student("张三", 18, "男"),
        new Student("李四", 20, "男"),
        new Student("王五", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女"),
        new Student("赵六", 20, "男"),
        new Student("孙七", 18, "女")
    };

    initList(list, students);

    traverseList(list);

  }

  private static void traverseList(List<Student> list) {
    Iterator<Student> iterator = list.iterator();
    while (iterator.hasNext()) {
      Student student = iterator.next();
      System.out.println(student + "\n");
    }
  }

  private static void initList(List<Student> list, Student[] students) {
    for (Student student : students) {
      list.add(student);
    }
  }
}

运行结果
{ name='张三', age='18', gender='男'}

{ name='李四', age='20', gender='男'}

{ name='王五', age='18', gender='女'}

{ name='赵六', age='20', gender='男'}

{ name='孙七', age='18', gender='女'}

{ name='赵六', age='20', gender='男'}

{ name='孙七', age='18', gender='女'}

package Search;

import java.util.*;

public class BinarySearch {
  public static void main(String[] args) {
    int[] array = new int[] { 9, 2, 8, 1, 5, 1, 4, 0, 2, 5, 6, 8 };

    System.out.println("原数组:" + Arrays.toString(array));

    Arrays.sort(array);

    System.out.println("排序后:" + Arrays.toString(array));

    int index1 = MyBinarySearch(array, 8);

    System.out.println(8 + "在数组中的下标为" + index1);

    int index2 = MyBinarySearch(array, 985);

    System.out.println(index2);

  }

  private static int MyBinarySearch(int[] array, int targetNum) {
    int min = 0;
    int max = array.length - 1;
    while (min <= max) {
      int mid = (min + max) / 2;
      if (array[mid] > targetNum) {
        max = mid - 1;
      }
      if (array[mid] < targetNum) {
        min = mid + 1;
      }
      if (array[mid] == targetNum) {
        return mid;
      }
    }
    return -1;
  }
}

运行结果
原数组:[9, 2, 8, 1, 5, 1, 4, 0, 2, 5, 6, 8]
排序后:[0, 1, 1, 2, 2, 4, 5, 5, 6, 8, 8, 9]
8在数组中的下标为10
-1

package Map.HashMap;

import java.util.*;

public class HashMapDemo1 {
  /*
   * 底层结构是哈希表结构，具有键唯一，无序，特点
   */
  // 键不能重复，值可以重复

  public static void main(String[] args) {
    HashMap<String, String> hashmap = new HashMap<>();

    hashmap.put("319102020330", "李华");
    hashmap.put("319102020331", "张三");
    hashmap.put("319102020332", "李四");
    hashmap.put("319102020333", "王五");
    hashmap.put("319102020330", "政然");
    hashmap.put("319102020331", "张三");

    System.out.println(hashmap);
  }
}

运行结果
{319102020333=王五, 319102020332=李四, 319102020331=张三, 319102020330=政然}

package Map.HashMap;

import java.util.*;

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 this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return this.age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public Student name(String name) {
    setName(name);
    return this;
  }

  public Student age(int age) {
    setAge(age);
    return this;
  }

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

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

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

}

public class HashMapDemo2 {
  public static void main(String[] args) {
    /*
     * 存储数据，每位学生（姓名，年龄）都有自己的家庭住址。
     * 学生和地址有对应关系，将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
     * 要求：学生姓名相同并且年龄相同视为同一名学生，不能重复存储
     */

    /**
     * 学生姓名 年龄 家庭住址
     * 张美丽 18岁 北京市朝阳区阳光小区12号楼302室
     * 王伟 20岁 上海市浦东新区海天花园8号楼506室
     * 李磊 19岁 广州市天河区华景新城15号别墅
     * 陈小芳 17岁 成都市武侯区锦江花园5栋104室
     * 赵阳 21岁 南京市鼓楼区中山路22号公寓401室
     * 
     */

    Student[] students = new Student[] {
        new Student("张美丽", 18),
        new Student("王伟", 20),
        new Student("李磊", 19),
        new Student("陈小芳", 17),
        new Student("赵阳", 21),
        new Student("张美丽", 18),
        new Student("王伟", 20),
        new Student("李磊", 19),
        new Student("陈小芳", 17),
        new Student("赵阳", 21)
    };

    String[] address = new String[] {
        "北京市朝阳区阳光小区12号楼302室",
        "上海市浦东新区海天花园8号楼506室",
        "广州市天河区华景新城15号别墅",
        "成都市武侯区锦江花园5栋104室",
        "南京市鼓楼区中山路22号公寓401室",
        "上海市徐汇区龙华路188号鸿运大厦15楼1503室",
        "广州市越秀区农林路36号绿地中心18栋2201室",
        "成都市高新区天府大道1980号华润中心3栋808室",
        "深圳市福田区福虹路28号富士康大厦10楼1005室",
        "杭州市西湖区文一西路78号西溪国际大厦5栋602室"
    };

    Map<Student, String> map = new HashMap<Student, String>();

    initMap(map, students, address);

    // 要达到去重效果，需要重写hashCode和equals方法

    traverseMap(map);

  }

  private static void traverseMap(Map<Student, String> map) {
    Set<Student> keySet = map.keySet();
    for (Student student : keySet) {
      System.out.println(student + " : " + map.get(student));
    }
  }

  private static void initMap(Map<Student, String> map, Student[] students, String[] address) {
    for (int i = 0; i < students.length; i++) {
      Student student = students[i];
      String adr = address[i];
      map.put(student, adr);
    }
  }
}

运行结果

{ name='张美丽', age='18'} : 上海市徐汇区龙华路188号鸿运大厦15楼1503室
{ name='王伟', age='20'} : 广州市越秀区农林路36号绿地中心18栋2201室
{ name='李磊', age='19'} : 成都市高新区天府大道1980号华润中心3栋808室
{ name='赵阳', age='21'} : 杭州市西湖区文一西路78号西溪国际大厦5栋602室
{ name='陈小芳', age='17'} : 深圳市福田区福虹路28号富士康大厦10楼1005室

package Map.LinkedHashMap;

import java.util.*;

public class LinkedHashMapDemo1 {
  /**
   * 底层结构是有链表和哈希表结构，具有键唯一，有序特点
   * LinkedHashMap类 , 底层采用的数据结构 : 链表+哈希表
   * 特点 :
   * 1 元素唯一
   * 2 元素有序
   * 
   * @param args
   */
  public static void main(String[] args) {
    Map<String, String> LinkedHashMap = new LinkedHashMap<>();
    /*
     * 学号: 2023001，姓名: 王小明
     * 学号: 2023002，姓名: 李婷婷
     * 学号: 2023003，姓名: 张阳
     * 学号: 2023004，姓名: 赵鑫
     * 学号: 2023005，姓名: 陈思思
     */
    LinkedHashMap.put("2023001", "王小明");
    LinkedHashMap.put("2023002", "李婷婷");
    LinkedHashMap.put("2023003", "张阳");
    LinkedHashMap.put("2023004", "赵鑫");
    LinkedHashMap.put("2023005", "陈思思");
    LinkedHashMap.put("2023004", "赵鑫");
    LinkedHashMap.put("2023005", "陈思思");

    System.out.println(LinkedHashMap);

    Iterator<Map.Entry<String, String>> it = LinkedHashMap.entrySet().iterator();
    while (it.hasNext()) {
      Map.Entry<String, String> entry = it.next();
      System.out.println(entry.getKey() + " : " + entry.getValue());
    }
  }
}
运行结果
{2023001=王小明, 2023002=李婷婷, 2023003=张阳, 2023004=赵鑫, 2023005=陈思思}
2023001 : 王小明
2023002 : 李婷婷
2023003 : 张阳
2023004 : 赵鑫
2023005 : 陈思思

package Map.TreeMap;

import java.util.*;

public class TreeMapDemo1 {
  /*
   * 底层是有红黑树，具有键唯一，排序特点
   * TreeMap的底层是红黑树实现的，有排序的能力，键去重。
   * 可以自然排序（键所在的类要实现Comparable）
   * 若自定义类没有自然排序功能，或自然排序功能不满足要求时。可以自定义比较器排序（Comparator）
   * 
   */
  public static void main(String[] args) {
    // 自然排序
    TreeMap<Integer, String> treeMap1 = new TreeMap<>();
    treeMap1.put(3, "Three");
    treeMap1.put(1, "One");
    treeMap1.put(2, "Two");
    System.out.println("自然排序：" + treeMap1);
    // 自定义比较器排序
    TreeMap<Integer, String> treeMap2 = new TreeMap<>((o1, o2) -> o2 - o1);
    treeMap2.put(3, "Three");
    treeMap2.put(1, "One");
    treeMap2.put(2, "Two");
    System.out.println("自定义比较器排序：" + treeMap2);
  }
}

运行结果
自然排序：{1=One, 2=Two, 3=Three}
自定义比较器排序：{3=Three, 2=Two, 1=One}

package Map.TreeMap;

import java.util.*;

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 this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return this.age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public Student name(String name) {
    setName(name);
    return this;
  }

  public Student age(int age) {
    setAge(age);
    return this;
  }

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

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

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

}

public class TreeMapDemo2 {
  public static void main(String[] args) {
    /*
     * 需求：创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。 学生属性姓名和年龄
     * 要求按照年龄进行升序排序并遍历
     */
    Student[] students = new Student[] {
        new Student("张美丽", 18),
        new Student("王伟", 20),
        new Student("李磊", 19),
        new Student("陈小芳", 17),
        new Student("赵阳", 21),

    };

    String[] nativePlace = new String[] { "安徽安庆", "江苏无锡", "浙江杭州", "四川成都", "陕西咸阳" };

    Map<Student, String> map = new TreeMap<>(new Comparator<Student>() {

      @Override
      public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        return o1.getAge() - o2.getAge();
      }
      
    });

    initMap(map, students, nativePlace);

    traverseMap(map);
  }

  private static void traverseMap(Map<Student, String> map) {
    Set<Map.Entry<Student, String>> entries = map.entrySet();
    for (Map.Entry<Student, String> entry : entries) {
      System.out.println(entry);
    }
  }

  private static void initMap(Map<Student, String> map, Student[] students, String[] nativePlace) {
    for (int i = 0; i < nativePlace.length; i++) {
      Student student = students[i];
      String place = nativePlace[i];
      map.put(student, place);
    }
  }
}

运行结果
{ name='陈小芳', age='17'}=四川成都
{ name='张美丽', age='18'}=安徽安庆
{ name='李磊', age='19'}=浙江杭州
{ name='王伟', age='20'}=江苏无锡
{ name='赵阳', age='21'}=陕西咸阳

package Map.Map;

import java.util.*;

/**
 * - public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
 * - public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
 * - public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
 * - public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
 * - public boolean containKey(Object key): 判断该集合中是否有此键
 */

public class MapDemo1 {
  public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();
    map.put("中国科学技术大学", "张三");
    map.put("南京航空航天大学", "李四");
    map.put("北京航空航天大学", "王五");
    map.put("南京邮电大学", "王二麻子");
    map.put("北京外国语大学", "孙七");
    map.put("首都对外经济贸易大学", "赵德柱");

    traverseMap(map);
    System.out.println("=========================================================================");

    System.out.println(map.remove("南京邮电大学"));

    System.out.println(map.get("首都对外经济贸易大学"));

    Set<String> keySet = map.keySet();

    System.out.println("所有学校名称：" + keySet);

    System.out.println(map.containsKey("南京航空航天大学"));

    map.entrySet().forEach(System.out::println);

  }

  private static void traverseMap(Map<String, String> map) {
    for (String key : map.keySet()) {
      System.out.println("学校名称：" + key + "\t\t\t\t\t 学生姓名：" + map.get(key));
    }

  }
}
运行结果
学校名称：北京航空航天大学                                       学生姓名：王五
学校名称：南京邮电大学                                   学生姓名：王二麻子
学校名称：中国科学技术大学                                       学生姓名：张三
学校名称：北京外国语大学                                         学生姓名：孙七
学校名称：首都对外经济贸易大学                                   学生姓名：赵德柱
学校名称：南京航空航天大学                                       学生姓名：李四
=========================================================================
王二麻子
赵德柱
所有学校名称：[北京航空航天大学, 中国科学技术大学, 北京外国语大学, 首都对外经济贸易大学, 南京航空航天大学]
true
北京航空航天大学=王五
中国科学技术大学=张三
北京外国语大学=孙七
首都对外经济贸易大学=赵德柱
南京航空航天大学=李四

package Map.Map;

import java.util.*;

public class MapTest {
  public static void main(String[] args) {
    /*
     * 需求：字符串“aababcabcdabcde”
     * 请统计字符串中每一个字符出现的次数，并按照以下格式输出
     * 输出结果：
     * a（5）b（4）c（3）d（2）e（1）
     * 
     */

    /*
     * Map集合中，键存字符，值存出现的次数
     * 遍历字符串，得到每一个字符
     * 到集合中看是否包含这个字符
     * 如果不包含，表示是第一次出现
     * 如果包含，表示不是第一次出现
     */

    String str = new String("aababcabcdabcde");

    HashMap<Character, Integer> hashmap = new HashMap<>();

    for (int i = 0; i < str.length(); i++) {
      char key = str.charAt(i);
      if (!hashmap.containsKey(key)) {
        hashmap.put(key, 1);
      } else {
        hashmap.put(key, hashmap.get(key) + 1);
      }
    }

    Set<Character> keyset = hashmap.keySet();
    for (Character character : keyset) {
      System.out.print(character + "(" + hashmap.get(character) + ")");
    }
  }
}
运行结果
a(5)b(4)c(3)d(2)e(1)

package Map.Map;

import java.util.*;

public class TraverseMap {
  public static void main(String[] args) {
    /*
     * 第一种遍历方式 : 键找值方式
     * 
     */
    Map<String, String> map = new HashMap<>();

    String[] strings1 = new String[] { "周瑜", "孙策", "刘备", "诸葛亮" };

    String[] strings2 = new String[] { "大乔", "小乔", "孙尚香", "黄月英" };

    initMap(map, strings1, strings2);

    // 第一种遍历方式 : 键找值方式
    fun1(map);

    System.out.println("======================================================");

    // 第二种遍历方式 : 键值对对象遍历

    fun2(map);
  }

  private static void fun2(Map<String, String> map) {
    // 第二种遍历方式 : 键值对对象遍历
    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    for (Map.Entry<String, String> entry : entrySet) {
      System.out.println(entry.getKey() + "-" + entry.getValue());
    }
  }

  private static void initMap(Map<String, String> map, String[] strings1, String[] strings2) {
    for (int i = 0, j = 0; i < strings1.length && j < strings2.length; i++, j++) {
      map.put(strings1[i], strings2[j]);
    }
  }

  private static void fun1(Map<String, String> map) {
    // 第一种遍历方式 : 键找值方式
    Set<String> keySet = map.keySet();

    for (String key : keySet) {
      System.out.println(key + "-" + map.get(key));
    }

  }
}

运行结果
刘备-孙尚香
孙策-小乔
诸葛亮-黄月英
周瑜-大乔
======================================================
刘备-孙尚香
孙策-小乔
诸葛亮-黄月英
周瑜-大乔

package Nesting_of_sets.List_Nested_List;

import java.util.*;

public class List_Nested_List {
  public static void main(String[] args) {
    /*
     * 使用场景举例：一年级有多个班级，每个班级有多名学生。要求保存每个班级的学生姓名，
     * 保存一个年级所有的班级信息
     * 
     * 思路：
     * 可以使用List集合保存一个班级的学生
     * 可以使用List集合保存所有班级
     * 
     * 因此我们可以定义集合如下：
     * 班级：List<String>
     * 年级：List<List<String>>
     * 
     */

    // 创建班级集合
    List<String> class1Students = new ArrayList<>();
    // 添加学生
    class1Students.add("Tom");
    class1Students.add("Jerry");
    class1Students.add("Spike");
    // 创建班级集合
    List<String> class2Students = new ArrayList<>();
    // 添加学生
    Collections.addAll(class2Students, "Tyke", "Butch", "Quacker", "Daffy", "Judy");

    // 年级
    List<List<String>> gradeClassList = new ArrayList<>();

    // 添加班级
    Collections.addAll(gradeClassList, class1Students, class2Students);

    traverseList(gradeClassList);

  }

  private static void traverseList(List<List<String>> gradeClassList) {

    // 遍历年级集合
    // 三种遍历方法

    for (List<String> classes : gradeClassList) {
      for (String stuName : classes) {
        System.out.println("姓名:" + stuName);
      }
      System.out.println("====================");
    }
  }

}

运行结果
姓名:Tom
姓名:Jerry
姓名:Spike
====================
姓名:Tyke
姓名:Butch
姓名:Quacker
姓名:Daffy
姓名:Judy
====================

package Nesting_of_sets.List_Nested_Map;

/*
 * 
 * 使用场景举例：一年级有多个班级，每个班级有多名学生。要求保存每个班级的学生姓名，姓名有与之对应的学号，保存一年级所有的班级信息。

思路：
可以使用Map集合保存一个班级的学生（键是学号，值是名字）
可以使用List集合保存所有班级

因此我们可以定义集合如下：
班级：Map<String,String> 键是学号，值是姓名
年级：List<Map<String,String>>保存每个班级的信息 

 */

import java.util.*;

public class List_Nested_Map {
  public static void main(String[] args) {
    Map<String, String> class1Students = new HashMap<>();

    class1Students.put("001", "Tom");
    class1Students.put("002", "Jerry");
    class1Students.put("003", "Spike");

    Map<String, String> class2Students = new HashMap<>();

    class2Students.put("004", "Tyke");
    class2Students.put("005", "Butch");
    class2Students.put("006", "Quacker");

    Map<String, String> class3Students = new HashMap<>();

    class3Students.put("007", "Nibbles");
    class3Students.put("008", "Sneezy");
    class3Students.put("009", "Dopey");

    List<Map<String, String>> gradeClasses = new ArrayList<>();

    Collections.addAll(gradeClasses, class1Students, class2Students, class3Students);

    traverseMap(gradeClasses);

  }

  private static void traverseMap(List<Map<String, String>> gradeClasses) {
    for (Map<String, String> classStudents : gradeClasses) {
      for (Map.Entry<String, String> entry : classStudents.entrySet()) {
        System.out.println("学号：" + entry.getKey() + "，姓名：" + entry.getValue());
      }
      System.out.println("================================================");
    }

    for (Map<String, String> map : gradeClasses) {
      Set<String> keySet = map.keySet();
      for (String key : keySet) {
        System.out.println("学号：" + key + "，姓名：" + map.get(key));
      }
      System.out.println("================================================");
    }
  }
}

运行结果
学号：001，姓名：Tom
学号：002，姓名：Jerry
学号：003，姓名：Spike
================================================
学号：004，姓名：Tyke
学号：005，姓名：Butch
学号：006，姓名：Quacker
================================================
学号：007，姓名：Nibbles
学号：008，姓名：Sneezy
学号：009，姓名：Dopey
================================================
学号：001，姓名：Tom
学号：002，姓名：Jerry
学号：003，姓名：Spike
================================================
学号：004，姓名：Tyke
学号：005，姓名：Butch
学号：006，姓名：Quacker
================================================
学号：007，姓名：Nibbles
学号：008，姓名：Sneezy
学号：009，姓名：Dopey
================================================

package Nesting_of_sets.Map_Nested_Map;

import java.util.*;

/*
 * 
 * 使用场景举例：一个年级有多个班级，每个班级有多名学生。要求保存每个班级的学生姓名，姓名有与之对应的学号，保存一年级所有的班级信息，班级有与之对应的班级名称。

思路：
可以使用Map集合保存一个班级的学生（键是学号，值是名字）
可以使用Map集合保存所有班级（键是班级名称，值是班级集合信息）

因此我们可以定义集合如下：
班级： Map<String,String> 键：学号，值：姓名
年级： Map<String,Map<String,String>> 键：班级名称，值：具体班级信息

 */
public class Map_Nested_Map {
  public static void main(String[] args) {
    // 班级名称 Map<String, String> 键：学号，值：姓名

    Map<String, Map<String, String>> gradeMap = new HashMap<>();

    Map<String, String> class1Map = new HashMap<>();

    class1Map.put("001", "Tom");
    class1Map.put("002", "Jerry");
    class1Map.put("003", "Spike");
    class1Map.put("004", "Lily");

    Map<String, String> class2Map = new HashMap<>();

    class2Map.put("001", "Tyke");
    class2Map.put("002", "Butch");
    class2Map.put("003", "Toodles");
    class2Map.put("004", "Quacker");

    Map<String, String> class3Map = new HashMap<>();

    class3Map.put("001", "Tuffy");
    class3Map.put("002", "Puffy");
    class3Map.put("003", "Fluffy");
    class3Map.put("004", "Bubbles");
    class3Map.put("005", "Buddy");

    gradeMap.put("class1", class1Map);
    gradeMap.put("class2", class2Map);
    gradeMap.put("class3", class3Map);

    traverseGradeMap(gradeMap);

  }

  private static void traverseGradeMap(Map<String, Map<String, String>> gradeMap) {
    // for (Map.Entry<String, Map<String, String>> entry : gradeMap.entrySet()) {
    // System.out.println("Class Name: " + entry.getKey());
    // Map<String, String> classMap = entry.getValue();
    // for (Map.Entry<String, String> studentEntry : classMap.entrySet()) {
    // System.out.println("Student ID: " + studentEntry.getKey() + ", Student Name:
    // " + studentEntry.getValue());
    // }
    // System.out.println("=============================================================");
    // }

    Set<String> keySet1 = gradeMap.keySet();// 拿到每个班级的名称
    for (String className : keySet1) {
      System.out.println("Class Name:" + className);
      Set<String> keySet2 = gradeMap.get(className).keySet();// 拿到每个班级的学生信息
      for (String studentId : keySet2) {
        System.out.println("Student ID:" + studentId + ", Student Name:" + gradeMap.get(className).get(studentId));
      }
      System.out.println("=============================================================");
    }

  }
}
运行结果
Class Name:class3
Student ID:001, Student Name:Tuffy
Student ID:002, Student Name:Puffy
Student ID:003, Student Name:Fluffy
Student ID:004, Student Name:Bubbles
Student ID:005, Student Name:Buddy
=============================================================
Class Name:class2
Student ID:001, Student Name:Tyke
Student ID:002, Student Name:Butch
Student ID:003, Student Name:Toodles
Student ID:004, Student Name:Quacker
=============================================================
Class Name:class1
Student ID:001, Student Name:Tom
Student ID:002, Student Name:Jerry
Student ID:003, Student Name:Spike
Student ID:004, Student Name:Lily
=============================================================