集合框架和泛型

1、set

1. HashSet不重复，无序。
2. TreeSet不重复，会自动排序，升序。

3. import java.util.TreeSet;
   import java.util.Set;
   public class Tree {
   public static void main(String[] args) {
   Set set=new TreeSet<>();
   set.add("GG");
   set.add("gg");
   set.add("ee");
   set.add("EE");
   System.out.println(set);

   }
   }

    

2、map集合 ⽆序，键唯⼀

1. 存的是键值对

2. package com.map;
   
   import java.util.*;
   
   public class MapTest {
       public static void main(String[] args) {
           //Map集合
           Map map = new HashMap();
           //添加
           map.put("CN","中华人民共和国");
           map.put("CN","中华人民共和国");
           map.put("US","美利坚合众国");
           map.put("RU","俄罗斯联邦");
           //显示无序，唯一
           System.out.println(map);
           System.out.println(map.get("CN"));
           //根据键取值
           String key ="CN";
           Object o = map.get(key);
           String str =(String) o;
           System.out.println(key+"对应的国家是："+str);
           //获取长度
           int size = map.size();
           System.out.println("Map共有"+size+"组数据");
           //判断是否存在指定的键（key）
           boolean b = map.containsKey(key);
           System.out.println("Map中包含"+key+"吗？："+b);
           String value = "中华人民共和国";
           boolean b1 = map.containsValue(value);
           System.out.println("Map中包含"+value+"吗？："+b1);
           //获取所有键（key）
           Set keySet = map.keySet();
           System.out.println(keySet);
           //获取所有值（value）
           Collection values = map.values();
           System.out.println(values);
           //清空
   //        map.clear();
   //        System.out.println(map);
           //遍历
           System.out.println("========================");
           keySet = map.keySet();
           for (Object o1 : keySet) {
               String key2 = (String) o1;
               String value2=(String)map.get(key2);
               System.out.println(key2+"==>"+value2);
           }
           System.out.println("========================");
           keySet = map.keySet();
           System.out.println(keySet);
           Iterator iterator = keySet.iterator();
           while (iterator.hasNext()) {
               String key2 = (String)iterator.next();
               String value2 = (String)map.get(key2);
               System.out.println(key2+"==>"+value2);
           }
           System.out.println("=========================");
           Set set = map.entrySet();
           System.out.println(set);
           for (Object o2 : set) {
               Map.Entry entry= (Map.Entry)o2;
               Object key2 = entry.getKey();
               Object value2 = entry.getValue();
               System.out.println(key2+"==>"+value2);
           }
       }
   
   }

    

3、泛型

1. 通过泛型可以避免数据向下转型时的异常问题。
2.  常⽤泛型 List<E> Set<E> Map<K,V> Iterator<E>。
3. 泛型中指定类型不能是基本数据类型，⽽只能是引⽤数据类型。

4、Collections

1. package com.set;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.List;
   
   public class SetTest2 {
       public static void main(String[] args) {
           List<String> list = new ArrayList<String>();
           list.add("苹果");
           list.add("橘子");
           list.add("香蕉");
           list.add("西瓜");
           //排序
           System.out.println("排序前" + list);
           Collections.sort(list);
           System.out.println("排序后" + list);
           //查找 前提 必须是排序的升序的
           int banana = Collections.binarySearch(list, "香蕉");
           System.out.println("index=" + banana);
           //找最大值
           String max = Collections.max(list);
           System.out.println(list + "中最大值是：" + max);
           //最小值
           String min = Collections.min(list);
           System.out.println(list + "中最大值是：" + min);
           //反转
           System.out.println("======================");
           Collections.reverse(list);
           System.out.println(list);
       }
   }

    

5、compareTo

1. 对于⾃定义的类型进⾏排序，必须要implementsComparable<E> 并重写 public int compareTo(E e),此⽅法有返回值。
2. 这个⽅法有返回值的意义。
   1. 返回0 表⽰两个对象相待。
   2. 返回正数 表⽰当前对象⼤于 参数对象。
   3. 返回负数 表⽰当前对象⼩于 参数对象。

3. package com.student;
   
   public class Student implements Comparable<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;
       }
   
       @Override
       public String toString() {
           return "Student{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   '}';
       }
   
       @Override
       public int compareTo(Student o) {
           //按升序排
           return this.age-o.age;
           //按降序排 return -(this.age-o.age);
           //return o.age-this.age;
       }
   }

   package com.student;
   
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.List;
   
   public class StudentTest {
       public static void main(String[] args) {
           Student s1= new Student("未来世界",10);
           Student s2= new Student("文明古国",15);
           Student s3= new Student("选择英雄",18);
           Student s4= new Student("傻人傻福",20);
           Student s5= new Student("逼上梁山",23);
           List<Student> studentList= Arrays.asList(s1,s2,s3,s4,s5);
           System.out.println("排序前："+studentList);
           Collections.sort(studentList);
           System.out.println("排序后"+studentList);
   
           //降序排
           Collections.reverse(studentList);
           System.out.println("排序后"+studentList);
       }
   }