JavaSEDemo25Map

古城微笑少年丶 2021-09-25 07:50 230阅读 0赞

### 文章目录 ###

*  简介
 *  练习题
 *   *  练习1
     *  练习2
     *  练习3
     *  练习4
     *  练习5
     *  练习6
     *  练习7
     *  练习8
     *  练习9
 *  treeSet的ceiling、higher、remove、clear、forEach、iterator方法
 *  LinkedHashSet
 *  Map的本质
 *  Map常用方法
 *   *  put、putAll
     *  keySet、iterator、get()、entrySet、values、isEmpty、containsKey、containsValue
     *  注意:map.put(null,null);
 *  TreeMap的常用方法
 *   *  put方法
     *  put(对象)、keySet、iterator、entrySet
     *  ceilingKey、ceilingEntry
     *  containsKey、descendingMap、firstEntry、floorEntry、higherEntry、lowerEntry、navigableKeySet
 *  LinkedHashMap

# 简介 #

*  本文是2021/04/24整理的笔记
 *  赘述可能有点多，还请各位朋友耐心阅读
 *  本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进

# 练习题 #

## 练习1 ##

以下代码的执行结果是？【单项选择题】【简单】
    public class Example { 
    
     public static void main(String[] args) { 
      TreeSet<String> t = new TreeSet<String>();
      if (t.add("one"))
       if (t.add("two"))
        if (t.add("three"))
         t.add("four");
      for (String s : t) { 
       System.out.print(s);
      }
     }
    }
    A．one
    B．onethreetwo
    C．onetwothreefour
    D．fouronethreetwo

答案  
D

## 练习2 ##

现有：
    list是一个合法的集合引用，getCollection（）返回一个合法集合的引用，以下语句哪些是合法的？
    【多项选择题】【简单】
    A．for(Object o : list)
    B．for(Object o : getCollection())
    C．for(Object o : list.iterator())
    D．for(Iterator I;list.iterator();i.hasNext())

答案  
AB

## 练习3 ##

哪些集合是同步的？【多项选择题】【简单】
    A．TreeSet
    B．Hashtable
    C．Vector
    D．LinkedList

答案  
BC

## 练习4 ##

下列代码执行结果是？【简答题】【中等】
    class RectObject { 
     public int x;
     public int y;
    
     public RectObject(int x, int y) { 
      this.x = x;
      this.y = y;
     }
    
     @Override
     public int hashCode() { 
      final int prime = 31;
      int result = 1;
      result = prime * result + x;
      result = prime * result + y;
      return result;
     }
    
     @Override
     public boolean equals(Object obj) { 
      if (this == obj)
       return true;
      if (obj == null)
       return false;
      if (getClass() != obj.getClass())
       return false;
      final RectObject other = (RectObject) obj;
      if (x != other.x) { 
       return false;
      }
      if (y != other.y) { 
       return false;
      }
      return true;
     }
    }
    
    public class Example { 
     public static void main(String[] args) { 
      HashSet<RectObject> set = new HashSet<RectObject>();
      RectObject r1 = new RectObject(3, 3);
      RectObject r2 = new RectObject(5, 5);
      RectObject r3 = new RectObject(3, 6);
      set.add(r1);
      set.add(r2);
      set.add(r3);
      r3.y = 7;
      System.out.println("删除前的大小size:" + set.size());
      set.remove(r3);
      System.out.println("删除后的大小size:" + set.size());
     }
    }

答案  
删除前的大小size:3  
删除后的大小size:3

## 练习5 ##

题目  
Hashtable和HashMap的区别  
答案  
HashTable同步、HashMap不同步  
HashTable编译时可以放null，但是运行时会出空指针异常。  
HashMap可以用null作为一次键，值可以有多个null

## 练习6 ##

Vector、ArrayList、LinkedList的区别  
Vector 同步  
ArrayList不同步 数组 增删慢 查询快-  
LinkedList不同步 链表 增删快 查询慢

## 练习7 ##

题目  
List、Map、Set三个接口，存取元素时，各有什么特点  
答案  
List以特定索引来存取元素，可以有重复元素。Set不能存放重复元素（用对象的equals()方法来区分元素是否重复）。  
Map保存键值对映射，映射关系可以是一对一或多对一。  
Set和Map容器都有基于哈希存储和排序树的两种实现版本，基于哈希存储的版本理论存取时间复杂度为O(1)，而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键（key）构成排序树从而达到排序和去重的效果。

