189 8069 5689
java变量放到缓存中的机制如下：
创新互联专注为客户提供全方位的互联网综合服务，包含不限于成都做网站、网站建设、文成网络推广、小程序定制开发、文成网络营销、文成企业策划、文成品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联为所有大学生创业者提供文成建站搭建服务，24小时服务热线：18982081108，官方网址：www.cdcxhl.com
Java中有中间缓存变量来储存其单个表达式的值，而j的自增自减的结果依然保留在原来的变量储存区。因为本体是j的值，而单个表达式的值是中间产生的一个临时变量值，是在整条计算表达式结束后就可以抛弃的值，所以用个临时中间缓存变量在放就可以了。这就可以实现自增自减运算在计算时值的加减1顺序差异产生的表达式与本体值差异的两个变量储存。
如下代码：
package com.qiu.lin.he;
public class CeShi {
public static void main(String[] args) {
for (int i = 0; i 10; i++) {
for (int j = 0; j 10; j++) {
int temp = i;//中间变量，进行缓存
i = j;
j = temp;
System.out.println(i + "和j的值为" + j);
}
}
}
}
结果如下：
在jsp页面里：
request.setAttribute("aaa",bbb);
request.getSession().setAttribute("ccc",ddd);
其中，bbb是一个文本里面的内容，ddd是另一个文本框里的内容。
这样可以暂时保存下来，等再次返回这个页面的时候，我们在用
得到bbb,request.getAttribute(''aaa''); 然后再把bbb设置在第一个文本框里面就好了，达到了缓存的效果。
如果你用struts框架，里面的html标签库已经为我们提供了这样的效果。我们可以直接来用。
session最好少用，一般系统都用session来存储用户信息，session用多了对系统开销不好，缓存也尽量少用，要用的话都用在基本不会改变的数据上，不然会影响系统，如果经常改变的量，用了缓存，如：一个程序在用缓存中的数据，而另一个程序却在修改缓存的数据，那边程序就会出现不符合的数据了，如果回答对你有帮助，请把分给我吧，谢谢
java有自己的缓存输入输出类，比如 InputStream,FileOutputStram等 具体可以查看API，
要想自己实现的话，很简单，设置一个足够大的字节数组就可以了，把需要的东西放进去，就是个缓存。
你这个分数太少了吧，程序到是有，不过给你有点可惜
CacheMgr.java
import java.util.*;
import cn.javass.framework.cache.vo.CacheConfModel;
public class CacheMgr {
private static Map cacheMap = new HashMap();
private static Map cacheConfMap = new HashMap();
private CacheMgr(){
}
private static CacheMgr cm = null;
public static CacheMgr getInstance(){
if(cm==null){
cm = new CacheMgr();
Thread t = new ClearCache();
t.start();
}
return cm;
}
/**
* 增加缓存
* @param key
* @param value
* @param ccm 缓存对象
* @return
*/
public boolean addCache(Object key,Object value,CacheConfModel ccm){
boolean flag = false;
cacheMap.put(key, value);
cacheConfMap.put(key, ccm);
System.out.println("now addcache=="+cacheMap.size());
return true;
}
/**
* 删除缓存
* @param key
* @return
*/
public boolean removeCache(Object key){
cacheMap.remove(key);
cacheConfMap.remove(key);
System.out.println("now removeCache=="+cacheMap.size());
return true;
}
/**
* 清除缓存的类
* @author wanglj
* 继承Thread线程类
*/
private static class ClearCache extends Thread{
public void run(){
while(true){
Set tempSet = new HashSet();
Set set = cacheConfMap.keySet();
Iterator it = set.iterator();
while(it.hasNext()){
Object key = it.next();
CacheConfModel ccm = (CacheConfModel)cacheConfMap.get(key);
//比较是否需要清除
if(!ccm.isForever()){
if((new Date().getTime()-ccm.getBeginTime())= ccm.getDurableTime()*60*1000){
//可以清除，先记录下来
tempSet.add(key);
}
}
}
//真正清除
Iterator tempIt = tempSet.iterator();
while(tempIt.hasNext()){
Object key = tempIt.next();
cacheMap.remove(key);
cacheConfMap.remove(key);
}
System.out.println("now thread================"+cacheMap.size());
//休息
try {
Thread.sleep(60*1000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
CacheConfModel.java
public class CacheConfModel implements java.io.Serializable{
private long beginTime;
private boolean isForever = false;
private int durableTime;
public long getBeginTime() {
return beginTime;
}
public void setBeginTime(long beginTime) {
this.beginTime = beginTime;
}
public boolean isForever() {
return isForever;
}
public void setForever(boolean isForever) {
this.isForever = isForever;
}
public int getDurableTime() {
return durableTime;
}
public void setDurableTime(int durableTime) {
this.durableTime = durableTime;
}
}
顺便说一句，缓存的管理不是靠时间久来计算的，是靠最大不活动间隔计算的，你的设计思想有问题
所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。缓存机制的实现有很多中，这里讲一种。
public class CacheImmutale{
//声明要缓存的类名；
private final String className;
//声明10个缓存池
private static CacheImmutale[] cache= new CachImmutale[10];
//记录缓存的位置，最新位置为[pos-1]
private static int pos=0;
//构造器
public CacheImmutale(String className){
this.className=className;
}
//返回方法
public String getName(){
return className;
}
//返回对象实例名，传进要使用的实例名，由该方法去判断缓存池中是否存在
public static CacheImmutale valueOf(String className){
//遍历缓存池，若存在，返回
for(int i=0;i
if(cache[i]!=nullcache[i].getName().equals(className)){
return cache[i];
}
}
//如果缓存池满，则采取先进先出
if(pos==10){
cache[0]=new CacheImmutale(className);
pos=1;
return cache[0];
}
else{
cache[pos++]=new CacheImmutale(className);
return cache[pos-1];
}
}
public boolean equals(Object obj){
if(obj instanceof CacheImmutale){
CacheImmutale c1=(CacheImmutale)obj;
if(className.equals(c1.getName())){
return true;
}
}
return false;
}
public int hashCode(){
return className.hashCode();
}
}