1.Map接口特点

  1. Map与Collection并列存在。用于保存具有映射关系的数据: Key-Value(双列集合)
  2. Map中的key和value可以是任何引用类型的数据
  3. Map中的key不允许重复，原因和HashSet一样，当key一样，新的值会替换原先的
  4. Map中的value可以重复
  5. Map的key可以为null(只能一个)，value也可以为null(可以多个)
  6. key和value之间是单向一对一关系，通过指定的key总能找到对应的value
  7. put: 添加
  8. remove: 根据健删除映射关系
  9. get: 根据键获取值
  10. size: 获取元素个数
  11. isEmpty: 判断个数是否为0
  12. clear: 清除

  13. containsKey: 查找键是否存在 

    1. import java.util.*;
    2. public class Hello {
    3. public static void main(String[] args) throws Exception {
    4.  HashMap hashMap = new HashMap();
    5.  hashMap.put("user","123");
    6.  hashMap.put("password","123");
    7.  hashMap.put("password","123");
    8.  System.out.println(hashMap);//{password=123, user=123}
    9. }}

    2.HashMap的遍历

    1. import java.util.*;
    2. import java.util.function.Consumer;
    3. public class Hello {
    4. public static void main(String[] args) throws Exception {
    5.  HashMap hashMap = new HashMap();
    6.  hashMap.put("user","123");
    7.  hashMap.put("password","123");
    8.  hashMap.put("password","1234");
    9.  Set set = hashMap.keySet();
    10.  System.out.println("========one=========");
    11.  for (Object o : set) {
    12.      System.out.println(o+"-"+hashMap.get(o));
    13.  }
    14.  System.out.println("========second=========");
    15.  Iterator iterator = set.iterator();
    16.  while (iterator.hasNext()) {
    17.      Object next =  iterator.next();
    18.      System.out.println(next+"-"+hashMap.get(next));
    19.  }
    20.  System.out.println("========third=========");
    21.  Set set1 = hashMap.keySet();
    22.  set1.forEach(new Consumer() {
    23.      @Override
    24.      public void accept(Object o) {
    25.          System.out.println( o+"-"+hashMap.get(o));
    26.      }
    27.  });
    28.  System.out.println("========four=========");
    29.  Set set2 = hashMap.entrySet();
    30.  for (Object o : set2) {
    31.      Map.Entry o1 = (Map.Entry) o;//向上转型
    32.      System.out.println( o1.getKey()+"-"+o1.getValue());
    33.  }
    34.  System.out.println("======遍历所有val-one===========");
    36.  Collection values = hashMap.values();
    37.  for (Object o1 : values) {
    38.      System.out.println(o1);
    39.  }     System.out.println("======遍历所有val-second===========");
    40.  Iterator iterator1 = values.iterator();
    41.  while (iterator1.hasNext()) {
    42.      Object next = iterator1.next();
    43.      System.out.println(next);
    44.  }    System.out.println("======遍历所有val-third===========");
    45.  values.forEach(new Consumer() {
    46.      @Override
    47.      public void accept(Object o) {
    48.          System.out.println(o);
    49.      }
    50.  });
    51. }}

    3.Hashtable

  14. 存放的元素是键值对: K-V

  15. Hashtable的键和值都不能为null，否则会抛出NullPointerException
  16. Hashtable使用方法基本上和HashMap一样

  17. Hashtable线程安全，HashMap线程不安全 

    1. import java.util.*;
    2. public class Hello {
    3. public static void main(String[] args) throws Exception {
    4.  Hashtable hashtable = new Hashtable();
    5.  hashtable.put("1","1");
    6.  hashtable.put("2","2");
    7.  System.out.println(hashtable);//{2=2, 1=1}
    8. }}

    4.Properties

  18. Properties类继承自Hashtable类

  19. 使用一种键值对的形式来保存数据，使用特点和Hashtable类似
  20. Properties还可用于从xxx.properties文件中，加载数据到Properties类对象,并进行读取和修改。xxx.properties通常作为配置文件

  21. Properties的增删改查 

    1. import java.util.*;
    2. public class Hello {
    3. public static void main(String[] args) throws Exception {
    4.  Properties Properties = new Properties();
    5.  Properties.put("1","1");
    6.  Properties.put("2","2");
    7.  System.out.println(Properties);
    8. }}

    5.TreeSet

  22. TreeSet的基本使用，TreeSet底层走的是TreeMap

  23. 在构造器中，可以传入一个比较器，指定排序规则

  24. 如果比较器返回的结果为0，则数据不会加入到TreeSet 

    1. import java.util.*;
    2. public class Hello {
    3. public static void main(String[] args) throws Exception {
    4.  TreeSet TreeSet = new TreeSet(new Comparator() {
    5.      @Override
    6.      public int compare(Object o1, Object o2) {
    7.          return ((String)o1).length()-((String)o2).length();}});
    8.  TreeSet.add("a");
    9.  TreeSet.add("aa");
    10.  TreeSet.add("aaa");
    11.  TreeSet.add("aaaa");
    12.  TreeSet.add("aaaaa");
    13.  System.out.println(TreeSet);//[a, aa, aaa, aaaa, aaaaa]
    14.  //不能添加null
    15. }}

    6.TreeMap

  25. TreeMap的基本使用

  26. 在构造器中，可以传入一个比较器，指定排序规则

  27. 如果比较器返回的结果为0，则key不会加入到TreeMap，值会替换 

    1. import java.util.*;
    2. public class Hello {
    3. public static void main(String[] args) throws Exception {
    4.  TreeMap TreeMap = new TreeMap(new Comparator() {
    5.      @Override
    6.      public int compare(Object o1, Object o2) {
    7.          return 0;
    8.      }//((String)o1).length()-((String)o2).length()
    9.  });//
    10.  TreeMap.put("a1","1a");
    11.  TreeMap.put("aa","aa");
    12.  TreeMap.put("aaa","aaa");
    13.  TreeMap.put("aaaa","aaaa");
    14.  TreeMap.put("aaaaa","aaaaa");
    15.  System.out.println(TreeMap);//{a1=aaaaa}
    16. }}

    7.Collections工具类

  28. Collections工具类的作用
    是一个操作Set、List和Map等集合的工具类
    提供了一系列静态的方法对集合元素进行排序、查询和修改等操作

  29. 排序相关操作
    a) reverse(List): 反转List中元素的顺序
    b) shuffle(List): 对List集合元素进行随机打乱
    c) sort(List): 根据元素的自然顺序对指定List集合元素按升序排序
    d) sort(List, Comparator): 根据指定规则对List集合元素进行排序
    e) swap(List,int,int): 将指定List集合中的i处元素和j处元素进行交换

  30. 查找和替换
    a) Object max(Collection): 根据元素的自然顺序，返回集合中的最大元素
    b) Object max(Collection, Comparator): 根据指定规则, 返回集合中的最大元素
    c) Object min(Collection)
    d) Object min(Collection, Comparator)
    e) int frequency(Collection, Object): 返回指定集合中指定元素的出现次数
    f) void copy(List dest,List src): 将src中的内容复制到dest中
    g) boolean replaceAll(List list, Object oldVal, Object newVal): 使用新值替换所有旧值

    8.集合使用的选择

  31. 判断需要存储数据的类型(一组对象或一组键值对)

  32. 一组对象(单列): Collection接口
    允许重复: List
    增删多: LinkedList(底层是双向链表)
    改查多: ArrayList(底层是Object类型的可变数组)
    不允许重复: Set
    无序: HashSet(底层是HashMap，数组+链表+红黑树)
    排序: TreeSet
    插入和取出顺序一致: LinkedHashSet(底层是数组+双向链表)

  33. 一组键值对(双列): Map接口
    键无序: HashMap(底层jdk7: 数组+链表，jdk8: 数组+链表+红黑树)
    键排序: TreeMap
    键插入和取出顺序一致: LinkedHashMap
    读取文件: Properties

    9.泛型

  34. 为什么需要泛型
    a) 编译时，检查添加元素的类型，提高了安全性
    b) 减少了类型转换的次数，提高效率

  35. 泛型的基本使用
    ArrayList arrayList = new ArrayList();
  36. 泛型是一种可以接受数据类型的类型，相当于通用型

  37. 泛型的作用
    a) 泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生类型转换异常。同时，代码更加简洁、健壮
    b) 可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型、参数类型

  38. 泛型的基本概念
    a) public class ArrayList
    int a = 1; a = 2; a = 3;
    E = String; E = Dog; E = Integer;
    这里的E就是泛型，字母可以随意表示。泛型用来表示数据类型的类型
    b) 泛型又称参数化类型，是jdk5出现的特性, 解决数据类型的安全性问题
    c) 在类实例化时只要指定好需要的具体的类型即可

  39. 泛型的声明
    interface List{}
    class HashMap{}
    T、K、V不代表值，而是表示类型，任意字母都可以。常用T表示，是Type的缩写
  40. 泛型实例化
    HashMap hashMap = new HashMap<>();
    Iterator> iterator = entries.iterator();

  41. 泛型细节
    a) T、K、V，只能放引用类型
    b) 在给泛型指定具体类型后，可以传入该类型或者其子类类型
    c) HashMap hashMap = new HashMap(); 等价于 HashMap ```java import java.util.*; public class Hello { public static void main(String[] args) throws Exception { ArrayList objects = new ArrayList<>(); objects.add(200); objects.add(100); Collections.sort(objects, new Comparator() {

    1.  @Override
    2.  public int compare(Integer o1, Integer o2) {
    3.      return o2-o1;
    4.  }

    }); System.out.println(objects);

    a objecta = new a<>();//自定义数据类型 objecta.test(“123”);

    System.out.println(“================================”); HashMap HashMap = new HashMap<>(); HashMap.put(“1叶秋”,”123”); HashMap.put(“2叶秋”,”123”); HashMap.put(“3叶秋”,”123”); HashMap.put(“4叶秋”,”123”); Set> entries = HashMap.entrySet(); Iterator> iterator = entries.iterator(); while (iterator.hasNext()) {

    1.  Map.Entry<String, String> next =  iterator.next();
    2.  System.out.println(next.getKey()+"-"+next.getValue());

    } }}

class a{//自定义泛型类 public x name; public x test(x a){ System.out.println(a); return a; }; }

  1. <a name="kbLp9"></a>
  2. #### 10.自定义泛型类
  4. 1. 泛型标识符，一般是单个大写字母
  5. 1. 泛型标识符可以有多个
  6. 1. 实例属性、实例方法参数、实例方法返回值都可以使用泛型
  7. 1. 静态属性、静态方法、静态代码块都不能使用泛型
  8. 1. 使用了泛型的数组不能初始化
  9. 1. 泛型类的类型是在创建对象时确定的
  10. 1. 创建对象时，没有指定类型，默认为Object
  11. ```java
  12. public class Hello {
  13.  public static void main(String[] args) throws Exception {
  14.      a<String,Integer,Boolean> a = new a<>();//自定义数据类型   String,Integer,Boolean  全是包装类
  15.      a.test(1);
  16.      a.aaaa=new String[]{"123"};//数组外部初始化
  17.  }}
  18. class a<x,y,z>{
  19.     public x aaaa[];
  20.     //自定义泛型类中，不能使用静态方法；不能初始化数组
  21.     public x name;
  22.     public y test(y a){
  23.         System.out.println(a);
  24.         return a;
  25.     };
  26.     public z test1(z a){
  27.         System.out.println(a);
  28.         return a;
  29.     };
  30. }