## 练习8 ##

public class Example { 
     public static void main(String[] args) { 
      List list = new ArrayList();
      list.add("a");
      list.add("b");
      list.add("c");
      List<Integer> intList = list;
      for (int i = 0; i < list.size(); i++) { 
       System.out.println(intList.get(i));
      }
     }
    }

## 练习9 ##

题目  
写一个类student,属性id,name,age,创建3个对象,分别使用内部比较器和外部比较器添加3个对象到TreeSet中,打印输出结果.

# treeSet的ceiling、higher、remove、clear、forEach、iterator方法 #

@Test
        public void testCeiling(){ 
            TreeSet<String> set = new TreeSet<>();
            set.add("a");
            set.add("b");
            set.add("c");
            set.add("cc");
            set.add("aa");
            set.add("bb");
            set.clear();
    
          /* 1. ceiling higher System.out.println("set = " + set); // String c = set.ceiling("c"); String c = set.higher("c"); System.out.println("c = " + c);*/
    
    
                   /* 2.remove boolean b = set.remove("b"); System.out.println("b = " + b); System.out.println("set = " + set);*/
    
           /* 3.clear set.clear(); System.out.println("set = " + set);*/
    
            /* 4.forEach for (String s : set) { System.out.println("s = " + s); } */
    
    
            /* 5.iterator Iterator<String> iterator = set.iterator(); while(iterator.hasNext()){ System.out.println("iterator.next() = " + iterator.next()); }*/
        }

# LinkedHashSet #

*  按照将元素插入到 set 中的顺序（插入顺序）进行迭代.
 *  特点:存入的顺序就是迭代的次序,但是可不是存储的顺序(存储使用 hashcode 存储的,是无续的)

# Map的本质 #

keySet：Set集合 无序 不可重复  
value:Collection集合 有序 可以重复

# Map常用方法 #

## put、putAll ##

import org.junit.Test;
    import java.util.*;
     @Test
        public void testHashMap(){ 
            HashMap<String,String> map = new HashMap<>();
            map.put("入云龙","公孙胜");
            map.put("及时雨","宋公明");
            map.put("花和尚","鲁智深");
            map.put(null,null);
            map.put("九纹龙",null);
            System.out.println("map = " + map);
    
            HashMap<String, String> map1 = new HashMap<>();
            map1.putAll(map);
            System.out.println("map1 = " + map1);
        }

## keySet、iterator、get()、entrySet、values、isEmpty、containsKey、containsValue ##

@Test
        public void testRemove(){ 
            HashMap<String,String> map = new HashMap<>();
            map.put("入云龙","公孙胜");
            map.put("及时雨","宋公明");
            map.put("花和尚","鲁智深");
    
            Set<String> keySet = map.keySet();
            for (String key : keySet) { 
                System.out.println(key + ":" + map.get(key));
            }
            Iterator<String> iterator = keySet.iterator();
            while(iterator.hasNext()){ 
                String key = iterator.next();
                System.out.println(key+ ": " + map.get(key));
            }
            /*for (String key : keySet) { System.out.println("key :" + key + ",value:" + map.get(key)); }*/
    /* Set<Map.Entry<String, String>> entrySet = map.entrySet(); for (Map.Entry<String, String> entry : entrySet) { System.out.println(entry.getKey() + ": " + entry.getValue()); }*/
            /*Collection<String> values = map.values(); for (String value : values) { System.out.println("value = " + value); }*/
            /*Set<String> keySet = map.keySet(); for (String key : keySet) { System.out.println("key = " + key); }*/
            /*System.out.println("map.isEmpty() = " + map.isEmpty()); String s = map.get("花和尚"); System.out.println("s = " + s); System.out.println("map.size() = " + map.size());*/
    
            /*String remove = map.remove("及时雨"); System.out.println("remove = " + remove); System.out.println("map = " + map); map.clear();*/
         /* boolean b = map.containsKey("入云龙"); System.out.println("b = " + b);*/
    
           /* boolean b = map.containsValue("鲁智深"); System.out.println("b = " + b); System.out.println("map = " + map);*/
        }

