Java 以更可读的方式在ArrayList中添加元素

我在下面的代码片段中添加了

ArrayList

List <Integer> myList = new  ArrayList();
myList.add(1);
myList.add(2);
myList.add(3);
myList.add(4);

---

更新：-我使用java 1.6

当您在实例化之前知道元素时：

List<Integer> myList = new ArrayList<>(Arrays.asList(1, 2, 3, 4));

并且简单地使用

List<Integer> myList = new ArrayList<>(asList(1, 2, 3, 4));

listmylist=newarraylist（asList（1,2,3,4））；

或

List myList=new ArrayList（）；
//做事
addAll（asList（1,2,3,4））；

---

如果您知道永远不想向列表中添加更多元素，您可以简单地编写

List<Integer> myList = Arrays.asList(1, 2, 3, 4);

List myList=Arrays.asList（1,2,3,4）；

或使用静态导入：

List<Integer> myList = asList(1, 2, 3, 4);

List myList=asList（1,2,3,4）；

如果您觉得这是可读的，那么还有一种方法

List<Integer> list = new ArrayList<Integer>() {{
    add(1);add(2);add(3);
}};

List List=new ArrayList（）{{
添加（1）；添加（2）；添加（3）；
}};

这是一种方法。但我猜这个值并不总是1…4。你仍然可以使用for循环

for (int i = 1; i <= 4; i ++){
mylistAdd(i)  
}

---

for（int i=1；i可以通过扩展
ArrayList
来链接方法。然后添加一个方法
addMe
，该方法将返回新的
ArrayList
类

class chainedArrayList extends ArrayList
{
     public chainedArrayList addMe(Object o)
     {add(o);return this;}
}

现在可以链接这些方法

mychainedArrayList.addMe(1).addMe(2).addMe(3).addMe(4);

方式（尽管列表是不可变的）：

ImmutableList myList=ImmutableList.builder（）
.add（1）
.add（2）
.add（3）
.build（）；

或者这样：

List <Integer> myList = Lists.newArrayList(1,2,3);

List myList=Lists.newArrayList（1,2,3）；

或

List myList=Ints.asList（1,2,3）；
不，很遗憾，因为它返回布尔值，除非对其进行扩展，否则您可以使用构建器的样式进行操作

看看（谷歌收藏）是否有适合你的东西。它们使用的生成器样式可能适合你，也可能不适合你。比如

public static <E> List<E> asList(@Nullable 
             E first,
             E[] rest)

但老实说，执行for循环和add已经足够优雅了，而且还有更多的事情需要担心。
如果您想要一个可变的整数列表，可以使用以下选项：

MutableList<Integer> list1 = Lists.mutable.with(1).with(2).with(3).with(4);
MutableList<Integer> list2 = Lists.mutable.with(1, 2, 3, 4);
Assert.assertEquals(list1, list2);

注意：我是Eclipse集合的提交者。
方法是如上所述的Arrays.asList（T…）。但这里有另一种方法：

public class CollectionChain<T, C extends Collection<T>> {

    public static <T> CollectionChain<T, ArrayList<T>> newArrayList(T inital) {
        return start(new ArrayList<>(), inital);
    }

    public static <T, C extends Collection<T>> CollectionChain<T, C> start(C collection, T inital) {
        return new CollectionChain<>(collection).add(inital);
    }

    private final C collection;

    private CollectionChain(C collection) {
        this.collection = collection;
    }

    public CollectionChain<T, C> add(T value) {
        collection.add(value);
        return this;
    }

    public final CollectionChain<T, C> addAll(T... values) {
        return addAll(Arrays.asList(values));
    }

    public CollectionChain<T, C> addAll(Collection<T> values) {
        collection.addAll(values);
        return this;
    }

    // Add other chained actions

    public C get() {
        return collection;
    }
}

