java修改list存储对象

Ⅰ java中将list对象写入文件

可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行存储list对象，举例：
OutputStreamWriter pw = null;//定义一个流
pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例
pw.write(list);//将要写入文件的内容，可以多次write
pw.close();//关闭流
备注：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。

Ⅱ java中使用ArrayList如何修改里面的内容.

java里增强for循环【for(String a: arrayList)】里面可以修改数据,但是不能删除数据，如下例子：
<pre t="code" l="java">修改集合：

import java.util.ArrayList;
import java.util.List;

public class TestA {

public static void main(String[] args){
//集合
List<String> arrayList=new ArrayList<String>();
//存放元素
arrayList.add("hello");
arrayList.add("ninghao");
arrayList.add("bye");
//集合标量
int index=0;
//遍历集合
for(String a:arrayList){
//输出集合对象
System.out.println(a);
//修改集合对象
arrayList.set(index, "hi");
//标量加一
index++;
}
//输出集合
System.out.println(arrayList);
}
}

结果：
hello
ninghao
bye
[hi, hi, hi]

删除集合元素：

import java.util.ArrayList;
import java.util.List;

public class TestA {

public static void main(String[] args){
//集合
List<String> arrayList=new ArrayList<String>();
//存放元素
arrayList.add("hello");
arrayList.add("ninghao");
arrayList.add("bye");
//集合标量
int index=0;
//遍历集合
for(String a:arrayList){
//输出集合对象
System.out.println(a);
//删除元素
arrayList.remove(index);

//标量加一
index++;
}
//输出集合
System.out.println(arrayList);
}
}
结果：
hello
Exception in thread "main" java.util.
at java.util.AbstractList$Itr.checkForComodification(AbstractList.java:372)
at java.util.AbstractList$Itr.next(AbstractList.java:343)
at app.TestA.main(TestA.java:19)由以上例子可以看出，增强for循环，在循环里可以修改集合元素，但是不能删除集合元素。

Ⅲ java反射如何获取并修改list子对象

先判断类型是否是list，然后用下面的代码就可以获取到list集合

Java code?
Method m = (Method) obj.getClass().getMethod("get" + getMethodName(field.getName())); List list = (List) m.invoke(obj);
Java code?private static String getMethodName(String fildeName) throws Exception{ byte[] items = fildeName.getBytes(); items[0] = (byte) ((char) items[0] - 'a' + 'A'); return new String(items); }

Ⅳ java里怎么修改list记录中的某个值

• java中使用arraylist修改里面的内容，可以使用set方法，拿到下标修改内容，如下代码packagecom.qiu.lin.he;

• import<a href="https://www..com/s?wd=java.util&tn=44039180_cpr&fenlei=-bIi4WUvYETgN-TLwGUv3ErHD4P1D1PWm"target="_blank"class="-highlight">java.util</a>.ArrayList;
• import<a href="https://www..com/s?wd=java.util&tn=44039180_cpr&fenlei=-bIi4WUvYETgN-TLwGUv3ErHD4P1D1PWm"target="_blank"class="-highlight">java.util</a>.List;
• publicclassCeshi{
• publicstaticvoidmain(String[]args){
• List<String>list=newArrayList<String>();
• list.add("a");
• list.add("b");
• list.add("c");
• System.out.println("未修改前:");
• for(Strings:list){
• System.out.println(s);
• }
• list.set(0,"修改之后的元素");//修改对应的元素
• System.out.println("已修改后:");
• for(Strings:list){
• System.out.println(s);
• }
• }
• }

• 运行结果如下：

• 

Ⅳ java中怎么把以保存数据的list集合传到别的类中操作进行增删改查，

有好多方法啊，

1，可以在类中自定义构造函数，将list集合作为参数，在new对象的时候把集合传进去。

2，可以在类中定义方法，将list集合作为参数，然后使用对象调用该方法，并把list集合作为实参传进去。

list集合得到了，想怎么增删改查都可以了。

