一个更有效的方法来编写这个程序

Question

这个程序是功课。我们已经完成了它，并且很好去。我想知道是否有更简化的写这个程序的方式？该程序被称为Interleave，它所做的是将两个ArrayLists组合起来，以便第一个ArrayList中的每个其他元素都来自第二个ArrayList。听起来很简单，就是我们使用迭代器来添加必要的元素。但代码是BLOCKY。在我看来，必须有更好的方式来写这个，对吧？提前致谢。

import java.util.*; 

public class Interleave 
{ 

public static void main(String[] args) 
{ 

    ArrayList<Integer> a1 = new ArrayList<Integer>(); 
    Collections.addAll(a1, 10, 20, 30); 

    ArrayList<Integer> a2 = new ArrayList<Integer>(); 
    Collections.addAll(a2, 4, 5, 6, 7, 8, 9); 

    System.out.println(a1); 
    System.out.println(a2); 

    System.out.println(interleave(a1, a2)); 

    ArrayList<String> list = new ArrayList<String>(); 
    String[] words = 
    { "how", "are", "you?" }; 

    for (String s : words) 
    { 
     list.add(s); 
    } 

} 

public static ArrayList<Integer> interleave(ArrayList<Integer> a1, 
     ArrayList<Integer> a2) 
{ 
    Iterator<Integer> it = a2.iterator(); 
    int i = 1; 
    while (it.hasNext()) 
    { 
     int val = it.next(); 
     if (a1.size() >= i) 
     { 
      a1.add(i, val); 
     } else 
     { 
      a1.add(val); 
     } 
     i += 2; 
    } 
    return a1; 

} 

}

Answer 1

效率比代码看起来更重要。每次在索引i处添加元素时，该索引之后的每个元素都需要由ArrayList向上移动一个索引，因为它使用数组作为其基础数据结构。如果使用避免这个问题的LinkedList，或者如果您创建了第三个数组（第一个数组+第二个数组），并将这些元素添加到该数组中，则此代码效率会更高。再次，你还必须考虑空间，所以制作另一个阵列会增加空间需求。

即使您坚持使用您当前的方法，您应该在添加所有元素之前增加数组的容量。这样，数组的容量已经足够大，可以添加另一个数组中的所有元素，并且不会（可能）需要多次增加。

希望有所帮助。

编辑：

你也可以重新配置阵列提前使得每个第二名已经是空的，这将节省您从我前面描述的阵列转移问题。

Answer 2

现在，你interleave函数假定一个具体列表实现（ArrayList）和特定类型，它必须包含（Integer）。您可以通过使用泛型概括此功能：

public static <T> List<T> interleave(List<T> first, List<T> second) 
{ 
    Iterator<T> it = second.iterator(); 
    int i = 1; 
    while (it.hasNext()) { 
     T val = it.next(); 
     if (first.size() >= i) 
      first.add(i, val); 
     else 
      first.add(val); 
     i += 2; 
    } 

    return first; 
} 

Answer 3

public static ArrayList<Integer> interleave(ArrayList<Integer> a1, ArrayList<Integer> a2) 
{ 
    Iterator<Integer> it1 = a1.iterator(); 
    Iterator<Integer> it2 = a2.iterator(); 
    ArrayList<Integer> output = new ArrayList<Integer>(); 

    while (it1.hasNext() || it2.hasNext()) 
    { 
     if (it1.hasNext()) { output.add(it1.next()); } 
     if (it2.hasNext()) { output.add(it2.next()); } 
    } 

    return output;  
} 

Answer 4

我不认为你可以减少代码量很大。它可能无法做得太快。但是，我会提出一些其他改进建议：

1. 如果您要返回另一个对象，那么对您传入的对象进行变异不是一个好习惯。
2. 你可以只使用List代替ArrayList所以任何类型的List可以传递。
3. 你可以使用泛型不能使其具体到Integer列表。

这些组合会产生这样的：

public static <T> List<T> interleave(List<T> a1, List<T> a2) { 
    List<T> list = new ArrayList<T>(a1.size() + a2.size()); 
    Iterator<T> it1 = a1.iterator(); 
    Iterator<T> it2 = a2.iterator(); 

    while (it1.hasNext() || it2.hasNext()) { 
     if (it1.hasNext()) { 
      list.add(it1.next()); 
     } 
     if (it2.hasNext()) { 
      list.add(it2.next()); 
     } 
    } 

    return list; 
}