如何在不使用 Collections.shuffle(...) 的情况下打乱字符串中的字符？

Question

如何打乱字符串中的字符（例如 hello 可以是 ehlol 或 lleoh 或...）。我不想使用 Collections.shuffle(...) 方法，有没有更简单的方法？

Answer 1

我不知道有什么更简单的事情。但是您可以使用 Math.rand() 功能在字符长度范围内生成一个随机数而无需替换，这将为您提供打乱的输出

public class Shuffle {
    public static void main(String[] args) {
        Shuffle s = new Shuffle();
        s.shuffle("hello");

    }
    public void shuffle(String input){
        List<Character> characters = new ArrayList<Character>();
        for(char c:input.toCharArray()){
            characters.add(c);
        }
        StringBuilder output = new StringBuilder(input.length());
        while(characters.size()!=0){
            int randPicker = (int)(Math.random()*characters.size());
            output.append(characters.remove(randPicker));
        }
        System.out.println(output.toString());
    }
}
/*
Sample outputs
hlleo
llheo
leohl
lleho
*/

Answer 2

性能不是很好，但在我看来相当可读：

public static String shuffleString(String string)
{
  List<String> letters = Arrays.asList(string.split(""));
  Collections.shuffle(letters);
  String shuffled = "";
  for (String letter : letters) {
    shuffled += letter;
  }
  return shuffled;
}

Answer 3

这个怎么样：

public static String shuffle(String text) {
    char[] characters = text.toCharArray();
    for (int i = 0; i < characters.length; i++) {
        int randomIndex = (int)(Math.random() * characters.length);
        char temp = characters[i];
        characters[i] = characters[randomIndex];
        characters[randomIndex] = temp;
    }
    return new String(characters);
}

Answer 4

多么烦人的问题啊。我最终得到了这个：

import java.util.Collections;
import com.google.common.primitives.Chars;
import org.apache.commons.lang3.StringUtils;

String shuffle(String s) {
    List<Character> chars = Chars.asList(s.toCharArray());
    Collections.shuffle(chars);
    return StringUtils.join(chars.stream().toArray());
}

是的，两个库:)

Answer 5

例如：

static String shuffle(String text){
    if (text.length()<=1)
        return text;

    int split=text.length()/2;

    String temp1=shuffle(text.substring(0,split));
    String temp2=shuffle(text.substring(split));

    if (Math.random() > 0.5) 
        return temp1 + temp2;
    else 
        return temp2 + temp1;
}    

Answer 6

class ShuffleString
{

    public static String shuffle(String s)
    {

        String shuffledString = ""; 

        while (s.length() != 0)
        {
            int index = (int) Math.floor(Math.random() * s.length());
            char c = s.charAt(index);
            s = s.substring(0,index)+s.substring(index+1);
            shuffledString += c;
        }

        return shuffledString;

    }

}


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

        String test = "hallo";
        test = ShuffleString.shuffle(test);
        System.out.println(test);
    }
}

输出：
阿赫洛尔

Answer 7

下面的代码既不需要递归，也不需要转换为集合。

public static String shuffle(String string) {
    StringBuilder sb = new StringBuilder(string.length());
    double rnd;
    for (char c: string.toCharArray()) {
        rnd = Math.random();
        if (rnd < 0.34)
            sb.append(c);
        else if (rnd < 0.67)
            sb.insert(sb.length() / 2, c);
        else
            sb.insert(0, c);
    }       
    return sb.toString();
}

Answer 8

不知道为什么你不想使用随机播放，除非是为了学校。 ;)

如果您关心性能，您绝对不能使用任何用“+”连接字符串的解决方案。

这是我能想到的最紧凑的解决方案：