## 注意:map.put(null,null); ##

key只放一个null,value可以放多个null

# TreeMap的常用方法 #

## put方法 ##

@Test
        public void testAdd(){ 
            TreeMap<String, String> treeMap = new TreeMap<>();
            treeMap.put("c","鲁智深");
            treeMap.put("a","史进");
            treeMap.put("b","武松");
            System.out.println("treeMap = " + treeMap);
        }

## put(对象)、keySet、iterator、entrySet ##

@Test
        public void testAddPerson(){ 
            Person p1 = new Person("宋江", 30);
            Person p2 = new Person("卢俊义", 29);
            Person p3 = new Person("武大郎", 33);
    // TreeMap<Person, Double> treeMap = new TreeMap<>();
            TreeMap<Person, Double> treeMap = new TreeMap<>(new Comparator<Person>() { 
                @Override
                public int compare(Person o1, Person o2) { 
                    int i = o1.getAge() - o2.getAge();
                    int j = o1.getName().compareTo(o2.getName());
                    return i == 0 ? j:i;
                }
            });
            treeMap.put(p1,3000.0);
            treeMap.put(p2,3200.0);
            treeMap.put(p3,4000.0);
            treeMap.put(p3,5000.0);
            System.out.println("treeMap = " + treeMap);
            Double aDouble = treeMap.get(p1);
            System.out.println("aDouble = " + aDouble);
          /* for (Person key : treeMap.keySet()) { System.out.println( key+":"+treeMap.get(key)); }*/
         /* Iterator<Person> iterator = treeMap.keySet().iterator(); while(iterator.hasNext()){ Person next = iterator.next(); System.out.println("next = " + next); }*/
            Set<Map.Entry<Person, Double>> entrySet = treeMap.entrySet();
            for (Map.Entry<Person, Double> entry : entrySet) { 
                System.out.println(entry + ":" + entry.getValue());
            }
        }

## ceilingKey、ceilingEntry ##

@Test
        public void testAdd2(){ 
            TreeMap<String, String> treeMap = new TreeMap<>();
            treeMap.put("c","鲁智深");
            treeMap.put("a","史进");
            treeMap.put("d","武松");
            System.out.println("treeMap = " + treeMap);
          /* String s = treeMap.ceilingKey("b"); System.out.println("s = " + s);*/
    
            Map.Entry<String, String> entry = treeMap.ceilingEntry("b");
            System.out.println("entry = " + entry);
        }

## containsKey、descendingMap、firstEntry、floorEntry、higherEntry、lowerEntry、navigableKeySet ##

@Test
        public void testContainsKey(){ 
            TreeMap<String, String> treeMap = new TreeMap<>();
            treeMap.put("c","鲁智深");
            treeMap.put("a","史进");
            treeMap.put("d","武松");
    
    /* boolean b = treeMap.containsKey("a"); System.out.println("b = " + b);*/
      /* NavigableSet<String> keySet = treeMap.descendingKeySet(); System.out.println("keySet = " + keySet);*/
            /*NavigableMap<String, String> descendingMap = treeMap.descendingMap(); System.out.println("descendingMap = " + descendingMap);*/
           /* Map.Entry<String, String> firstEntry = treeMap.firstEntry(); System.out.println("firstEntry = " + firstEntry);*/
    
          /* Map.Entry<String, String> lastEntry = treeMap.lastEntry(); System.out.println("lastEntry = " + lastEntry);*/
    
            /*Map.Entry<String, String> entry = treeMap.floorEntry("b"); System.out.println("entry = " + entry);*/
    
    /* Map.Entry<String, String> entry = treeMap.higherEntry("b"); System.out.println("entry = " + entry);*/
    
           /* Map.Entry<String, String> entry = treeMap.lowerEntry("b"); System.out.println("entry = " + entry);*/
    
            NavigableSet<String> KeySet = treeMap.navigableKeySet();
            System.out.println("KeySet = " + KeySet);
        }

# LinkedHashMap #

与HashMap类似，只是按插入的顺序进行迭代。

@Test
        public void testAdd(){ 
            LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();
            linkedHashMap.put("入云龙","公孙胜");
            linkedHashMap.put("及时雨","宋公明");
            linkedHashMap.put("花和尚","鲁智深");
        }