Question

说我有一个带有值的arraylist a：

a[0] = G
a[1] = B
a[2] = D

我想知道，如何在java中创建一个新的arraylist，它在随机位置连接索引值并将其放入一个新的arraylist b 所以喜欢：

b[0] = GB
b[1] = D

或

b[0] = G
b[1] = BD

或

b[0] = GBD

值的顺序保持不变，它只是连接的不同组合，并且在不同位置的不同数量。

Answer 1

像（伪代码）

之类的东西

newA = new ArrayList<String>();
for (b : a) {
 if (Math.random() > 0.5) newA.add(b);
 else newA.set(previous, newA.get(previous) + b);
}

Answer 2

假设您可以自己获得“随机位置”，我的想法是使用以下内容：

import org.apache.commons.lang.StringUtils;

public List<String> mergeAt(ArrayList<String> input, int offset) {
    List<String> result = new ArrayList<String>();
    result.add(StringUtils.join(input.subList(0, offset), '');
    result.add(StringUtils.join(input.subList(offset, input.size()), '');
    return result;
}

Answer 3

索引i的第一个合并元素，索引为j：

yourList.set(i, yourList.get(i) + yourList.get(j));

然后删除索引j处的元素：
```
yourList.remove(j);
```

Answer 4

这满足您上面列出的所有条件。您可以将joinIndex和joinSize调整为您想要的任何内容，它将从joinIndex位置开始并连接joinSize个字符。

修正了超出范围的问题。现在它只会在最后连续存在多个字符。

import java.util.ArrayList;
import java.util.List;


public class TestJoiner
{
   public static void main(String[] args){

      List<String> list = new ArrayList<String>();
      list.add("G");
      list.add("B");
      list.add("D");
      list.add("L");
      list.add("G");
      list.add("A");

      //Get Random Int
      int joinIndex=3;
      int joinSize=2;

      //check join size, make sure it doesn't exceed bounds.   
      joinSize=(joinIndex+joinSize+1)>list.size()?list.size()-joinIndex-1:joinSize;

      //join
      for(int a=joinIndex;a<joinIndex+joinSize;a++){
         list.set(joinIndex,list.get(joinIndex)+list.get(a+1));
      }         
      //shift
      for(int c=joinIndex+1;c<list.size()-joinSize;c++){
         list.set(c,list.get(c+joinSize));
      }

      //Truncate
      list=list.subList(0,list.size()-joinSize);

      System.out.println(list);
   }
}

Answer 5

獾。这是任务解决方案。只需使用List<String> Shaker.shake(List<String>)方法。

Shaker 类：

import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;

public class Shaker {
    public static List<String> shake(List<String> sourceList) {
        Random random = new Random();

        // We'll use cloned original list
        LinkedList<String> itemsList = new LinkedList<String>(sourceList);

        // Count how much items need shaking
        int itemsToMerge = itemsList.size();

        // New generated list
        List<String> newList = new ArrayList<String>();

        // Temporary values, used in cycle
        int firstGroupItemIndex = 0;

        while (0 < itemsToMerge) {
            // Select random number of merged items
            int groupLength = random.nextInt(itemsToMerge) + 1;

            // Create inserted string value
            StringBuilder insertedValue = new StringBuilder();
            int lastGroupItemIndex = firstGroupItemIndex + groupLength;
            for (int i = firstGroupItemIndex; i < lastGroupItemIndex; i++) {
                insertedValue.append(itemsList.removeFirst());
            }

            // Add merged string value
            newList.add(insertedValue.toString());
            firstGroupItemIndex = lastGroupItemIndex;

            itemsToMerge -= groupLength;
        }

        return newList;
    }
}

测试类：

import java.util.List;
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        List<String> originalList = new ArrayList<String>();
        originalList.add("G");
        originalList.add("B");
        originalList.add("C");
        originalList.add("L");
        originalList.add("G");
        originalList.add("A");

        List<String> newList = Shaker.shake(originalList);

        System.out.println("Original list: " + originalList);
        System.out.println("Shaked list: " + newList);
    }
}

查看结果：

原始清单：[G，B，C，L，G，A]
Shaked list：[GBC，LG，A]

如果您对代码有疑问，我会高兴地回答您您始终可以在github.com找到解决方案来源。

加入arraylist中的值

5 个答案: