Map接口，静态导入，可变参数，Collections集合工具类

Map接口:

　　Map集合中的每个元素由键和值2部分组成，通过键可以找到相应的值，Collection的集合为单列集合，Map的集合为双列集合，Map的集合不能不含重复的键，值可以重复，每个键只能对应一个值。

　　常用的方法：

Map接口常用的集合：

HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。也就是说，当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法。

　 LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。

　　注意事项：两个泛型变量<K,V>的数据类型可以相同，也可以不同。

Map集合遍历：

　　键找值方式：即通过元素中的键，获取键所对应的值。

　　1：获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。

　　2：遍历键的Set集合，获取每一个键。

　　3：根据键，获取键所对应的值。

　　Map集合方法：keySet()得到Map集合中所有的键。

　　　　　　　　　get(Object key):通过指定的键，从Map集合中找到相应的值。

　　代码体现：

　public static void main(String[] args) {
        　　HashMap<String,Integer> map=new HashMap<String,Integer>();
        　　map.put("张三",18);
       　　 map.put("李四",18);
       　　 map.put("张三",18);
     　　   //map.remove("李四");
      　　  //System.out.println(map.get("李四"));
     　　   //keySet+增强for循环
   　　 //1:获取所有key所在的Set集合
     　　   Set<String> set=map.keySet();
      　　  //2：遍历Set集合获取对应的value值
     　　   for(String key:set){
            　　System.out.println(key+"..."+map.get(key));
       　　 }
       　　 //2:keySet+Iterator迭代器
      　　  Set<String> set2=map.keySet();
       　　 Iterator<String> it=set2.iterator();
      　　  while(it.hasNext()){
          　　  String b=it.next();
            　　System.out.println(b+"..."+map.get(b));
      　　  }
   　　 }

　　Entry键值对对象：

　　　　Entry是一个嵌套接口，类似于成员内部类，Entry将键值对应的关系封装成了对象，即键值对对象，当遍历Map集合时，可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

　　　　Entry是Map接口中提供的一个静态内部嵌套接口。

　　　　接口Map<k,v>

　　　　接口Map.Entry<k,v>

　　　　getKey()方法:获取Entry对象中的键。

　　　　getValue()方法:获取Entry对象中的值。

　　　　entrySet()方法：用于返回Map集合中所有的键值对（Entry）对象，以Set集合形式返回。

　　　　步骤：

　　　　　　键值对方式：即通过集合中的每个键值对（Entry）对象，获取键值对（Entry）对象中的键与值

　　　　　　1：获取Map集合中的键值对（Entry）对象,以Set集合形式返回。

　　　　　　2：遍历包含键值对（Entry）对象的Set集合，得到每一个键值对（Entry）对象。

　　　　　　3：通过键值对（Entry）对象，获取Entry对象中的键与值。

　　　　　　注意事项：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。因为他与迭代器与Collection没有任何关系。

　　　　　　代码体现：　　