public static String shuffle(String string) {
    if (StringUtils.isBlank(string) {
        return string;
    }

    final List<Character> randomChars = new ArrayList<>();
    CollectionUtils.addAll(randomChars, ArrayUtils.toObject(string.toCharArray()));
    Collections.shuffle(randomChars);
    return StringUtils.join(randomChars, "");
}

Answer 9

没有外部库，对于那些不介意使用 Collections.shuffle() 的人：

static String shuffle(String string){

    List<Character> list = string.chars().mapToObj(c -> new Character((char) c))
                                         .collect(Collectors.toList());
    Collections.shuffle(list);
    StringBuilder sb = new StringBuilder();
    list.forEach(c -> sb.append(c));

    return sb.toString();
}

Answer 10

在 Kotlin 中，您可以执行以下操作。

val helloCharArray = "hello".toCharArray()
helloCharArray.shuffle()
val shuffledHello = helloCharArray.concatToString()

Answer 11

您可以迭代所有字符，将每个字符与下一个字符进行比较。那么如果 Math.rand() > 0.5 将此字符与下一个字符交换，否则移至下一个字符。

Answer 12

        String shuffled;
        do {
            shuffled = Stream.of(text.split("")).sorted((o1, o2) -> ThreadLocalRandom.current().nextInt(3) - 1).collect(Collectors.joining());
        }while(shuffled.equals(text));

Answer 13

如果仍想恢复原来的 String稍后，尝试这样的事情：

public static class ShuffledString
{
    private List<Integer> indices;
    private String string;

    public ShuffledString(List<Integer> indices, String string)
    {
        this.indices = indices;
        this.string = string;
    }

    public List<Integer> getIndices()
    {
        return indices;
    }

    public String getRegularString()
    {
        StringBuilder stringBuilder = new StringBuilder();

        for (int stringIndex = 0; stringIndex < indices.size(); stringIndex++)
        {
            int characterIndex = indices.indexOf(stringIndex);
            stringBuilder.append(string.charAt(characterIndex));
        }

        return stringBuilder.toString();
    }
}

public static ShuffledString shuffle(String input)
{
    List<Integer> indices = new ArrayList<>();

    StringBuilder output = new StringBuilder(input.length());
    while (indices.size() < input.length())
    {
        int randomIndex;

        while (indices.contains(randomIndex = (int) (Math.random() * input.length())))
        {

        }

        indices.add(randomIndex);
        output.append(input.charAt(randomIndex));
    }

    return new ShuffledString(indices, output.toString());
}

Answer 14

在 Java 8+ 中，可以使用 Collectors.shuffle(...) 在三行中完成此操作，如下所示：

1. 将字符串转换为字符列表
2. 随机排列列表
3. 将随机排列的字符列表转换回a String

代码：

public static String shuffle(final String str) {
    List<Character> chars = str.chars().mapToObj(e->(char)e).collect(Collectors.toList());
    Collections.shuffle(chars);
    return chars.stream().map(e->e.toString()).collect(Collectors.joining());
}

演示：

Rextester 演示

Answer 15

使用 commons-lang3：

import org.apache.commons.lang3.ArrayUtils;

String shuffle(String text) {
    char[] chars = text.toCharArray();
    ArrayUtils.shuffle(chars);
    return String.valueOf(chars);
}

Answer 16

使用 Stream API 的另一种简短实现：

 String shuffle(String str) {       
    return new Random().ints(0, str.length()).distinct().limit(str.length()) // shuffle indexes
            .mapToObj(i->""+str.charAt(i)).collect(Collectors.joining());    // collect letters
 }

Answer 17

某些String可能包含由多个字符组成的符号。

为了解决这个问题，您可以将 String 转换为代码点，对数组进行打乱，然后将它们转换回 String。

public static String shuffle(String toShuffle){
    int[] codePoints = toShuffle.codePoints().toArray();
    shuffle(codePoints);
    return new String(codePoints, 0, codePoints.length);
}

可以像 this 或使用任何其他方法来完成数组的洗牌：

//code from https://stackoverflow.com/a/1520212/10871900
private static void shuffle(int[] ar)
  {
    // If running on Java 6 or older, use `new Random()` on RHS here
    Random rnd = ThreadLocalRandom.current();
    for (int i = ar.length - 1; i > 0; i--)
    {
      int index = rnd.nextInt(i + 1);
      // Simple swap
      int a = ar[index];
      ar[index] = ar[i];
      ar[i] = a;
    }
  }

作为性能较差的替代方案，您可以使用包装对象并随机播放流：

public static String shuffle(String toShuffle){
    int[] codePoints = toShuffle
        .codePoints()
        .boxed()
        .sorted((o1, o2) -> ThreadLocalRandom.current().nextInt(-1, 2) //https://stackoverflow.com/a/55352119/10871900 
        .mapToInt(i->i)
        .toArray();
    return new String(codePoints, 0, codePoints.length);
}