将术语添加到 2d Arraylist 两次

Question

0

上下文：我正在尝试随机打乱 2D arraylist。

例如，如果我有下面的 2d arraylist（在任一方向上都可以），我想根据输入索引将所有类似的值移动到一起（例如，将所有 b 移动到它们各自的开头数组).

[[a,b,c]                               [[b,c,a]

,[a,b,c]                ==>            ,[b,c,a]

,[a,b,c]]                              ,[b,c,a]]

我使用的方法有两个数据结构。将数据添加到新的数据结构中，并从旧的数据结构中删除它，直到所有垂直组都被打乱。

我的第一次尝试是打乱数组的顺序，而不是它们的内容。

我决定先尝试将一组数据添加到新数据结构中，但它会将这些项添加到所有数组中，尽管运行代码行没有那么多次。

例如，如果上面每个 'b' 的值都是 1,2,3 而不是输出 [1][2][3]，它会输出 [1,2,3][1,2, 3][1,2,3]。我已经测试了每一行代码的输出，它会按计划进行，直到 terms2shuffled.get(k).add(intermediateTerms.get(k).get(j));

我的代码：

ArrayList<ArrayList<String>> intermediateTerms = new ArrayList<>();
           terms2shuffled = new ArrayList<>();
           
           ArrayList<String> temp = new ArrayList();
           for(int i = 0;i<columnNumber;i++){
               terms2shuffled.add(temp);
           }
           
           intermediateTerms=terms2;            
           
           int length = intermediateTerms.get(0).size();
               int j = random.nextInt(length);
               for(int k = 0; k<numColumns;k++){
                   System.out.println(intermediateTerms.get(k).get(j));
                   terms2shuffled.get(k).add(intermediateTerms.get(k).get(j));
                   System.out.println(terms2shuffled);

                   //intermediateTerms.remove(j);

（其中 wordsNumber == 行数 NumColumns == 列数）

感谢您的帮助

Answer 1

以下代码行：

ArrayList<String> temp = new ArrayList();
for(int i = 0;i<columnNumber;i++){
    terms2shuffled.add(temp);
}

...为每一行添加相同的 ArrayList 实例，这意味着以下行：

terms2shuffled.get(k).add(intermediateTerms.get(k).get(j));

...将修改该单个实例（因为 terms2shuffled.get(k) 将始终为您提供 temp），这应该解释原因：

it adds the terms to all arrays

您可以试试：

for(int i = 0; i < columnNumber; i++) {
    terms2shuffled.add(new ArrayList<>());
}

为了每一行都有一个单独的 List 实例。

在下面的代码中：

intermediateTerms=terms2;

...我假设terms2是原来的二维列表，所以这里要注意，后面修改intermediateTerms，其实也是在修改terms2 列表，因为它们都指向同一个实例。如果您不想修改原始列表，那么您应该创建它的 深拷贝 ，然后将深拷贝分配给 intermediateTerms。由于 terms2 是二维的，因此简单的 terms2.clone(); 是不够的。

以下 for-循环声明：

for (int k = 0; k < numColumns; k++)

使用 k 作为列的索引，但是在循环体中你使用 k 来获取二维中的 row List。由于您的二维 List 是正方形，因此根本不重要。我只是注意到这一点。据我所知，这可能不会阻止有人将行解释为列，将列解释为行，所以我在这里假设最简单的情况，这就是我注意到这一点的原因。

if I have the 2d arraylist below (which can be as long in either direction), I want to move all like values together according to an input index (e.g. move all b's to the beginning of their respective array).

在你给出的代码中，你似乎只做了一个操作（即移动每一行中的一列，而不是移动每一行中的多列）。相反，您可能希望多次重复该过程，就像这样（在伪代码中）：

deep copy all values from terms2 to the result list.
for each column (named 'c') repeat:
    generate a random column (named 'r') to change its location in each row.
    for each row (in the resulting list) repeat:
        swap column 'c' for 'r' in the row.

但这似乎还不够，因为您只会在每行的基础上随机播放，这意味着例如第二行中的元素将始终保留在第二行中。即使在那之后你打乱了行，仍然有一些元素永远不会离开他们的行。相反，您可能希望在每个单元格的基础上进行洗牌（这样的示例逻辑和代码紧随其后，在此 post 中）。

I am trying to shuffle a 2D arraylist randomly.

随机化二维 List 中所有值的一种方法（在每个单元格的基础上）是：

将二维 List 折叠为单一维度。
单维度随机播放。
从打乱的单一维度重新创建维度 List。

例如：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListUtils {
    
    public static <T> void collapseFrom2D(final List<? extends List<T>> inputList2D,
                                          final List<T> outputList1D) {
        inputList2D.forEach(outputList1D::addAll);
    }
    
    public static <T> void setAll(final Iterator<T> inputIter,
                                  final ListIterator<T> outputIter,
                                  final long limit) {
        for (long i = 0; outputIter.hasNext() && inputIter.hasNext() && i < limit; ++i) {
            outputIter.next();
            outputIter.set(inputIter.next());
        }
    }
    
    public static <T> void setAll(final Iterator<T> inputIter,
                                  final ListIterator<T> outputIter) {
        setAll(inputIter, outputIter, Integer.MAX_VALUE);
    }
    
    public static <T> void expandTo2D(final Iterator<T> inputValuesIter,
                                      final List<? extends List<T>> outputList2D) {
        final Iterator<? extends List<T>> outputIter = outputList2D.iterator();
        while (outputIter.hasNext())
            setAll(inputValuesIter, outputIter.next().listIterator());
    }
    
    public static <T> void expandTo2D(final List<T> inputList1D,
                                      final List<? extends List<T>> outputList2D) {
        expandTo2D(inputList1D.iterator(), outputList2D);
    }
    
    public static <T> void shuffle2D(final List<? extends List<T>> list) {
        final ArrayList<T> singleDimension = new ArrayList<>();
        collapseFrom2D(list, singleDimension);
        Collections.shuffle(singleDimension);
        expandTo2D(singleDimension, list);
    }
    
    public static void main(final String[] args) {
        final ArrayList<List<Integer>> list = new ArrayList<>();
        list.add(Arrays.asList(1, 2));
        list.add(Arrays.asList(3, 4, 5, 6));
        list.add(Collections.emptyList());
        list.add(Arrays.asList(7, 8, 9));
        System.out.println("Before: " + list);
        shuffle2D(list);
        System.out.println("After: " + list);
    }
}

据我了解，这可以概括为 n 维列表或数组。

上面给出的示例代码不必运行在正方形 List 上。它也适用于非矩形 Lists。

将术语添加到 2d Arraylist 两次

Terms adding twice to 2d Arraylist

java

arrays

arraylist