📌  相关文章
📜  如何在Java中克隆列表？

📅  最后修改于: 2022-05-13 01:55:15.109000             🧑  作者: Mango

如何在Java中克隆列表？

给定一个Java列表，任务是克隆这个列表。

例子：

在Java中，有多种方法可以克隆列表。本文将解释一些用于实现相同目的的主要方法。

  • 使用复制构造函数：使用Java中的 ArrayList 构造函数，可以使用另一个集合中的元素初始化新列表。
    句法： 
    ArrayList cloned = new ArrayList(collection c);

where c is the collection containing 
elements to be added to this list.

    方法：

    1. 创建要克隆的列表。
    2. 通过将原始列表作为 ArrayList 的复制构造函数的参数传递来克隆列表。

    下面的代码说明了这个例子。 

    // Program to clone a List in Java
  
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
  
class Example {
    public static void main(String[] args)
    {
        // Create a list
        List original
            = Arrays.asList(
                "GeeksForGeeks",
                "A Computer Science",
                "Portal");
  
        // Clone the list
        List cloned_list
            = new ArrayList(original);
  
        System.out.println(cloned_list);
    }
}
    输出： 
    [GeeksForGeeks, A Computer Science, Portal]
  • 使用 addAll() 方法： List 类有一个名为 addAll() 的方法，它将一个集合的所有元素附加到列表中。

    句法： 

    boolean addAll(Collection c);

where c is the collection containing
elements to be added to this list.

    方法：

    1. 创建要克隆的列表。
    2. 使用 ArrayList 构造函数创建一个空列表。
    3. 使用 addAll() 方法将原始列表附加到空列表中。

    以下示例将说明此方法。 

    // Program to clone a List in Java
  
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
  
class Example {
    public static void main(String[] args)
    {
        // Create a list
        List original
            = Arrays.asList(
                "GeeksForGeeks",
                "A Computer Science",
                "Portal");
  
        List cloned_list
            = new ArrayList();
  
        // Cloning a list
        cloned_list.addAll(original);
  
        System.out.println(cloned_list);
    }
}
    输出： 
    [GeeksForGeeks, A Computer Science, Portal]
  • 在Java 8 中使用流 使用Java 8 中引入的 Streams API，可以克隆列表。 collect() 方法（连同 toList() 方法）用于克隆列表。

    方法：

    1. 创建一个类
    2. 使用 asList 方法从数组创建类对象列表。
    3. 使用 stream() 方法将对象列表转换为对象流。
    4. 使用 collect(Collectors.toList()) 方法收集所有流元素列表实例并将它们返回到 cloned_list。

    下面的程序说明了这个概念。 

    import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
  
// Program to clone a List in Java
class Example {
    public static void main(String[] args)
    {
        // Create a list
        List original
            = Arrays.asList(
                "GeeksForGeeks",
                "A Computer Science",
                "Portal");
  
        // Clone a list
        List cloned_list
            = original.stream()
                  .collect(Collectors.toList());
  
        System.out.println(cloned_list);
    }
}
    输出： 
    [GeeksForGeeks, A Computer Science, Portal]
  • 使用 clone() 方法： Java中类的 Clone() 方法用于创建当前对象的类的新实例，并使用指定对象的内容初始化其所有字段。要克隆一个列表，可以遍历原始列表并使用 clone 方法复制所有列表元素并使用 add 方法将它们附加到列表中。

    句法： 

    protected Object clone()
throws CloneNotSupportedException

    方法：

    1. 创建一个可克隆类，该类重写了 clone 方法。
    2. 使用 asList 方法从数组创建类对象列表。
    3. 创建一个空列表。
    4. 循环遍历原始列表的每个元素，并调用类对象的clone()方法（返回类实例）并使用 add() 方法将其附加到新列表中。

    下面的例子说明了这个概念。 

    import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
  
// Class needs to be cloneable
class GfG implements Cloneable {
  
    String username;
    String msg;
  
    // Constructor
    GfG(String username, String msg)
    {
        this.username = username;
        this.msg = msg;
    }
  
    // To print the objects in the desired format
    @Override
    public String toString()
    {
        return "\nHello " + username + " !\n" + msg + "\n";
    }
  
    // Overriding the inbuilt clone class
    @Override
    protected GfG clone()
    {
        return new GfG(username, msg);
    }
}
  
// Program to clone a List in Java
class Example {
    public static void main(String[] args)
    {
        // Creating a list
        List original
            = Arrays.asList(
                new GfG("Geeks",
                        "GeeksForGeeks"),
                new GfG("GFG",
                        "A computer science portal for geeks"));
  
        // Creating an empty list
        List cloned_list
            = new ArrayList();
  
        // Looping through the list
        // and cloning each element
        for (GfG temp : original)
            cloned_list.add(temp.clone());
        System.out.println(cloned_list);
    }
}
    输出： 
    [
Hello Geeks !
GeeksForGeeks, 
Hello GFG !
A computer science portal for geeks
]
  • 使用 Apache Commons Lang ：同样可以通过使用第三方库提供的克隆方法来实现，例如 Apache Commons Lang。
    句法： 
    public static  T clone(T object)

where T is the type of the object
and object is the Serializable object
to be cloned

    方法：

    1. 创建一个可序列化的类。
    2. 使用 asList 方法从数组创建类对象列表。
    3. 创建一个空列表。
    4. 循环遍历原始列表的每个元素，并调用可序列化对象（返回类实例）的 SerializationUtils.clone() 方法，并使用 add() 方法将其附加到新列表中。

    下面的程序说明了这种情况。 

    import org.apache.commons.lang3.SerializationUtils;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
  
