zoukankan      html  css  js  c++  java
  • Java Map操作

    Map:键必须是唯一

    同步方法:Map m = Collections.synchronizedMap(new TreeMap(...));

    Hashtable:基于散列表的实现  允许空键空值  线程安全

    HashMap:基于散列表的实现  允许空键空值  线程不安全  (与Hashtable基本一致)

    TreeMap: 基于红黑树数据结构的实现  不允许空键空值  线程不安全

    WeakHashMap:改进的HashMap,它对key实行“弱引用”,如果一个key不再被外部所引用,那么该key可以被GC回收。

    在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们的效率更高。

     HashTable:

    import java.util.Hashtable;
    
    public class Main {
    
        public static void main(String[] args) {
            Hashtable ht = new Hashtable();
            ht.put(new A(60000) , "11");
            ht.put(new A(87563) , "22");
            ht.put(new A(1232) , new B());
            System.out.println(ht);
    
            //只要两个对象通过equals比较返回true,
            //Hashtable就认为它们是相等的value。
            //由于Hashtable中有一个B对象,
            //它与任何对象通过equals比较都相等,所以下面输出true。
            System.out.println(ht.containsValue("测试字符串"));  ////只要两个A对象的count相等,它们通过equals比较返回true,且hashCode相等
            //Hashtable即认为它们是相同的key,所以下面输出true。
            System.out.println(ht.containsKey(new A(87563)));   ////下面语句可以删除最后一个key-value对
            ht.remove(new A(1232));    ////通过返回Hashtable的所有key组成的Set集合,
            //从而遍历Hashtable每个key-value对
            for (Object key : ht.keySet())
            {
                System.out.print(key + "---->");
                System.out.print(ht.get(key) + "
    ");
            }
        }
    }
    class A
    {
        int count;
        public A(int count)
        {
            this.count = count;
        }
        //根据count的值来判断两个对象是否相等。
        public boolean equals(Object obj)
        {
            if (obj == this)
                return true;
            if (obj!=null &&
                    obj.getClass()==A.class)
            {
                A a = (A)obj;
                return this.count == a.count;
            }
            return false;
        }
        //根据count来计算hashCode值。
        public int hashCode()
        {
            return this.count;
        }
    }
    class B
    {
        //重写equals()方法,B对象与任何对象通过equals()方法比较都相等
        public boolean equals(Object obj)
        {
            return true;
        }
    }
    {com.company.A@ea60=11, com.company.A@1560b=22, com.company.A@4d0=com.company.B@5451c3a8}
    true
    true
    com.company.A@ea60---->11
    com.company.A@1560b---->22
    View Code

    LinkedHashMap:

    import java.util.LinkedHashMap;
    public class Main {
    
        public static void main(String[] args) {
            LinkedHashMap scores = new LinkedHashMap();
            scores.put("语文" , 80);
            scores.put("英文" , 82);
            scores.put("数学" , 76);
            //遍历scores里的所有的key-value对
            for (Object key : scores.keySet())
            {
                System.out.println(key + "------>" + scores.get(key));
            }
        }
    }
    语文------>80
    英文------>82
    数学------>76
    View Code

    Properties:

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.util.Properties;
    
    public class Main {
        public static void main(String[] args) {
            try {
                Properties props = new Properties();
                //向Properties中增加属性
                props.setProperty("username", "yeeku");
                props.setProperty("password", "123456");
    
                //将Properties中的key-value对保存到a.ini文件中
                props.store(new FileOutputStream("a.ini"), "comment line");   ////新建一个Properties对象
                Properties props2 = new Properties();
                //向Properties中增加属性
                props2.setProperty("gender", "male");
    
                //将a.ini文件中的key-value对追加到props2中
                props2.load(new FileInputStream("a.ini"));    //
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    #comment line
    #Thu Nov 10 13:45:53 CST 2016
    password=123456
    username=yeeku
    View Code

    会在项目根目录生成一个a.ini文件

    import java.io.File;
    import java.io.IOException;
    import java.io.PrintStream;
    import java.util.Properties;
    
    public class Main {
        public static void main(String[] args) {
            Properties p = new Properties();
            p.setProperty("id","dean");
            p.setProperty("password","123456");
            System.out.println(p);
            try{
                PrintStream fW = new PrintStream(new File("d:\test1.properties"));
                p.list(fW );
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
    View Code
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.util.Properties;
    
    public class Main {
        public static void main(String[] args) {
            try {
                Properties prop = new Properties();// 属性集合对象
                FileInputStream fis = new FileInputStream("prop.properties");// 属性文件输入流
                prop.load(fis);// 将属性文件流装载到Properties对象中
                fis.close();// 关闭流
    
                // 获取属性值,sitename已在文件中定义
                System.out.println("获取属性值:sitename=" + prop.getProperty("sitename"));
                // 获取属性值,country未在文件中定义,将在此程序中返回一个默认值,但并不修改属性文件
                System.out.println("获取属性值:country=" + prop.getProperty("country", "中国"));
    
                // 修改sitename的属性值
                prop.setProperty("sitename", "Boxcode");
                // 添加一个新的属性studio
                prop.setProperty("studio", "Boxcode Studio");
                // 文件输出流
                FileOutputStream fos = new FileOutputStream("prop.properties");
                // 将Properties集合保存到流中
                prop.store(fos, "Copyright (c) Boxcode Studio");
                fos.close();// 关闭流
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
    }

    TreeMap:

    import java.util.TreeMap;
    
    public class Main {
    
        public static void main(String[] args) {
            TreeMap tm = new TreeMap();
            tm.put(new R(3) , "11");
            tm.put(new R(-5) , "22");
            tm.put(new R(9) , "33");
    
            System.out.println(tm);
    
            //返回该TreeMap的第一个Entry对象
            System.out.println(tm.firstEntry());
    
            //返回该TreeMap的最后一个key值
            System.out.println(tm.lastKey());
    
            //返回该TreeMap的比new R(2)大的最小key值。
            System.out.println(tm.higherKey(new R(2)));
    
            //返回该TreeMap的比new R(2)小的最大的key-value对。
            System.out.println(tm.lowerEntry(new R(2)));
    
            //返回该TreeMap的子TreeMap
            System.out.println(tm.subMap(new R(-1) , new R(4)));
        }
    }
    class R implements Comparable
    {
        int count;
        public R(int count)
        {
            this.count = count;
        }
        public String toString()
        {
            return "R[count:" + count + "]";
        }
        //根据count来判断两个对象是否相等。
        public boolean equals(Object obj)
        {
            if (this == obj)
                return true;
            if (obj!=null && obj.getClass()==R.class)
            {
                R r = (R)obj;
                return r.count == this.count;
            }
            return false;
        }
        //根据count属性值来判断两个对象的大小。
        public int compareTo(Object obj)
        {
            R r = (R)obj;
            return count > r.count ? 1 : count < r.count ? -1 : 0;
        }
    }
    {R[count:-5]=22, R[count:3]=11, R[count:9]=33}
    R[count:-5]=22
    R[count:9]
    R[count:3]
    R[count:-5]=22
    {R[count:3]=11}
    View Code
    Set和Map的关系十分密切,java源码就是先实现了HashMap、TreeMap等集合,然后通过包装一个所有的value都为null的Map集合实现了Set集合类

    WeakHashMap:
    import java.util.WeakHashMap;
    
    public class Main {
    
        public static void main(String[] args) {
            WeakHashMap whm = new WeakHashMap();
            //将WeakHashMap中添加三个key-value对,
            //三个key都是匿名字符串对象(没有其他引用)
            whm.put(new String("语文") , new String("良好"));
            whm.put(new String("数学") , new String("及格"));
            whm.put(new String("英文") , new String("中等"));
    
            //将WeakHashMap中添加一个key-value对,
            //该key是一个系统缓存的字符串对象。"java"是一个常量字符串强引用
            whm.put("java" , new String("中等"));
            //输出whm对象,将看到4个key-value对。
            System.out.println(whm);
            //通知系统立即进行垃圾回收
            System.gc();
            System.runFinalization();
            //通常情况下,将只看到一个key-value对。
            System.out.println(whm);
        }
    }
    {英文=中等, java=中等, 数学=及格, 语文=良好}
    {java=中等}
    View Code

    如果需要使用WeakHashMap的key来保留对象的弱引用,则不要让key所引用的对象具有任何强引用,否则将失去使用WeakHashMap的意义

    IdentityHashMap:

    import java.util.IdentityHashMap;
    public class Main {
    
        public static void main(String[] args) {
            IdentityHashMap ihm = new IdentityHashMap();
            //下面两行代码将会向IdentityHashMap对象中添加两个key-value对
            ihm.put(new String("语文") , 89);
            ihm.put(new String("语文") , 78);
            System.out.println(ihm);
            //下面两行代码只会向IdentityHashMap对象中添加一个key-value对
            ihm.put("java" , 93);
            ihm.put("java" , 98);
            System.out.println(ihm);
        }
    }
    {语文=89, 语文=78}
    {语文=89, java=98, 语文=78}
    View Code

    EnumMap:

    import java.util.EnumMap;
    public class Main {
    
        public static void main(String[] args) {
            //创建一个EnumMap对象,该EnumMap的所有key
            //必须是Season枚举类的枚举值
            EnumMap enumMap = new EnumMap(Season.class);
            enumMap.put(Season.SUMMER , "夏日炎炎");
            enumMap.put(Season.SPRING , "春暖花开");
            System.out.println(enumMap);
        }
    }
    enum Season
    {
        SPRING,SUMMER,FALL,WINTER
    }
    {SPRING=春暖花开, SUMMER=夏日炎炎}
    View Code

    与创建普通Map有所区别的是,创建EnumMap是必须指定一个枚举类,从而将该EnumMap和指定枚举类关联起来

    Map集合类的编程应用场景:

    1) HashMap和Hashtable的效率大致相同,因为它们的实现机制几乎完全一样。但HashMap通常比Hashtable要快一点,因为Hashtable需要额外的线程同步控制
    2) TreeMap通常比HashMap、Hashtable要慢(尤其是在插入、删除key-value对时更慢),因为TreeMap底层采用红黑树来管理key-value对
    3) 使用TreeMap的一个好处就是: TreeMap中的key-value对总是处于有序状态,无须专门进行排序操作

    http://www.cnblogs.com/LittleHann/p/3690187.html

    http://blog.csdn.net/speedme/article/details/22398395

  • 相关阅读:
    MySQL不支持的特性
    MySQL查询执行路径
    MySQL索引
    索引的选择性
    MySQL学习笔记_时间,多表更新,数据库元数据
    PowerDesigner 小技巧
    linux下清空文件内容
    mysql跟踪sql
    Navicat For Mysql快捷键
    PHP 配置多站点多目录
  • 原文地址:https://www.cnblogs.com/hongdada/p/6049911.html
Copyright © 2011-2022 走看看