缓存的思想

缓存的思想
单例模式的懒汉式实现还体现了缓存的思想，缓存也是实际开发中非常常见的功能。简单讲就是，如果某些资源或者数据会被频繁的使用，可以把这些数据缓存到内存里面，每次操作的时候，先到内存里面找，看有没有这些数据，如果有，那么就直接使用，如果没有那么就获取它，并设置到缓存中，下一次访问的时候就可以直接从内存中获取了。从而节省大量的时间，缓存是一种典型的时间换空间的方案。

//java中缓存的基本实现示例
public class JavaCache {
    //缓存数据的容器，定义成Map是方便访问，直接根据key就可以获取Value了
    //key选用String是为了简单，方便演示
    private Map<String, Ojbect> map = new HashMap<String, Object>();
    //从缓存中获取值
    public Object getValue(String key) {
        //先从缓存里面取值
        Object obj = map.get(key);
        //判断缓存里面是否有值
        if (obj == null) {
            //如果没有，那么就去获取相应的数据，比如读取数据库或者文件
            //这里只是演示，所以直接写个假的值
            obj = key+",value";
            //把获取的值设置回到缓存里面
            map.put(key, obj);
        }
        //如果有值了，就直接返回使用
        return obj;
    }
}

为了方便理解，再举几个具体应用，一个是项目中的，一个是算法题

public class Test {
    public static void main(String[] args) {
        List<String> v_subList = new List<String>();
        v_subList.add("Proxy123");
        v_subList.add("Proxy456");
        v_subList.add("static123");
        v_subList.add("static456");
        v_subList.add("public123");
        v_subList.add("public456");

        Map<String, List<String>> map = m1(v_subList);
        //业务逻辑的话，需要哪个组就可以获取到哪个组的所有节点名
        List<String> ProxyList = map.get("Proxy");

        //业务逻辑是分组处理业务的,所有直接遍历map就行了，map里面已经用list分好了
    }

    public static Map<String, List<String>> m1(List<String> v_subList) {
        //这个map的key是组名，就是v_Group,value就是所有以v_Group开头的节点名，用list存储
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        //遍历所有节点
        for (String v_Name : v_subList) {
            //提取当前节点的组名
            String v_Group = v_Name.substring(0, v_Name.length() - 3);
            //看看map中有没有对应的list
            List<String> v_GroupList = map.get(v_Group);

            //如果没有的话就初始化一个，并且把v_Name扔进list中
            if (v_GroupList == null) {
                v_GroupList = new ArrayList<String>();
                v_GroupList.add(v_Name);
                map.put(v_Group, v_GroupList);
            } else {
                //如果有直接扔到list中
                v_GroupList.add(v_Name);
            }
        }

        return map;
    }
}

//问题描述：给定一字符串，相同的字符只保留第一次出现的，比如qwwewee 123321-------------qwe 123
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String input = s.nextLine();
        Map<Character, Integer> map = new HashMap<Character, Integer>();
        for (int i=0; i<input.length(); i++) {
            char c = input.charAt(i);
            if (map.get(c) == null) {
                map.put(c, i);

                System.out.print(c);
            }
        }
    }
}

实现缓存机制的步骤：
1.定义一个存放缓存数据的容器
2.从缓存中获取数据的做法
先从缓存里面取值
判断缓存里面是否有值
如果有值了，就直接使用这个值
如果没有，那么就去获取相应的数据，或者创建相应的对象
把获取的值设置回到缓存里面

web开发Scope->就是数据的缓存范围

//<jsp:useBean name="aa" class="com.yhc.AModel" scope="request">
//思路应该是差不多的
Object obj = request.getAttribute("aa");
AModel am = null;
if (obje == null) {
    am = new AModel();
    request.setAttribute("aa", am);
} else {
    am = (AModel)obj;
}

使用缓存来模拟实现单例

public class Singleton {
    //定义一个缺省的key值，用来标识在缓存中的存放
    private final static String DEFAULT_KEY = "One";
    //缓存实例的容器
    private static Map<String, Singleton> = new HashMap<String, Singleton>();
    private Singleton() {}
    public static Singleton getInstance() {
        //先从缓存中获取
        Singleton instance = (Singleton) map.get(DEFAULT_KEY);
        //如果没有，就新建一个，然后设置回缓存中
        if (instance == null) {
            instance = new Singleton();
            map.put(DEFAULT_KEY, instance);
        }
        //如果有就直接使用
        return instance;
    }
}