11.自定义泛型接口

  1. 接口中的静态成员不能使用泛型
  2. 泛型接口的类型，在继承接口或者实现接口时确定
  3. 没有指定类型，默认为Object 
    1. public class Hello {
    2. public static void main(String[] args) throws Exception {
    3.  a<String,Integer,Boolean> a = new a<>();//自定义数据类型
    4.  a.test(1);
    5.  a.aaaa=new String[]{"123"};//数组外部初始化
    6.  a.test2("接口");
    7.  a.A("接口");
    8. }}
    9. class a<x,y,z> implements USB1<String,String,String>{
    10. public x aaaa[];
    11. //自定义泛型类中，不能使用静态方法；不能初始化数组
    12. public x name;
    13. public y test(y a){
    14.     System.out.println(a);
    15.     return a;
    16. };
    17. public z test1(z a){
    18.     System.out.println(a);
    19.     return a;
    20. };
    21. @Override
    22. public String A(String a) {
    23.     System.out.println("null");
    24.     return "null";
    25. }
    26. public String test(String a) {
    27.     return USB1.super.test2(a);
    28. }
    29. }
    30. interface USB1<W,X,Z>{
    31. X A( W a );
    32. //不能使用static
    33. default Z test2(Z a){//接口的默认方法
    34. System.out.println(a);
    35. return a;
    36. }}

    12.Class类的方法

getName 获取全类名
getSimpleName 获取简单类名
getSuperClass 以Class形式返回父类信息
getInterfaces 以Class[]形式返回接口信息
getField/getFields 获取public修饰的字段，包含本类和父类
getDeclaredField/getDeclaredFields 获取本类所有字段
getMethod/getMethods 获取public修饰的方法，包含本类和父类
getDeclaredMethod/getDeclaredMethods 获取本类所有方法
getConstructors 获取本类public修饰的构造器
getDeclaredConstructors 获取本类所有构造器
getPackage 以Package形式返回包信息
getAnnotations 以Annotation形式返回注解信息
getClass 得到运行类型
newlnstance 创建对象
getClassLoader 得到类加载器
forName 得到类对象