當前位置:首頁 » 編程語言 » java復制list

java復制list

發布時間: 2022-12-29 14:14:04

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.

參數類型不正確

熱點內容
編程器解讀 發布:2025-07-03 03:22:49 瀏覽:23
中國電信加密通信業務 發布:2025-07-03 03:06:00 瀏覽:520
腳本家的台詞 發布:2025-07-03 03:05:50 瀏覽:708
arcgisforpython 發布:2025-07-03 03:05:46 瀏覽:898
期計演算法 發布:2025-07-03 02:56:53 瀏覽:404
不同域訪問 發布:2025-07-03 02:49:05 瀏覽:818
多槽編程 發布:2025-07-03 02:47:42 瀏覽:919
sql2008錯誤233 發布:2025-07-03 02:28:52 瀏覽:168
創建資料庫語句mysql 發布:2025-07-03 02:14:34 瀏覽:146
python量化投資 發布:2025-07-03 02:05:11 瀏覽:804