公共类集合链{
公共静态集合链newArrayList（T inital）{
返回start（newarraylist（），inital）；
}
公共静态集合链开始（C集合，T初始）{
返回新的CollectionChain（collection）.add（初始）；
}
私人收藏；
私人收藏链（C收藏）{
this.collection=collection；
}
公共收藏链增值（T值）{
收藏。增值；
归还这个；
}
公共最终收集链添加全部（T…值）{
返回addAll（Arrays.asList（values））；
}
public CollectionChain addAll（集合值）{
collection.addAll（值）；
归还这个；
}
//添加其他链接操作
公共C get（）{
回收；
}
}

可以这样使用：

import static project.path.CollectionChain.*;

List<String> chainResult = newArrayList("Needed to properly resolve the type").add("A test").addAll("1", "2").get();

导入静态项目.path.CollectionChain.*；
List chainResult=newArrayList（“需要正确解析类型”）.add（“测试”）.addAll（“1”、“2”）.get（）；

这样只会创建和填充一个列表。
@Anirudh它非常优雅。您的意思是：List myList=Arrays.asList（1,2,3,4）？@BalázsMáriaNémeth:不，因为他以后无法向该列表中添加更多元素。@BalázsMáriaNémeth:根据您的建议编辑了我的答案。我认为如果您正在考虑创建一个全新的类，您最好只编写一个接受n个参数并将它们添加到列表中的助手方法。@Supericy是的，您是对的…除非他不想付出额外的努力来压倒可读性，否则我仍然会坚持第一个不那么优雅的解决方案。乍一看，这在性能方面可能并不重要，但下面介绍的解决方案总是有一点折衷。要么创建额外的对象，要么创建新的类在你的应用程序中，甚至导入新的依赖项都不需要ch，这总有一个很好的理由，而且在大多数情况下，这还不够充分。@BalázsMáriaNémeth:在你的简历中，你说：你正在寻求改进。改进就是利用API并使用其中一个建议的答案。所有4个当前发布的答案比第一个解决方案要好；）@jlordo：说实话，我以前已经使用了大多数建议的解决方案，现在仍然使用其中的一些，但改进并不总是意味着发明或引入新的解决方案，有时还需要坚持使用最简单的方法。我并不是说这些解决方案是无效的（我点击upvote是有原因的；），我只是想给出另一个观点。
List <Integer> myList = Lists.newArrayList(1,2,3);

List <Integer> myList = Ints.asList(1,2,3);

public static <E> List<E> asList(@Nullable 
             E first,
             E[] rest)

def list = [5, 6, 7, 8]

MutableList<Integer> list1 = Lists.mutable.with(1).with(2).with(3).with(4);
MutableList<Integer> list2 = Lists.mutable.with(1, 2, 3, 4);
Assert.assertEquals(list1, list2);

MutableIntList primitiveList1 = IntLists.mutable.with(1).with(2).with(3).with(4);
MutableIntList primitiveList2 = IntLists.mutable.with(1, 2, 3, 4);
Assert.assertEquals(primitiveList1, primitiveList2);

public class CollectionChain<T, C extends Collection<T>> {

    public static <T> CollectionChain<T, ArrayList<T>> newArrayList(T inital) {
        return start(new ArrayList<>(), inital);
    }

    public static <T, C extends Collection<T>> CollectionChain<T, C> start(C collection, T inital) {
        return new CollectionChain<>(collection).add(inital);
    }

    private final C collection;

    private CollectionChain(C collection) {
        this.collection = collection;
    }

    public CollectionChain<T, C> add(T value) {
        collection.add(value);
        return this;
    }

    public final CollectionChain<T, C> addAll(T... values) {
        return addAll(Arrays.asList(values));
    }

    public CollectionChain<T, C> addAll(Collection<T> values) {
        collection.addAll(values);
        return this;
    }

    // Add other chained actions

    public C get() {
        return collection;
    }
}

import static project.path.CollectionChain.*;

List<String> chainResult = newArrayList("Needed to properly resolve the type").add("A test").addAll("1", "2").get();