java，单例模式的泛型类该怎么实现？

[Aswei]

rt。。
我想了好半天没办法解决，谁能给帮忙啊。。。

[kosora曹]

你说的这个是IOC

import java.util.HashMap;

class Hello{
	public void print(){
		System.out.println("HelloWorld!");
	}
}
public class SpringIoc {
public static HashMap<String,Object> contextmap=new HashMap<String,Object>();

/**
 * 初始化一个bean放到spring容器中
 */
public static void initBean(Class<?> clazz){
	try {
		Object obj = clazz.newInstance();
		contextmap.put(clazz.getSimpleName(), obj);
	} catch (Exception e) {
	} 
}
/**
 * 这是SpringIOC的核心方法
 * 参考:http://www.tuicool.com/articles/qYfYJ3E
 */
public static void componentScan(String packagePath){
	//扫描packagePath下的所有java文件及其子package，调用initBean()方法
}
public static void main(String[] args) {
	initBean(Hello.class);
	Hello he=(Hello) contextmap.get("Hello");
	he.print();
}
}

http://www.tuicool.com/articles/qYfYJ3E

[haimian88]

T t=new T() 这种是不行的 ，你可以通过工厂模式实现试试

[healer_kx]

Java不是C++，这种泛型没有太大的意义。

[oh_Maxy]

嗯，比如ArrayList<String>对象和ArrayList<Integer>对象，这两个应该无法做成同一个单例呢

[王飞2023]

https://github.com/faicm/king/blob/master/src/faicm/tools/util/Singleton.java 这个我有专门做过 ，楼主可以看一下：

package faicm.tools.util;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author faicm
 * 
 * 
 *         Sington.get(Person.class) will get sington new Person();
 * 
 * 
 *         if remove(Person.class) will get the other sington new Perso();
 *
 */
@SuppressWarnings("rawtypes")
public class Singleton {
	private static volatile HashMap<Class, Object> hashmap = new HashMap<Class, Object>();
	private static ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
	private static Lock rlock = rwlock.readLock();
	private static Lock wlock = rwlock.writeLock();

