相关疑难解决方法(0)

我一直只是一个人使用:

List<String> names = new ArrayList<>();

我使用接口作为可移植性的类型名称,因此当我问这些问题时,我可以重新编写代码.

何时应该LinkedList使用,ArrayList反之亦然？

在Java的隐藏功能中,最佳答案提到了Double Brace Initialization,它具有非常诱人的语法:

Set<String> flavors = new HashSet<String>() {{
    add("vanilla");
    add("strawberry");
    add("chocolate");
    add("butter pecan");
}};

这个成语创建了一个匿名内部类,其中只包含一个实例初始化程序,"可以使用包含作用域中的任何[...]方法".

主要问题:这听起来效率低吗？它的使用是否应限于一次性初始化？(当然炫耀!)

第二个问题:新的HashSet必须是实例初始化程序中使用的"this"...任何人都可以了解机制吗？

第三个问题:在生产代码中使用这个成语是否过于模糊？

简介:非常非常好的答案,谢谢大家.在问题(3)中,人们认为语法应该是清楚的(尽管我建议偶尔发表评论,特别是如果你的代码会传递给可能不熟悉它的开发人员).

在问题(1)上,生成的代码应该快速运行.额外的.class文件会导致jar文件混乱,并且会稍微减慢程序启动速度(感谢@coobird测量它).@Thilo指出垃圾收集可能会受到影响,在某些情况下,额外加载类的内存成本可能是一个因素.

问题(2)对我来说最有趣.如果我理解答案,那么DBI中发生的事情是匿名内部类扩展了由new运算符构造的对象的类,因此具有引用正在构造的实例的"this"值.井井有条.

总的来说,DBI让我感到非常好奇.Coobird和其他人指出,您可以使用Arrays.asList,varargs方法,Google Collections和提议的Java 7 Collection文字获得相同的效果.Scala,JRuby和Groovy等较新的JVM语言也为列表构建提供了简明的符号,并且与Java良好地互操作.鉴于DBI使类路径混乱,减慢了类加载速度,并使代码更加模糊,我可能会回避它.但是,我打算在一位刚刚获得SCJP的朋友身上发表这篇文章,并且喜欢关于Java语义的好朋友!;-) 感谢大家!

7/2017:Baeldung 对双支撑初始化有很好的总结,并认为它是一种反模式.

12/2017:@Basil Bourque指出,在新的Java 9中你可以说:

Set<String> flavors = Set.of("vanilla", "strawberry", "chocolate", "butter pecan");

这肯定是要走的路.如果您遇到早期版本,请查看Google Collections的ImmutableSet.

假设,我有一个恒定数量的集合(例如3个ArrayLists)作为类的成员.现在,我想将所有元素公开给其他类,以便它们可以简单地遍历所有元素(理想情况下,只读).我正在使用guava集合,我想知道如何使用guava iterables/iterators来生成内部集合的逻辑视图,而无需制作临时副本.

说我有一个 Map<? extends Object, List<String>>

我可以很容易地获得地图的值,并迭代它以生成单个List<String>.

   for (List<String> list : someMap.values()) {
        someList.addAll(list);
    }

有没有办法一次性压扁它？

  List<String> someList = SomeMap.values().flatten();

在阅读这个问题的答案时出现了这个问题 - 如何在java中加入两个列表.这个答案给出了解决方案

List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };

阅读评论,用户说它是邪恶和丑陋的,不应该用于生产.

我想知道使用它有什么害处？为什么在生产中使用它是丑陋的,邪恶的还是坏的？

注意:被问到这是一个问题因为,引用的帖子太旧了(2008年),回答者几个月后就离开了.

如果我想在Java中将两个列表合并为一个,我可以使用ListUtils.union(List list1,List list2).但是,如果我想组合多个列表呢？

这有效:

import org.apache.commons.collections.ListUtils;
List<Integer>list1=Arrays.asList(1,2,3);
List<Integer>list2=Arrays.asList(4,5,6);
List<Integer>list3=Arrays.asList(7,8,9);
List<Integer>list4=Arrays.asList(10,0,-1);
System.out.println(ListUtils.union(ListUtils.union(list1, list2),ListUtils.union(list3, list4)));