你说好几个类共同操作一个集合，集合这个东西跟数组一样，你把它作为实参传过去，实际上并不是传的集合对象本身，而是它的地址（或者是引用，可以这么理解），然后你在方法中操作集合，都是直接作用于集合本身而不是集合的值，也就是说你在方法内部操作传进来的集合，跟在外面直接操作集合是一个效果。这跟普通的变量不一样，普通的变量是值传递，你在方法内部操作一个变量只是在操作值，原来的变量还在那里不会改变。

所以说好几个类共同操作一个list集合，只需要分别把这个list集合传递到各个类中就可以了。

publicclassAnswer{
publicstaticvoidmain(String[]args){
Listlist=newArrayList();
Aaaa=newAaa(list);
Bbbb=newBbb();

//调用对象中的方法操作list集合
a.funA();
b.funB(list);
}
}

classAaa{
Listlist;
publicAaa(){};
publicAaa(Listlist){
this.list=list;
}

//定义处理list集合的方法
public...funA(){
//操作list集合
...
}
}

classBbb{
//定义处理list集合的方法
public...(Listlist){
//操作list集合
...
}
}

Ⅵ java里怎样用list存储对象

List<泛型> list = new ArrayList<泛型>();

list.add(泛型object);

e.g.
List<String> list = new ArrayList<String>();
String str = new String("aaaa");
list.add(str);

Ⅶ java如何将1个list存入缓存中并在缓存在修改数据

publicclassTest2{

	publicstaticvoidmain(String[]args){
		try{
			List<String>list=newArrayList<>();
			//模拟传过来的值
			inti=0;
			while(true){
				Longtime=newDate().getTime();
				//将当前时间与值拼接成字符串保存到list
				list.add("value"+i+","+time);
				//调用处理方法
				processing(list);
				i++;
				//模拟每次传入的时间长度
				Thread.sleep(3000);
			}
		}catch(InterruptedExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
	}
publicstaticvoidprocessing(List<String>list){
	//第一个存入的值
				Stringsrc1=list.get(0);
				//最后一个存入的值
				Stringsrc2=list.get(list.size()-1);
				//通过转换成数组
				String[]c1=src1.split(",");
				String[]c2=src2.split(",");
				//拿到第一个存入的时间字符串转换成Long
				Longl1=Long.parseLong(c1[1]);
				//拿到最新的时间字符串转换成Long
				Longl2=Long.parseLong(c2[1]);
				//如果大于等于30000毫秒就说明了过了30秒清空
				if((l2-l1)>=30000){
					list.clear();
				}
	System.out.println("每次的值"+src2);
	System.out.println("是否30秒清空"+(list.size()==0));
	}
}


/*******************************第二种方式*************************************/

publicclassTest2{
	//定义一个全局变量用于接收时间
	privatestaticLongtime=0L;
	publicstaticvoidmain(String[]args){
		try{
			List<String>list=newArrayList<>();
			//模拟传过来的值
			inti=0;
			while(true){
				//如果list是在清空状态那么就创建个时间为第一次时间
				if(list.size()==0){
					time=newDate().getTime();
				}
				//将字符串保存到list
				list.add("value"+i);
				//调用处理方法，没次传入一个当前存入对象的时间
				processing(list,newDate().getTime());
				i++;
				//模拟每次传入的时间长度
				Thread.sleep(3000);
			}
		}catch(InterruptedExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
	}
publicstaticvoidprocessing(List<String>list,Longtimes){
	//当前时间-第一次存入的时间大于等于30000毫秒
			//就是过了30秒执行清空操作
				if((times-time)>=30000){
					list.clear();
				}
				for(Stringls:list){
				System.out.println("每次的值"+ls);
				}
	System.out.println("是否30秒清空"+(list.size()==0));
	}
}

我没有redis 只能模拟一个 你看下 其实 你就多了一步 从缓存中取值 判断不能 等于 30000毫秒 因为 时间会有所偏差 可能大于 所以 大于等于，你要是觉得 毫秒太长你可以 转换成秒存入 在计算

第二种 的话 你的程序 可能不需要太大改掉