思路是这样的：           建立一个类 ，里面封装一个Map集合，然后将类单例化，通过另一个函数调用类的getInstance方法，往Map里面添加元素，实现类似数据添加的方法，但是为什么我这个代码getInstance多次调用获得不是同一个对象呢... 是我对单例的理解有问题还是代码有问题 ，请各位大神指导下~

1. class SQL
   
2. {
   
3.         private static Map<String,Hero> sql = new HashMap<String ,Hero>();
   
4.         private SQL(){}
   
5.         private static SQL Sql = new SQL();
   
6.         public  static SQL getInstance()
   
7.         {
   
8.                 return Sql;
   
9.         }
   
10.         
    
11.         public static boolean addSQL(String name,Hero h)
    
12.         {
    
13.                 if (sql.containsKey(name))
    
14.                         return false;
    
15.                 sql.put(name,h);
    
16.                 return true;
    
17.         }
    
18.         public static void printSQL()
    
19.         {
    
20.                 Iterator<Map.Entry<String,Hero>> it= sql.entrySet().iterator();
    
21.                 while (it.hasNext())
    
22.                 {
    
23.                         Map.Entry<String,Hero> me = it.next();
    
24.                         System.out.println(me.getValue().name);
    
25.                 }
    
26.         }
    
27.         
    
28. }
    

复制代码

每次调用类中的addSQL方法之后里面的元素总是刚添加的那个，不管调用多少次，为什么啊？？
我想实现可以多次往里面添加元素，实现类似数据库的方法，怎么实现呢？

刚用楼主的代码测试了一下，所有添加的元素都在啊，没有问题。

1. import java.util.*;
   
2. class SQL
   
3. {
   
4.         private static Map<String,String> sql = new HashMap<String ,String>();
   
5.         private SQL(){}
   
6.         private static SQL Sql = new SQL();
   
7.         public  static SQL getInstance()
   
8.         {
   
9.                 return Sql;
   
10.         }
    
11.         
    
12.         public static boolean addSQL(String name,String h)
    
13.         {
    
14.                 if (sql.containsKey(name))
    
15.                         return false;
    
16.                 sql.put(name,h);
    
17.                 return true;
    
18.         }
    
19.         public static void printSQL()
    
20.         {
    
21.                 Iterator<Map.Entry<String,String>> it= sql.entrySet().iterator();
    
22.                 while (it.hasNext())
    
23.                 {
    
24.                         Map.Entry<String,String> me = it.next();
    
25.                         System.out.println(me.getValue());
    
26.                 }
    
27.         }
    
28.         
    
29. }
    
30. public class SqlTest {
    
31.         public static void main(String[] args) {
    
32.                 // TODO Auto-generated method stub
    
33.                 //SQL s = SQL.getInstance();
    
34.                 SQL.addSQL("zhangsan", "1");
    
35.                 SQL.addSQL("lisi", "2");
    
36.                 SQL.addSQL("wangwu", "3");
    
37.                 SQL.printSQL();
    
38.                
    
39.         }
    
40. 
    
41. }

复制代码

...... 发表于 2013-10-17 16:53
刚用楼主的代码测试了一下，所有添加的元素都在啊，没有问题。

应该是你的24行代码有问题，我不知道你的Hero类怎么定义的，可能是你me.getValue().name得到的值都相同吧

...... 发表于 2013-10-17 16:53
刚用楼主的代码测试了一下，所有添加的元素都在啊，没有问题。

我知道在.. 但是你再添加一次呢 会发现之前添加的没有了  我想实现不断地往里面添加数据的功能

请你看看这个代码，你运行一下试试。


package com.itheima;

import java.util.*;

class SQL {
        private static Map<String, String> sql = new HashMap<String, String>();

        private SQL() {
        }

        private static SQL Sql = new SQL();

        public static SQL getInstance() {
                return Sql;
        }

        public boolean addSQL(String name, String h) {
                if (sql.containsKey(name))
                        return false;
                sql.put(name, h);
                return true;
        }

        public void printSQL() {
                Iterator<Map.Entry<String, String>> it = sql.entrySet().iterator();
                while (it.hasNext()) {
                        Map.Entry<String, String> me = it.next();
                        System.out.println(me.getKey()+":"+me.getValue());
                }
        }

}

public class SqlTest {
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                // SQL s = SQL.getInstance();
                SQL sql=SQL.getInstance();
                sql.addSQL("zhangsan", "1");
                sql.addSQL("lisi", "2");
                sql.addSQL("wangwu", "3");
                sql.printSQL();
               
                System.out.println("-----------------------");
               
                SQL sql2=SQL.getInstance();
                sql2.addSQL("wenbaoxing", "4");
                sql2.printSQL();
        }

}

hyz123456 发表于 2013-10-17 17:44
我知道在.. 但是你再添加一次呢 会发现之前添加的没有了  我想实现不断地往里面添加数据的功能 ...

不明白你的再添加是什么意思……难道是添加一次之后程序运行结束，然后再运行往里面添加？？

...... 发表于 2013-10-17 19:36
不明白你的再添加是什么意思……难道是添加一次之后程序运行结束，然后再运行往里面添加？？ ...

嗯  把前面的程序弄成一个数据库的意思
然后通过后面运行多个程序往里面添加内容

hyz123456 发表于 2013-10-17 20:35
嗯  把前面的程序弄成一个数据库的意思
然后通过后面运行多个程序往里面添加内容 ...

这样啊 ，那我感觉就不是单例的问题了，要用到IO，你要建一个文件，存储这些内容，然后每个程序运行一次就往里面存一次，用的时候在从这个文件里面读取出来就行了

hyz123456 发表于 2013-10-17 20:35
嗯  把前面的程序弄成一个数据库的意思
然后通过后面运行多个程序往里面添加内容 ...

这样啊 ，那我感觉就不是单例的问题了，要用到IO，你要建一个文件，存储这些内容，然后每个程序运行一次就往里面存一次，用的时候在从这个文件里面读取出来就行了

hyz123456 发表于 2013-10-17 20:35
嗯  把前面的程序弄成一个数据库的意思
然后通过后面运行多个程序往里面添加内容 ...

这样啊 ，那我感觉就不是单例的问题了，要用到IO，你要建一个文件，存储这些内容，然后每个程序运行一次就往里面存一次，用的时候在从这个文件里面读取出来就行了

hyz123456 发表于 2013-10-17 20:35
嗯  把前面的程序弄成一个数据库的意思
然后通过后面运行多个程序往里面添加内容 ...

这样啊 ，那我感觉就不是单例的问题了，要用到IO，你要建一个文件，存储这些内容，然后每个程序运行一次就往里面存一次，用的时候在从这个文件里面读取出来就行了

楼主你好，如果问题已解决请将帖子状态修改为提问结束，如果未解决请继续提问，谢谢合作
如果不会修改请看解释帖：http://bbs.itheima.com/thread-89313-1-1.html

楼主你好，如果问题已解决请将帖子状态修改为提问结束，如果未解决请继续提问，谢谢合作
如果不会修改请看解释帖：http://bbs.itheima.com/thread-89313-1-1.html