// Class should be Serializable
class GfG implements Serializable {
    String username;
    String msg;
  
    // Constructor
    GfG(String username, String msg)
    {
        this.username = username;
        this.msg = msg;
    }
  
    // Overriding to print the objects
    // in the desired manner
    @Override
    public String toString()
    {
        return "\nHello " + username
            + " !\n" + msg + "\n";
    }
}
  
// Program to clone a List in Java
class Example {
    public static void main(String[] args)
    {
        // Creating the list
        List original
            = Arrays.asList(
                new GfG("Mukkesh",
                        "Hey there fellows!"),
                new GfG("McKenzie",
                        "Welcome to my page!"));
  
        // Creating an empty list
        List cloned_list = new ArrayList();
  
        // Looping through the list
        // and cloning each element
        // using SerializationUtils.clone
        for (GfG temp : original)
            cloned_list.add(
                SerializationUtils.clone(temp));
        System.out.println(cloned_list);
    }
}

    输出： 

    [
Hello Mukkesh !
Hey there fellows!, 
Hello McKenzie !
Welcome to my page!
]
  • 使用 Gson 库将列表转换为 JSON ：使用 Google 的 Gson 库，可以将列表转换为 JSON。此 JSON字符串可以转换为 List 类型的对象，并可用于初始化新的 List。

    句法： 

    String gson.toJson(List a);
Returns a JSON string of the List object a.

List gson.fromJson(String b, Class T)
Returns a list of type Class T, from the JSON string b.

    方法：

    1. 创建一个类
    2. 使用 asList 方法从数组创建类对象列表。
    3. 使用 toJson()函数创建原始列表的 JSON字符串，将其作为参数传递给此函数。
    4. 存储返回的 JSON字符串
    5. 通过使用 fromJson()函数并将存储的 JSON字符串作为参数传递，创建一个空列表并直接将其初始化为原始列表的值。

    下面的程序说明了这一点。 

    import com.google.gson.Gson;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
  
// Class should be Serializable
class GfG implements Serializable {
    String username;
    String msg;
  
    // Constructor
    GfG(String username, String msg)
    {
        this.username = username;
        this.msg = msg;
    }
  
    // Overriding to print the object
    // in the desired format
    @Override
    public String toString()
    {
        return "\nHello " + username + " !\n" + msg + "\n";
    }
}
  
// Program to clone a List in Java
class Example {
    public static void main(String[] args)
    {
        // Creating a new list
        List original
            = Arrays.asList(new GfG("Mukkesh",
                                    "Hey there fellows!"),
                            new GfG("McKenzie",
                                    "Welcome to my page!"));
        // Creating a gson object
        Gson gson = new Gson();
  
        // Converting the list into a json string
        String jsonstring
            = gson.toJson(original);
  
        // Converting the json string
        // back into a list
        List cloned_list
            = gson.fromJson(jsonstring, GfG);
  
        System.out.println(cloned_list);
    }
}

    输出： 

    [
Hello Mukkesh !
Hey there fellows!, 
Hello McKenzie !
Welcome to my page!
]
  • 使用 Reflection 包： Reflection 包也可用于克隆列表。

    方法：

    1. 创建一个可克隆类，该类重写了 clone 方法。
    2. 使用 asList 方法从数组创建类对象列表。
    3. 创建一个空列表。
    4. 使用 getClass().getDeclaredMethod(“clone”) 方法从类中获取clone方法（在列表的一个元素上），并将其存储为方法实例。
    5. 循环遍历列表的每个元素，并调用存储的方法，该方法将返回一个类实例，该实例可以附加到新列表中。 
    import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
  
// GfGclass implements Cloneable Interface
class GfG implements Cloneable {
    String username;
    String msg;
  
    // Constructor
    GfG(String username, String msg)
    {
        this.username = username;
        this.msg = msg;
    }
  
    // Overriding to print the object
    // in the desired format
    @Override
    public String toString()
    {
        return "\nHello " + username
            + "!\n" + msg + "\n";
    }
  
    // Overriding the clone function
    @Override
    protected Object clone()
        throws CloneNotSupportedException
    {
        return new GfG(username, msg);
    }
}
  
class ListUtils {
    // Create a cloning function
    public static  List
    clone(List original)
        throws NoSuchMethodException,
               InvocationTargetException,
               IllegalAccessException
    {
  
        // Boundary conditions checked
        if (original == null
            || original.size() == 0) {
            return new ArrayList<>();
        }
  
        // Get the clone method from the GfG class
        Method method
            = original.get(0)
                  .getClass()
                  .getDeclaredMethod("clone");
  
        // Create an empty list for cloning
        List clone = new ArrayList<>();
  
        // Loop through the list and
        // invoke the clone method of each element
        for (T item : original) {
            clone.add((T)method.invoke(item));
        }
  
        // Return the cloned list
        return clone;
    }
  
    public static void main(String[] args)
    {
        // Creating a list
        List original
            = Arrays.asList(
                new GfG("Geeks",
                        "GeeksForGeeks"),
                new GfG("GFG",
                        "A computer science portal for geeks"));
  
        // Create an empty list for cloning
        List cloned_list = null;
  
        // Use try and catch for exception handling
        try {
            cloned_list = clone(original);
        }
        catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        catch (IllegalAccessException e) {
            e.printStackTrace();
        }
  
        // Print the cloned list
        System.out.println(cloned_list);
    }
}
    输出： 
    [
Hello Geeks!
GeeksForGeeks, 
Hello GFG!
A computer science portal for geeks
]