　　public class Demo02 {
  　　　　　　　　 public static void main(String[] args) {
       　　　　　　 HashMap<Person, String> map = new HashMap<Person, String>();
       　　　　　　 map.put(new Person("张三", 18), "java0803");
       　　　　　　map.put(new Person("张三", 18), "java0803");
     　　　　　　   map.put(new Person("李四", 20), "java0903");
      　　　　　　  map.put(new Person("王五", 21), "java0903");
       　　　　　　 //1:entrySet+增强for
       　　　　　　 //获取所有结婚证所在的Set集合
      　　　　　　  Set<Map.Entry<Person,String>> set=map.entrySet();
        　　　　　　//遍历Set集合，取到每一个结婚证对象
      　　　　　　  for(Map.Entry<Person,String> entry:set){
           　　　　　 System.out.println(entry.getKey()+"..."+entry.getValue());
       　　　　　　　　 }
       　　　　　　 //entrySet+Iterator迭代器
     　　　　　　   Set<Map.Entry<Person,String>> set2=map.entrySet();
     　　　　　　   Iterator<Map.Entry<Person,String>> it=set2.iterator();
     　　　　　　   while(it.hasNext()){
         　　　　　　   Map.Entry<Person,String>  a=it.next();
         　　　　　　   System.out.println(a.getKey()+"..."+a.getValue());
       　　　　　　　　 }
   　　　　　　　　 }

静态导入：　　

在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。

可变参数：我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：　　　　

　　　　　　修饰符返回值类型方法名(参数类型... 形参名){ }==修饰符返回值类型方法名(参数类型[] 形参名){ }，只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

　　　　　　同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

　　　　　　注意事项：只能出现一次，可变参数一定要写在参数列表的末尾位置。

　　　　代码体现：

　　package com.oracle.demo01;
　　　　　　　　import static java.lang.System.out;
　　　　　　　　public class Demo03 {

　　　　　　　　public static void main(String[] args) {
       　　　　　　 out.println(add(44,55));
    　　　　　　    out.println(add(44,55,99));
   　　　　　　　　 }
　　　　　　　　public static int add(int...a){
   　　　　　　　　 int sun=0;
   　　　　　　　　 for(int b:a){
      　　　　　　  　　sun+=b;
   　　　　　　 　　}
   　　　　　　　　 return sun;
　　　　　　　　　　}
　　　　　　　　}

collections集合工具类：

　　　　Collections是集合工具类，用来对集合进行操作。

四种集合嵌套代码体现：

1：

　public static void main(String[] args) {
      　　　　　　  HashMap<String, HashMap<Person,String>> map
       　　　　　　 =new HashMap<String, HashMap<Person,String>>();
        　　　　　　//创建2个小map
       　　　　　　  HashMap<Person,String> java0803=new  HashMap<Person,String>();
        　　　　　　 HashMap<Person,String> java0903=new  HashMap<Person,String>();
        　　　　　　 java0803.put(new Person("小红帽",18), "山东淄博");
        　　　　　　 java0803.put(new Person("大灰狼",18), "山东济南");
       　　　　　　  java0903.put(new Person("小白兔",20), "山东淄博");
        　　　　　　 java0903.put(new Person("派大星",21), "山东济南");
      　　　　　　   map.put("java0803", java0803);
       　　　　　　  map.put("java0903", java0903);
        　　　　　　 Set<String> bigKeys=map.keySet();
         　　　　　　for(String bigkey:bigKeys){
            　　　　 HashMap<Person,String> smallMap=map.get(bigkey);
            　　　　　　 Set<Person> smallkeys=smallMap.keySet();
              　　　　   for(Person skey:smallkeys){
                   　　　　  String svalue=smallMap.get(skey);
                  　　   System.out.println(bigkey+"..."+skey+"..."+svalue);
               　　　　  }
           　　　　  }
       　　　　　　  }

2：

　public static void main(String[] args) {
    　　　　    HashMap<String, HashMap<Person,String>> map
       　　　　 =new HashMap<String, HashMap<Person,String>>();
        　　　　 HashMap<Person,String> java0803=new  HashMap<Person,String>();
      　　　　   HashMap<Person,String> java0903=new  HashMap<Person,String>();
       　　　　  java0803.put(new Person("小红帽",18), "山东淄博");
       　　　　  java0803.put(new Person("大灰狼",18), "山东济南");
       　　　　  java0903.put(new Person("小白兔",20), "山东淄博");
      　　　　   java0903.put(new Person("派大星",21), "山东济南");
        　　　　 map.put("java0803", java0803);
       　　　　  map.put("java0903", java0903);
         　　　　Set<String> bigkeys=map.keySet();
       　　　　  Iterator<String> it=bigkeys.iterator();
        　　　　 while(it.hasNext()){
            　　　　 String bigkey=it.next();
             　　　　HashMap<Person,String> smallmap=map.get(bigkey) ;
           　　　　  Set<Person> skeys=smallmap.keySet();
            　　　　 Iterator<Person> itt=skeys.iterator();
             　　　　while(itt.hasNext()){
             　　   　　 Person skey=itt.next();
                　　　　 String svalue=smallmap.get(skey);
                 　　　　System.out.println(bigkey+"..."+skey+"..."+svalue);
          　　　　   }
      　　　　   }
  　　　　　　  }

3：

　Set<Map.Entry<String, HashMap<Person,String>>> bigentrys=
            　　 map.entrySet();
         　　   for(Map.Entry<String, HashMap<Person,String>> bigentry:bigentrys){
             　　String bigkey=bigentry.getKey();
           　　  HashMap<Person,String> smallMap=bigentry.getValue();
          　　   Set<Map.Entry<Person, String>> sentrys=smallMap.entrySet();
            　　 for(Map.Entry<Person, String> sentry:sentrys){
            　　  Person skey=sentry.getKey();
                　 String svalue=sentry.getValue();
                　 System.out.println(bigkey+"..."+skey+"..."+svalue);
           　　  }
      　　   }
  　　　　  }

 Set<Map.Entry<String, HashMap<Person,String>>> bigkeys
       　　　　  =map.entrySet();
        　　　　 Iterator<Map.Entry<String, HashMap<Person,String>>> it=
                　　 bigkeys.iterator();
        　　　　 while(it.hasNext()){
           　　　　  Map.Entry<String, HashMap<Person,String>> bigenrys=it.next();
           　　　　  String bigkey=bigenrys.getKey();
            　　　　 HashMap<Person,String> smallMap=bigenrys.getValue();
            　　　　 Set<Map.Entry<Person,String>> sentrys=smallMap.entrySet();
           　　　　  Iterator<Map.Entry<Person,String>> itt=sentrys.iterator();
            　　　　 while(itt.hasNext()){
                 　　　　Map.Entry<Person,String> sentry=itt.next();
               　　　　  Person skey=sentry.getKey();
               　　　　  String svalue=sentry.getValue();
               　　　　  System.out.println(bigkey+"..."+skey+"..."+svalue);
          　　　　   }
        　　　　 }
　　　　　　    }

posted @ 2020-10-14 19:19 马雪峰1 阅读(128) 评论(0) 收藏举报

刷新页面返回顶部

Map接口，静态导入，可变参数，Collections集合工具类

公告