精华内容
下载资源
问答
  • HashMap操作

    2017-12-14 21:48:04
    有段时间没写java代码,竟然有些生疏,整理一些HashMap操作 Map map = new HashMap(); map.put("1", "a"); map.put("2", "b"); map.put("3", "c"); // 遍历map的第一种方式 Set> entry = map.entrySet...

    有段时间没写java代码,竟然有些生疏,整理。

    1、HashMap操作

    		Map<String, String> map = new HashMap();
    
    		map.put("1", "a");
    		map.put("2", "b");
    		map.put("3", "c");
    		// 遍历map的第一种方式
    		Set<Map.Entry<String, String>> entry = map.entrySet();
    		Iterator<Map.Entry<String, String>> ite = entry.iterator();
    		while (ite.hasNext()) {
    			Map.Entry<String, String> en = ite.next();
    			System.out.println(en.getKey() + " --> " + en.getValue());
    		}
    		// 遍历map的第二种方式
    		for (Map.Entry<String, String> en : map.entrySet()) {
    			System.out.println(en.getKey() + " --> " + en.getValue());
    		}
    
    		// 获得所有key的集合
    		Set<String> keys = map.keySet();
    		Iterator<String> it = keys.iterator(); // 获得key的迭代器
    		while (it.hasNext()) {
    			String key = it.next(); // 迭代器是key的迭代器
    		}
    		// 获得所有的值values-->返回值为List
    		for (String value : map.values()) {
    			System.out.println(value);
    		}
    		// 该方法不正确,会报错
    		// ArrayList<String> ls= (ArrayList<String>) map.values();
    		// 如下正解
    		List<String> ls = new ArrayList<String>(map.values());
    		//常用方法
    		System.out.println(map.containsKey("1"));//是否包含键
    		System.out.println(map.containsValue("a"));//是否包含值
    		Map<String, String> map2 = new HashMap(map);/2、

    2、将一个set转化为List的两种方式

    		 //构造一个set
    		 Set<String> set=new HashSet<>();
    		 set.add("z");
    		 set.add("z");
    		 set.add("a");
    		 set.add("f");
    		 //方法一
    		 List<String> ll=new ArrayList<>();
    		 if(set!=null && !set.isEmpty()) {
    			 for(Iterator<String> iterator=set.iterator();iterator.hasNext();) {
    				 String data=iterator.next();
    				 if(data!=null) {
    					 ll.add(data);
    				 }
    			 }
    		 }
    		 //方法二:将一个set转为List
    		 List<String> ls=new ArrayList<>(set);
    		 System.out.println(ls);

    3、List排序与二分查找

    	      String aggAlgo = "SRC,DST;RULE group";  
    	      //数组转集合
    	      List<String> ls = new ArrayList<>(Arrays.asList(aggAlgo.toLowerCase().split(",|;| ")));// split的切割可以根据多个条件进行切割
    	      //集合->数组 
    	      //String arr[] = ls.toArray(new String[ls.size()]);  
    	      Collections.sort(ls);// 自然顺序排序  
    	      //Collections.reverse(ls); //降序  
    	      int num = Collections.binarySearch(ls, "rule");// 二分查找  
    	      List<String> ls2 = new ArrayList<>(ls);// 将list赋值为另一个list  

    4、List去重

    方法一:使用stream流

    List lst1=ls.stream().distinct().collect(Collectors.toList());
    方法二:使用利用set

    List lst2=new ArrayList(new HashSet(ls));
    用到了List的构造方法: List<String> ls=new ArrayList<>(set);
    5、获得两个List中差集

    		// 集合去重  
    		List<String> ls1 = new ArrayList<>();  
    		ls1.add("a");  
    		ls1.add("b");  
    		ls1.add("c");  
    		  
    		List<String> ls2 = new ArrayList<>();  
    		ls2.add("a");  
    		ls2.add("b");  
    		ls2.add("c");  
    		ls2.add("d");  
    		// 是否存在ls1完全包含ls2的情况  
    		boolean exist = ls1.containsAll(ls2);  
    		if (!exist) {  
    		    ls2.removeAll(ls1);  
    		}  
    		System.out.println(ls1);//a b c
    		System.out.println(ls2);// d  






    展开全文
  • HashMap操作自用笔记

    2020-10-22 14:36:33
    HashMap<String, String> map = new HashMap(); 2、赋值 map.put("Tony", "156213"); 3、根据key取value String value = map.get("Tony"); 4、遍历 for(String key:map.keySet()){ String value = map.get...

    1、 创建

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

    2、赋值

    map.put("Tony", "156213");
    

    3、根据key取value

    String value = map.get("Tony");
    

    4、遍历

    for(String key:map.keySet()){
    	String value = map.get(key);
    }
    

    5、

    
    
    展开全文
  • Java:HashMap操作练习

    2018-12-06 23:08:12
    HashMap是HashTable的兄弟,继承AbstractMap,实现Cloneable/Serializable接口。AbstractMap又是Map的实现。 HashMap是通过计算存储对象的哈希值,以键值Entry数组来散列存储对象。 如果存储遇到哈希碰撞,新建一...

    HashMap是HashTable的兄弟,继承AbstractMap,实现Cloneable/Serializable接口。AbstractMap又是Map的实现。

    HashMap是通过计算存储对象的哈希值,以键值Entry数组来散列存储对象。
    如果存储遇到哈希碰撞,新建一个Node类,以旧键值对为头部,从尾部插入新键值对。
    如果链表的长度大于8,则该链表转换成红黑树存储碰撞键值对。(JDK 1.8)

    HashMap的容量总是2的次幂,在能估算需要容量的情况下,赋予接近并大于(容量*1.333)的2次幂大小为优

    本练习实现:
    创建HashMap插入数据,检查长度,清除数据
    遍历HashMap的4种方法
    1.for each entry:entrySet
    2.while iterator of entrySet hasNext
    3.for each key:keySet
    4.for each value:values
    浅拷贝
    1.HashMap.clone()
    2.HashMap.putAll(Map<K,T>)
    深拷贝
    1.HashMapPrac.cloneDeep()
    2.for each new entry put(map.entry.getKey(),new List(listOrigin))

    结论:

    1. HashMap的浅拷贝里Copied EntrySet()地址与Original EntrySet()不同
      所以直接修改EntrySet里的key或者value指向是没问题的。
    2. 如果Map存的是基本类型的包装类或者String,浅拷贝和深拷贝没区别
    3. 浅拷贝的真正的问题在于修改value或者key指向的,对象(比如一个List)的指向地址,会改变前者指向的地址从而产生意想不到的结果。
    import java.util.*;
    import java.io.*;
    
    /*
     * This class is meant to practise implementing the API of HashMap
     */
    public class HashMapPrac{
    
      public static void main(String[] args){
    
        //1. instantiate a hashmap with default constructor
        // then put some data
        print("==========1==========");
        var hashMap = new HashMap<String,String>();
        print(hashMap.isEmpty());//true
        hashMap.put("No.1","Oliver");//add data
        hashMap.put("No.2","Kimiko");
        hashMap.put("No.3","Matthew");
        hashMap.put("No.4","Andrew");
        print(hashMap.isEmpty());//false
        print(hashMap.size()); //4
        print(hashMap); //@override AbstractMap.toString()
    
        //2. get a shallow copy of this hashmap
        // then remove all of the mappings
        print("==========2==========");
        var hashMapCopyS = (HashMap)hashMap.clone();
        print(hashMapCopyS.size());//4
        print(hashMapCopyS);
        hashMapCopyS.clear();
        print(hashMapCopyS.size());//0
    
    
    
        //3. is there a mapping value for No.1? Is there a key mapping to Oliver?
        print("==========3==========");
        print(hashMap.containsKey("No.1"));//true
        print(hashMap.containsValue("Oliver"));//true
    
        //4. create a new hashMap, add 10 Integer pair to it
        //make sure value = 10*key
        //print the pairs where values < 50
        print("==========4==========");
        var map = new HashMap<Integer,Integer>();
        for(int i=1;i<=10;i++){
          map.put(i,i*10);
        }
        //for each entry of entrySet()
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
          if (entry.getValue()<50){
            print("Key: "+entry.getKey()+" Value: "+entry.getValue());
          }
        }
    
        print("");
    
        //while iterator of entrySet hasNext()
        Iterator iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
          var entry = (Map.Entry<Integer,Integer>)iterator.next();
          if (entry.getValue()<50){
            print("Key: "+entry.getKey()+" Value: "+entry.getValue());
          }
        }
    
        print("");
    
        //for each key of keySet()
        for(Integer key:map.keySet()){
          if(map.get(key)<50){
            print("Key: "+key+" Value "+map.get(key));
          }
        }
    
        //5.print only the value of map where value <50
        print("==========5==========");
    
        for (Integer value:map.values()){
          if(value<50){
            print("Value: "+value);
          }
        }
    
        //6.get a deep copy of hashmap(Integer,ArrayList<T>)
        print("==========6==========");
    
        //create the original hashmap
        var list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        var mapOrigin = new HashMap<Integer,ArrayList<Integer>>();
        mapOrigin.put(1,list);
        //copy the original hashmap
        var mapCopyDeep = new HashMap<Integer,ArrayList<Integer>>();
        for (Map.Entry<Integer,ArrayList<Integer>> entry:mapOrigin.entrySet()){
          mapCopyDeep.put(entry.getKey(),new ArrayList<Integer>(entry.getValue()));
        }
    
        //check if the values are pointing to the same list?
        print(mapOrigin.get(1)==mapCopyDeep.get(1)); //false
    
        // try copy using HashMap.putAll(Map<? extends K,? extends V>)
        var mapCopy = new HashMap<Integer,ArrayList<Integer>>();
        mapCopy.putAll(mapOrigin);
        print(mapOrigin.get(1)==mapCopy.get(1)); //true, another shallow copy
    
        //7. get a deep copy of mapOrigin, assumed that you dont know the 
        //   classes of which entry key and value have
        print("==========7==========");
        mapCopy = cloneDeep(mapOrigin);
        print(mapCopy + "\n" + mapOrigin);
        print(mapOrigin.get(1)==mapCopy.get(1)); //false
    
    
    
      }
    
      /*
       *Dizzy Lazy Fussy Busy
       */
      public static void print(Object obj){
        System.out.println(obj);
      }
    
      /*
       * Deep copy T of which extends Serializable
       */
       public static <T extends Serializable> T cloneDeep(T obj){
    
         T clonedObj = null;
         try{
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
           ObjectOutputStream oos = new ObjectOutputStream(baos);
           oos.writeObject(obj);
           oos.close();
    
           ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
           ObjectInputStream ois = new ObjectInputStream(bais);
           clonedObj = (T)ois.readObject();
           ois.close();
         }catch(Exception e){
           e.printStackTrace();
         }
         return clonedObj;
       }
    }
    

    输出:

    ==========1==========
    true
    false
    4
    {No.2=Kimiko, No.1=Oliver, No.4=Andrew, No.3=Matthew}
    ==========2==========
    4
    {No.2=Kimiko, No.1=Oliver, No.4=Andrew, No.3=Matthew}
    0
    ==========3==========
    true
    true
    ==========4==========
    Key: 1 Value: 10
    Key: 2 Value: 20
    Key: 3 Value: 30
    Key: 4 Value: 40
    
    Key: 1 Value: 10
    Key: 2 Value: 20
    Key: 3 Value: 30
    Key: 4 Value: 40
    
    Key: 1 Value 10
    Key: 2 Value 20
    Key: 3 Value 30
    Key: 4 Value 40
    ==========5==========
    Value: 10
    Value: 20
    Value: 30
    Value: 40
    ==========6==========
    false
    true
    ==========7==========
    {1=[1, 2, 3]}
    {1=[1, 2, 3]}
    false
    
    展开全文
  • name:a1 age:20 name:a4 age:18 name:a2 age:22 name:a3 age:24
  • HashMap操作例子

    2009-02-01 14:53:18
    Map map = new HashMap(); map.put("userName", "peter"); map.put("useremail", "aaa@163.com"); map.put("usersex", "男"); Iterator it...
    private void testHashMap() throws Exception {
    		Map map = new HashMap();
    		map.put("userName", "peter");
    		map.put("useremail", "aaa@163.com");
    		map.put("usersex", "男");
    
    		Iterator it = map.keySet().iterator();
    		Iterator myvalues = map.values().iterator();
    		while (it.hasNext()) {
    			Object key = it.next();
    			Object value = myvalues.next();
    			System.out.print("key=" + key.toString() + ",");
    			System.out.println("next=" + value.toString());
    		}
    	}
     
    展开全文
  • 死锁 导致CPU 100%!
  • import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; ...
  • HashMap CRUD操作

    2017-05-10 14:39:24
    HashMap实现对产品的CRUD操作,和适合初学者研究。
  • hashMap实现原理

    万次阅读 多人点赞 2019-07-31 18:35:50
    此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。 2. HashMap的数据结构:  在java编程语言中,最基本的结构就是两种,一...
  • hashmap内部操作

    2018-11-17 00:36:54
    由此可以看到,当在实例化HashMap实例时,如果给定了initialCapacity,由于HashMap的capacity都是2的幂,因此这个方法用于找到大于等于initialCapacity的最小的2的幂(initialCapacity如果就是2的幂,则返回的还是这...
  • Hashmap常用操作

    千次阅读 2014-08-11 10:37:03
    HashMap hm = new HashMap(); //插入数据 hm.put("a1", "gogogo"); hm.put("a2", "exexex"); //覆盖数据 hm.put("a1", "sim"); //输出key对应的value值 System.out.println(hm.get("a1")); //判断...
  • HashMap的基本操作

    2020-04-08 20:25:09
    HashMap的基本操作HashMap是基于hash算法的图,是一个数据结构标题数据结构有:线性结构(数列表List、队列、栈...)、树(二叉树、B树...)、堆、图Hash算法Hash算法特点作用HashMap特点HashMap类中几个重要的属性...
  • Java的HashMap基本操作

    2021-02-05 00:48:23
    HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。 HashMap 实现了 Map 接口,根据键的 HashCode 值存储数据,具有很快的访问速度...HashMap类常用操作 方法 功能 描述 put() 将键/值对添加到 hash
  • HashMap

    2020-12-22 04:08:43
    HashMap 在 JDK 1.7 中 HashMap 是以数组加链表的形式组成的,...JDK 1.8 之所以添加红黑树是因为一旦链表过长,会严重影响 HashMap 的性能,而红黑树具有快速增删改查的特点,这样就可以有效的解决链表过长时操作比较
  • HashMap的put操作

    2019-12-31 10:31:13
    1、HashMap的put操作(基于JDK1.7) 问题1:初始化主要包括哪些操作? 问题2:计算key的hash值? 问题3:计算桶的位置? 问题4:插入当前key和value?扩容?扩容安全吗,原因是什么? 问题5:对比JDK1.7和JDK...
  • HashMap进行排序操作

    2019-11-22 18:07:24
    HashMap进行排序操作 2018-08-28 00:13:59KyleWong123 HashMap本身是无序的,因此要对HashMap进行排序,就要依赖其他的类,比如LinkedHashMap,因为该类的底层是链表,是有序的,所以可以返LinkedHashMap来...
  • HashMap的各种操作

    2019-12-15 11:31:36
    import java.util.HashMap; public class Demo06HashMap { public static void main(String[] args){ HashMap map=new HashMap<>(); map.put(“siki”, 56);//key不可重复,value可重复 map.put(“sik”,...
  • Javascript实现和操作HashMap,压缩包里面有hashmap定义和操作的例子
  • HashMap的同步操作

    2019-09-19 23:52:03
    HashMap是大家很常用的一个Map,所以都认为他是很好用的一个Map,也就不去想他是否存在一些不合理的地方,像我刚刚看到这个错误的时候,我也是直接忽略掉,但是根据后来的详细了解,发现了HashMap的一些问题,在一些情况下...
  • HashMap特点和常用操作

    2019-12-17 22:48:59
    HashMap特点和常用操作一、在线API二、特点三、基本操作1.创建HashMap2.访问HashMap3.for 遍历4.forEach 遍历 一、在线API 在线API 二、特点 HashMap存储键值对,元素(key)不能重复; HashMap不维护顺序; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,281
精华内容 4,512
关键字:

hashmap操作