但它看起来并不是最好的解决方案,阅读也不是特别好.可悲的ListUtils.union(list1,list2,list3,list4)是不行.使用addAll多次并为所有条目的副本创建自己的列表对我来说似乎并不理想.那么我该怎么做呢？

我想检查branchList是否有相同的元素,如果相同,将branchList和tglList元素分开arraylist并将该arraylist放入另一个arraylist,

我想要的结果是BranchList1有2个arraylist,其中第一个arraylist包含元素'1',第二个arraylist包含元素'2',TglList1有2个arraylist作为元素,但我得到的是第1和第2个数组得到相同的值.

如何才能做到这一点？

ArrayList branchList = new ArrayList();
    branchList.add("1");
    branchList.add("1");
    branchList.add("1");
    branchList.add("2");
    branchList.add("2");
    branchList.add("2");

    ArrayList tglList = new ArrayList();
    tglList.add("5");
    tglList.add("10");
    tglList.add("20");
    tglList.add("100");
    tglList.add("500");
    tglList.add("1000");


    ArrayList newBranchList = new ArrayList();
    ArrayList newTglList = new ArrayList();

    ArrayList BranchList1 = new ArrayList();
    ArrayList TglList1 = new ArrayList();


    ArrayList abc = new ArrayList();
    String checkBranch = new String();

    for(int i=0;i<branchList.size();i++){
        String branch = branchList.get(i).toString();
        if(i==0 || checkBranch.equals(branch)){
            newBranchList.add(branch);
            newTglList.add(tglList.get(i).toString());
        }else{
            BranchList1.add(newBranchList);
            TglList1.add(newTglList);

            newBranchList.clear();
            newTglList.clear();

            newBranchList.add(branch);
            newTglList.add(tglList.get(i).toString());
        }
        if(i==(branchList.size()-1)){
            BranchList1.add(newBranchList);
            TglList1.add(newTglList);
        }
        checkBranch = …

我想简化与ImmutableList.of（）功能相关的现有代码

我曾经尝试通过消除“ new ...”构造函数来优化第二个List的创建，但是我当然不能通过调用.add（）来扩展不可变列表。

当前代码：

static final ImmutableList<ProductCodeEnum> PRODUCTS = ImmutableList.of(ProductCodeEnum.A, ProductCodeEnum.B, ProductCodeEnum.C);


static final ImmutableList<ProductCodeEnum> PRODUCTS_EXTENDED_LIST = new ImmutableList.Builder<ProductCodeEnum>().addAll(PRODUCTS)
.add(ProductCodeEnum.D)
.add(ProductCodeEnum.E)
.build();

预期的代码如下：

static final ImmutableList<ProductCodeEnum> PRODUCTS = ImmutableList.of(ProductCodeEnum.A, ProductCodeEnum.B, ProductCodeEnum.C);


static final ImmutableList<ProductCodeEnum> PRODUCTS_EXTENDED = PRODUCTS + ImmutableList.of(ProductCodeEnum.D, ProductCodeEnum.E);

我有两个List<List<String>>并且想将它们连接起来。

这是我的代码：

List<List<String>> a = Arrays.asList(Arrays.asList("a", "b", "c"));
List<List<String>> b = Arrays.asList(Arrays.asList("d", "e", "f"));
a.addAll(b);

但是，它不起作用并引发异常。

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:148)
    at java.util.AbstractList.add(AbstractList.java:108)
    at java.util.AbstractCollection.addAll(AbstractCollection.java:344)

下面的代码有效：

List<List<String>> a = new ArrayList<>();
a.add(Arrays.asList("a", "b", "c"));
List<List<String>> b = new ArrayList<>();
b.add(Arrays.asList("d", "e", "f"));
a.addAll(b);

这里有什么区别？

我有一个ArrayList如下.

ArrayList<ArrayList<String>> a = new ArrayList<ArrayList<String>>();

其中ArrayList 'a'包含两个StringList的字符串,如下所示.

[a,b,c,d] & [1,2,3,4]

如何将这两个列表合并为一个列表,如下所示.

[a,b,c,d,1,2,3,4]

提前致谢.