Question

我想在迭代期间向arrayList添加一些元素，但是我想在列表的最后添加，我尝试使用ListIterator，但只在实际元素交互后添加...

示例：

ArrayList<Integer> arr = new ArrayList<>(Arrays.asList(new Integer[]{1,2,3,4,5}));      
for (ListIterator<Integer> i = arr.listIterator(); i.hasNext();) {          
    i.add(i.next() + 10);               
}       
System.out.println(arr);

打印：[1, 11, 2, 12, 3, 13, 4, 14, 5, 15]

我需要做些什么才能得到：[1, 2, 3, 4, 5, 11, 12, 13, 14, 15]？

我的问题无法解决创建另一个列表并在...之后使用addAll（）我对这个问题的解释很差，让我更好地解释一下：

ArrayList<SomeClass> arr = new ArrayList<>();               
        int condition = 12; // example contidition number   
        for (ListIterator<SomeClass> i = arr.listIterator(); i.hasNext();) {                        
            if (i.next().conditionNumber == condition) {                
                // add to final of the list to process after all elements.                                                                 
            } else {                
                // process the element.     
                // change the contidition               
                condition = 4; // another example, this number will change many times               
            }                           
        }

我无法创建单独的列表，因为添加到final的元素可能会再次进入条件

由于

Answer 1

由于您使用的是Java 8，因此可以使用Stream API。 Concat原始列表的两个流，其中一个通过向其添加10来映射每个元素。

List<Integer> arr = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = Stream.concat(arr.stream(), arr.stream().map(i -> i + 10))
                             .collect(Collectors.toList());

当您更新问题时，我不明白为什么您无法创建另一个连续更新的列表。这就是我在你的案子中所做的事情。

这里是一个解决方案，它使用基于索引的for循环更新您正在迭代的列表，但不要忘记在开始迭代之前缓存大小，以便您只处理所在的元素处理前的清单。

ArrayList<SomeClass> arr = new ArrayList<>();
int condition = 12; // example contidition number
final int prevSize = arr.size();
for (int i = 0; i < prevSize; i++) {
    SomeClass element = arr.get(i);
    if (element.conditionNumber == condition) {
        //probably update or create a new element here
        arr.add(someNewElement);
    } else {
        // process the element.
        // change the contidition
        condition = 4; // another example, this number will change many times
    }
}

我无法创建单独的列表，因为元素添加到final可能再次进入条件

在我看来，这似乎是一种危险的行为，可能会无限期地将元素添加到列表中，但您可能知道您面临的真正问题。如果你可以试着避免这种情况会更好，IMO。

Answer 2

尝试：

这是dasblinkenlight所说的内容：因为add会添加到当前位置。你需要使用

ArrayList<Integer> arr = new ArrayList<>(Arrays.asList(new Integer[]{1,2,3,4,5}));

ArrayList<Integer> arr1 =new ArrayList<Integer>();

for (ListIterator<Integer> i = arr.listIterator(); i.hasNext();) {          
    arr1.add(i.next() + 10);               
}       

arr.addAll(arr1);
System.out.println(arr);

Answer 3

为什么不使用普通的for？

ArrayList<SomeClass> arr = new ArrayList<>();               
int condition = 12; // example contidition number
for (int i = 0; i < arr.size(); i++) {
    if (arr.get(i).conditionNumber == condition) {
        // add to final of the list to process after all elements.
        arr.add(someNewElement);
    } else {
        // process the element.
        // change the contidition
        condition = 4; // another example, this number will change many times
    }                           
}

不太酷，但应该适合你的情况。

Answer 4

您可以使用可以将两个列表与您的自定义结合起来的collect方法，就像我在下面所做的那样

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

  List<Integer> newList = arr.stream()                                                                         
          .collect(ArrayList<Integer>::new, (list, num) -> {                                                   
              list.add(num);                                                                                   
              list.add(num + 10);                                                                              
          }, ArrayList::addAll)       // this will give us the final list of element num and num+10            
          .stream()                                                                                            
          .sorted()                                                                                            
          .collect(Collectors.toList());                                                                       

  System.out.println(newList );

此处的关键是使用collect <{1}} stream api

方法的以下变体

collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator,BiConsumer<R, R> combiner);
如果可以解决问题，请告诉我。

在arrayList迭代期间添加元素（添加到列表的最后）

4 个答案: