Java 编写此程序的更有效方法

这个节目是家庭作业。我们已经完成了，可以出发了。我想知道是否有一种更精简的方式来编写这个程序？该程序称为Interleave，它所做的是获取两个ArrayList并将它们组合起来，以便第一个ArrayList中的其他元素都来自第二个ArrayList。听起来很简单，我们使用迭代器遍历并添加必要的元素。但代码是块状的。在我看来，一定有更好的方法来写这个，对吗？提前谢谢

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;

}

import java.util.*；
公共类交织
{
公共静态void main（字符串[]args）
{
ArrayList a1=新的ArrayList（）；
集合。添加所有（a1、10、20、30）；
ArrayList a2=新的ArrayList（）；
集合。添加所有（a2、4、5、6、7、8、9）；
系统输出打印LN（a1）；
系统输出打印LN（a2）；
系统输出打印LN（交织（a1，a2））；
ArrayList=新建ArrayList（）；
字符串[]字=
{“你好”、“怎么样”、“你呢？”}；
for（字符串s:单词）
{
列表。添加（s）；
}
}
公共静态ArrayList交错（ArrayList a1，
阵列列表a2）
{
迭代器it=a2.Iterator（）；
int i=1；
while（it.hasNext（））
{
int val=it.next（）；
如果（a1.size（）>=i）
{
a1.添加（i，val）；
}否则
{
a1.添加（val）；
}
i+=2；
}
返回a1；
}

---

}效率比代码外观更重要。每次在索引i添加元素时，该索引之后的每个元素都需要由ArrayList上移一个索引，因为它使用数组作为其底层数据结构。如果使用LinkedList可以避免此问题，或者创建第三个大小的数组（第一个数组+第二个数组）并将元素添加到该数组中，则此代码的效率会更高。再者，你也必须考虑空间，所以让另一个数组增加空间需求。 即使您坚持使用当前的方法，也应该在添加所有元素之前增加阵列的容量。这样，阵列的容量就已经足够大，可以添加来自另一个阵列的所有元素，并且（可能）不需要多次增加

希望有帮助

编辑：

---

您还可以提前重新配置阵列，使每一秒的位置都已为空，这样可以避免我前面描述的阵列移位问题。

现在，您的

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;
}

公共静态列表交错（列表第一，列表第二）
{
迭代器it=second.Iterator（）；
int i=1；
while（it.hasNext（））{
T val=it.next（）；
if（first.size（）>=i）
首先，添加（i，val）；
其他的
第一，添加（val）；
i+=2；
}
先返回；
}

公共静态ArrayList交错（ArrayList a1、ArrayList a2）
{
迭代器it1=a1.Iterator（）；
迭代器it2=a2.Iterator（）；
ArrayList输出=新的ArrayList（）；
while（it1.hasNext（）| | it2.hasNext（））
{
if（it1.hasNext（））{output.add（it1.next（））；}
if（it2.hasNext（））{output.add（it2.next（））；}
}
返回输出；
}

我不认为您可以减少太多的代码量。它可能也不会变得太快。不过，我建议进行一些其他改进：

如果要返回另一个对象，则对传入的对象进行变异不是一种好的做法

您可以使用

List

而不是

ArrayList

，这样就可以传入任何类型的

List

您可以使用泛型使其不特定于

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;
}

公共静态列表交错（列表a1、列表a2）{
列表列表=新的ArrayList（a1.size（）+a2.size（））；
迭代器it1=a1.Iterator（）；
迭代器it2=a2.Iterator（）；
while（it1.hasNext（）| | it2.hasNext（））{
if（it1.hasNext（））{
list.add（it1.next（））；
}
if（it2.hasNext（））{
list.add（it2.next（））；
}
}
退货清单；
}

Java作为一种语言，非常冗长和“块状”。要习惯它；-@Santa，至少他的项目没有涉及乐高积木，那会变得很混乱。甚至可能是“块状”；）您可以用for-each循环替换迭代器while循环，这将节省一整行代码！；）没有更好的方法来构造代码。但是，如果允许您为结果创建第三个数组并向其中添加项目，则可以使其更高效（即更快），因为将元素插入现有数组的速度很慢。@cularis lol。是的，我可以猜。我简直不敢相信最终结果会如此之大。尽管如此，这仍然迫使两个列表包含相同的类型。效率远不如代码外观重要。干净的代码不太可能是有缺陷的代码，而且更易于维护。如果您的代码没有足够的效率来完成它的工作，请分析它并修复重要的部分@nmichaels-你误用了过早优化的说法。每种情况都不同，因此都有自己的指导方针。此外，我们中的任何人都不可能说什么“足够有效地完成工作”，因为这是一次学校演习，OP没有详细说明要求。因此，我们不能不提一个总体上更好的解决方案。@nmichaels-我还应该补充一点，过早优化并不是使用糟糕编程实践的借口，这正是您所提倡的。在可能的情况下，程序员应该明智地选择数据结构，并编写代码，使其代码

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;
}