	public static Object get(Class c) {
		try {
			rlock.lock();
			if (hashmap.containsKey(c)) {
				return hashmap.get(c);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			rlock.unlock();

		}
		synchronized (c) {
			if (hashmap.containsKey(c)) {
				return hashmap.get(c);
			}
			try {
				Object o = c.newInstance();
				hashmap.put(c, o);
				return o;
			} catch (Exception e) {
				e.printStackTrace();
				return null;
			} finally {

			}
		}

	}

	public static void remove(Class c) {
		try {
			wlock.lock();
			synchronized (c) {
				hashmap.remove(c);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			wlock.unlock();
		}
	}

	public static void save(Object c) {
		try {
			synchronized (c.getClass()) {
				hashmap.put(c.getClass(), c);
			}
		} catch (Exception e) {
		} finally {
		}
	}

	public static void clear() {
		Set<Class> set = hashmap.keySet();
		Iterator<Class> i = set.iterator();
		while (i.hasNext()) {
			Class e = i.next();
			remove(e);
		}
		hashmap = new HashMap<Class, Object>();
	}
}

[疯狂熊猫人]

public class SingletonBuilder {

	@SuppressWarnings("rawtypes")
	private static final ConcurrentMap<Class, Singleton> map = new ConcurrentHashMap<>();
	
	@SuppressWarnings("unchecked")
	public static <E> Singleton<E> getSingleton(Class<E> type){
		Singleton<E> s = map.get(type);
		if(s==null){
			synchronized (map) {
				if((s = map.get(type))==null)
					map.put(type, s=new Singleton<>());
			}
		}
		return s;
	}
	public static class Singleton<E>{
		ArrayList<E> list = new ArrayList<>();
		private Singleton(){}
		
		@SuppressWarnings("unchecked")
		public E getData(){
			return (E) "123";
		}
		
		public boolean add(E e){
			return list.add(e);
		}
		
		public E get(int index){
			return list.get(index);
		}
	}
	
	public static void main(String[] args) {
		Singleton<String> single = SingletonBuilder.getSingleton(String.class);
		single.add("123");
		single.add("456");
		System.out.println(single.get(0));
		Singleton<Integer> single1 = SingletonBuilder.getSingleton(Integer.class);
		single1.add(1);
		single1.add(2);
		System.out.println(single1.get(0));
		
		Singleton<String> single2 = SingletonBuilder.getSingleton(String.class);
		single2.add("aa");
		single2.add("bb");
		System.out.println(single2.get(3));
	}
}

[engourdi]

引用 4 楼 oh_Maxy 的回复:

嗯，比如ArrayList<String>对象和ArrayList<Integer>对象，这两个应该无法做成同一个单例呢

确实，机制决定啦

[日知己所无]

暂时没想明白，实现出来的话，会在什么情况下使用？

[Inhibitory]

public class Test {
    public static <T> T getInstance(String qualifiedClassName) throws Exception {
        Class clazz = Class.forName(qualifiedClassName);

        return (T) clazz.newInstance();
    }

    public static void main(String[] args) throws Exception {
        Foo foo = getInstance("Foo"); // 根据左值就能自动判断类型
        foo.go();

        Bar bar = getInstance("Bar"); // 根据左值就能自动判断类型
        bar.go();
    }
}

class Foo {
    public void go() {
        System.out.println("Foo.go()");
    }
}

class Bar {
    public void go() {
        System.out.println("Bar.go()");
    }
}

输出:

Foo.go()
Bar.go()

[bigsnow]

大哥，你这个哪都好，就是不是singleton

引用 10 楼 Inhibitory 的回复:

public class Test {
    public static <T> T getInstance(String qualifiedClassName) throws Exception {
        Class clazz = Class.forName(qualifiedClassName);

        return (T) clazz.newInstance();
    }

    public static void main(String[] args) throws Exception {
        Foo foo = getInstance("Foo"); // 根据左值就能自动判断类型
        foo.go();

        Bar bar = getInstance("Bar"); // 根据左值就能自动判断类型
        bar.go();
    }
}

class Foo {
    public void go() {
        System.out.println("Foo.go()");
    }
}

class Bar {
    public void go() {
        System.out.println("Bar.go()");
    }
}

输出:

Foo.go()
Bar.go()

[soton_dolphin]

泛型不能被实例化，而单例模式需要实例化，这两个要求矛盾，所以你的要求不能实现。 也就是说在单体模式里用泛型你不能做到 T t = new T();

[解开者]

构造泛型类对象，应该用工厂模式而不是单例模式。 因为单例模式只产生一个对象，所以参数类型只可能为一种。在用到的地方，用和对象相同的参数类型不会有问题，但用和对象类型不同的参数类型会抛出转型异常（因为擦除）。所以，和不用泛型的区别只有首次创建对象时才能指定参数类型，而一般很少有这种应用场景。 与之相对，工厂模式可以产生不同参数类型的对象，这更符合泛型这种设计的初衷。

[长的丑怪我了]

首先一个都看不懂，然后每个都先写一篇，读懂里面的东西，然后去看课本。

[Keven Underwood]

class We<T>{
private static We<?> me = new We<>();

private T tell1;
private T tell2;

private We() {

}

private We(T tell1, T tell2) {
setTell1(tell1);
setTell2(tell2);
}

public static We<?> getInstance() {
return me;
}

public T getTell1() {
return tell1;
}

public void setTell1(T tell1) {
this.tell1 = tell1;
}

public T getTell2() {
return tell2;
}

public void setTell2(T tell2) {
this.tell2 = tell2;
}
}

public class Test {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
We<String> we = (We<String>) We.getInstance();
we.setTell1("12");
we.setTell2("12");
System.out.println(we.getTell1());
System.out.println(we.getTell2());
We<Integer> we2 = (We<Integer>) We.getInstance();
we2.setTell1(13);
we2.setTell2(13);
System.out.println(we2.getTell1());
System.out.println(we2.getTell2());
}
}