java复制list
① java 如何将一个list中的值全部复制到另一个list中
ArrayList<String> list1 = new ArrayList<String>();
list1.add("b");
list1.add("d");
// System.out.println(list1);
ArrayList<String> list2=new ArrayList<String>();
list2.addAll(list1);//将list1添加到list2中
System.out.println(list2);
② java怎么将list引用转为值
直接用 newList = oldList 是引用传递，复制的是地址！！！！！！！
改变oldList里的内容同样也会影响到newList
值传递可以用Collections.(newList, oldList)
但需要两个List的大小一样，即复制前还需要给newList指定长度
我认为值传递更方便的是newList.addAll(oldList)
③ java复制List最快方法是什么
估计没有快的。复制都是线性的。用多线程都不见得更快。重新设计算法吧，避免复制
其他的复制方法
List<Integer> a = b.clone();
或
Collections.(a,b);
④ Java中，复制一个对象，有什么好的方法
使用Java的反射机制实现：为了能更好的区分，写成了两个类，可以运行下面的代码看看效果
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Test {
public static void main(String[] args) throws Exception {
Customer1 c1 = new Customer1();
c1.setName("c1");
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
c1.setList(list);
Map<String,String> map = new HashMap<String, String>();
map.put("map1", "map1");
map.put("map2", "map2");
c1.setMap(map);
Customer2 c2 = new Customer2();
//
Class c = c1.getClass();
Class class2 = c2.getClass();
Field fields[] = c.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getMethodName = "get" + firstLetter + fieldName.substring(1);
String setMethodName = "set" + firstLetter + fieldName.substring(1);
Method getMethod = c.getMethod(getMethodName, new Class[] {});
Method setMethod = class2.getMethod(setMethodName,
new Class[] { field.getType() });
Object value = getMethod.invoke(c1, new Object[] {});
setMethod.invoke(c2, new Object[] { value });
}
System.out.println(c2.getName());
System.out.println(c2.getList());
System.out.println(c2.getMap());
}
}
class Customer1 {
private String name;
private List<String> list;
private Map<String, String> map;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
}
class Customer2 {
private String name;
private List<String> list;
private Map<String, String> map;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
}
⑤ JAVA一个泛型数组List<> 怎么复制某几行到另外一个List<>
你明白一个单纯的“?”是什么意思吗？它代表的是任意类型。既可以是有继承关系的，也可以是八竿子都打不到的。比如你想写的大约是这样的class gen{pulbic <? extends Number>void listMove(List <?>list1 , List<?> list2，Int i){list2.add(list1.get(i));}}但是请注意这里?号代表的是任意一个Number的子类，这意味着你如果传入像list1 是List<Long>而list2是List<Double>这样的同级泛型参数，就像这样来调用这个函数list1 = new List<Long >();list2 = new List<Double>();listMove(list1, list2, i);这个函数的目的显然是把list1 的第i个元素放入list2中，但是请注意list1和list2是不相同，也没有继承关系的同级别类型，你正试图把一个Long 类型放入一个只能够放置Double类型的List 中，如果java允许你这样来操作元素，那不是和泛型本身希望提高类型安全的目的背道而驰了吗？这个问题里你需要注意的是，想要传递的类型参数是有关系的，lIst1的?号应该是list2的本身或者子类才对，你应该这样定义你的方法，你需要对这两个?号有一定的约束这样来定义public < T extends Object>/*这里可以是你自己对类型的约束，我都是约束成了Object的*/void listMove(List<? extends T> list1//有条件的约束，?应该是T的子类, List<T> list2 ,int i){
list2.add(list1.get(i));
}
⑥ java如何将一个list的内容添加到另一个list中
在JAVA中，想要把一个list中的内容添加至另一个list中，有两种方法：
采用循环的方法。通过循环第一个ArrayList，然后通过每循环一次的方式，将值赋值给另一个ArrayList。具体代码实现如下：
2.采用ArrayList自带的addAll()方法。addAll()方法是通过传入整一个List，将此List中的所有元素加入到新的List中，也就是当前List会增加的元素个数等于传入的List的大小。该方法较为简单，具体代码实现如下：
⑦ java 如何指定原List其中一部分进行复制到新的list
publicstaticvoidmain(String[]args){
List<String>list1=newArrayList<String>();
List<String>list2=newArrayList<String>();list1.add("1");
list1.add("2");
list1.add("3");list2.add("a");//赋值list1前两个到list2中
System.out.println(list2);
list2.addAll(list1.subList(0,2));//可以先按下标截取，再添加
System.out.println(list2);
}
//运行结果如下：
[a]
[a,1,2]
望采纳
⑧ Java。如何将一个LinkedList里的元素全部复制到另一LinkedList容器里
LinkedList的Clone()只是浅复制，也就是只能复制对象的引用，而不能再内存中新生成一个对象，所以你复制之后的LinkedList和原始的LinkedList中存储的对象是共享的。
要想不共享，那只能覆盖你原始LinkedList中存放类的Clone()方法，在这个方法中new一个这个类的新实例，将对象的属性赋值给一个新实例。
然后new一个新的LinkedList实例，遍历原始LinkedList中的每个元素，调用这个元素的Clone()，将得到的新元素添加到新的LinkedList中。
大概的代码意思如下
ElementClass是LinkedList中存储的元素的类
public class ElementClass{
private String attributeOne;
......
public void setAttributeOne(String attValue){
this.attributeOne = attValue;
}
/* 覆盖Clone方法，新建一个本类的实例，并将对象的属性值完全复制过去*/
public Object Clone(){
ElementClass newInstance = new ElementClass();//新建一个本类实例
newInstance.setAttributeOne(this.attributeOne);//复制属性
return newInstance;
}
}
LinkedList newList = new LinkedList();//新建一个LinkedList实例
Iterator it = oldList.iterator();获取原始List的遍历器
while(it.hasNext()){
newList .add(((ElementClass) it.next()).clone());//遍历元素，将克隆的新对象加入新的List中
}
⑨ Java的List如何实现线程安全
Java的List如何实现线程安全？
Collections.synchronizedList(names);效率最高，线程安全
Java的List是我们平时很常用的集合，线程安全对于高并发的场景也十分的重要，那么List如何才能实现线程安全呢 ？
加锁
首先大家会想到用Vector，这里我们就不讨论了，首先讨论的是加锁，例如下面的代码
public class Synchronized{
private List<String> names = new LinkedList<>();
public synchronized void addName(String name ){
names.add("abc");
}
public String getName(Integer index){
Lock lock =new ReentrantLock();
lock.lock();
try {
return names.get(index);
}catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
return null;
}
}
synchronized一加，或者使用lock 可以实现线程安全，但是这样的List要是很多个，代码量会大大增加。
java自带类
在java中我找到自带有两种方法
CopyOnWriteArrayList
CopyOnWrite 写入时复制，它使一个List同步的替代品，通常情况下提供了更好的并发性，并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代，在多插入的情况下由于多次的复制性能会一定的下降。
下面是add方法的源代码
public boolean add(E e) {
final ReentrantLock lock = this.lock; // 加锁 只允许获得锁的线程访问
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 创建个长度加1的数组并复制过去
Object[] newElements = Arrays.Of(elements, len + 1);
newElements[len] = e; // 赋值
setArray(newElements); // 设置内部的数组
return true;
} finally {
lock.unlock();
}
}
Collections.synchronizedList
Collections中有许多这个系列的方法例如
主要是利用了装饰者模式对传入的集合进行调用 Collotions中有内部类SynchronizedList
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;
final List<E> list;
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}
static class SynchronizedCollection<E> implements Collection<E>, Serializable {
private static final long serialVersionUID = 3053995032091335093L;
final Collection<E> c; // Backing Collection
final Object mutex; // Object on which to synchronize
这里上面的mutex就是锁的对象 在构建时候可以指定锁的对象 主要使用synchronize关键字实现线程安全
/**
* @serial include
*/
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;
final List<E> list;
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {
super(list, mutex);
this.list = list;
}
这里只是列举SynchronizedList ，其他类类似，可以看下源码了解下。
测试
public class Main {
public static void main(String[] args) {
List<String> names = new LinkedList<>();
names.add("sub");
names.add("jobs");
// 同步方法1 内部使用lock
long a = System.currentTimeMillis();
List<String> strings = new CopyOnWriteArrayList<>(names);
for (int i = 0; i < 100000; i++) {
strings.add("param1");
}
long b = System.currentTimeMillis();
// 同步方法2 装饰器模式使用 synchronized
List<String> synchronizedList = Collections.synchronizedList(names);
for (int i = 0; i < 100000; i++) {
synchronizedList.add("param2");
}
long c = System.currentTimeMillis();
System.out.println("CopyOnWriteArrayList time == "+(b-a));
System.out.println("Collections.synchronizedList time == "+(c-b));
}
}
两者内部使用的方法都不一样，CopyOnWriteArrayList内部是使用lock进行加锁解锁完成单线程访问，synchronizedList使用的是synchronize
进行了100000次添加后时间对比如下：
可以看出来还是使用了synchronize的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。
⑩ java 列表复制问题
jl2.setListData(jl1.getSelectedValue());
voidsetListData(Vector<?> listData)
Constructs a read-only ListModel from a Vector
and calls setModel with this model.
参数类型不正确