Java 如何在不使用集合的情况下洗牌字符串中的字符。洗牌（…）？

如何洗牌字符串中的字符（例如，hello可以是ehlol或lleoh或…）。我不想使用Collections.shuffle（…）方法，有更简单的方法吗？

我不知道更简单的方法。但是，您可以使用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
*/

公共类洗牌{
公共静态void main（字符串[]args）{
洗牌s=新洗牌（）；
s、 洗牌（“你好”）；
}
公共无效洗牌（字符串输入）{
列表字符=新的ArrayList（）；
for（char c:input.toCharArray（））{
字符。添加（c）；
}
StringBuilder输出=新的StringBuilder（input.length（））；
while（characters.size（）！=0）{
int randPicker=（int）（Math.random（）*characters.size（））；
output.append（characters.remove（randPicker））；
}
System.out.println（output.toString（））；
}
}
/*
样本输出
赫利奥
伊洛
莱奥尔
卢埃霍
*/

您可以迭代所有字符，将每个字符与下一个字符进行比较。然后，如果Math.rand（）>0.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;
}    

静态字符串洗牌（字符串文本）{
if（text.length（）0.5）
返回temp1+temp2；
其他的
返回temp2+temp1；
}    

输出：

---

啊哈哈

性能不是很好，但在我看来还是可读的：

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;
}

公共静态字符串shufflesting（字符串）
{
列表字母=array.asList（string.split（“”）；
收藏。洗牌（字母）；
字符串洗牌=”；
for（字符串字母：字母）{
洗牌+=字母；
}
换位；
}

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

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();
}

publicstaticstringshuffle（字符串）{
StringBuilder sb=新的StringBuilder（string.length（））；
双rnd；
for（char c:string.toCharArray（））{
rnd=数学随机（）；
如果（rnd<0.34）
sb.附加（c）；
否则如果（rnd<0.67）
sb.插入（sb.长度（）/2，c）；
其他的
sb.插入（0，c）；
}       
使某人返回字符串（）；
}

不知道为什么你不想使用shuffle，除非是为了上学。；）

如果您关心性能，那么您肯定不能使用任何将字符串与“+”连接起来的解决方案

以下是我能想到的最简洁的解决方案：

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, "");
}

publicstaticstringshuffle（字符串）{
if（StringUtils.isBlank）（字符串）{
返回字符串；
}
最终列表randomChars=新的ArrayList（）；
CollectionUtils.addAll（randomChars、ArrayUtils.toObject（string.tocharray（））；
集合。洗牌（随机字符）；
返回StringUtils.join（randomChars，“”）；
}

这个怎么样：

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);
}

publicstaticstringshuffle（字符串文本）{
char[]characters=text.toCharArray（）；
for（int i=0；i

这是一个多么烦人的问题。我最终得出以下结论：

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());
}

import java.util.Collections；
导入com.google.common.primitives.Chars；
导入org.apache.commons.lang3.StringUtils；
串洗牌（串s）{
List chars=chars.asList（s.tocharray（））；
收藏。洗牌（字符）；
返回StringUtils.join（chars.stream（）.toArray（））；
}

---

是的，有两个库：）

如果以后仍要恢复原始库，请尝试以下操作：

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());
}

公共静态类ShuffledString
{
私人名单索引；
私有字符串；
公共ShuffledString（列表索引、字符串）
{
该指数=指数；
this.string=string；
}
公共列表获取索引（）
{
回报指数；
}
公共字符串getRegularString（）
{
StringBuilder StringBuilder=新的StringBuilder（）；
对于（int-stringIndex=0；stringIndex

无外部库，适用于不介意使用集合的用户。shuffle（）：

静态字符串洗牌（字符串）{
List List=string.chars（）.mapToObj（c->新字符（（char）c））
.collect（Collectors.toList（））；
集合。洗牌（列表）；
StringBuilder sb=新的StringBuilder（）；
list.forEach（c->sb.append（c））；
使某人返回字符串（）；
}

导入java.util.Random；
公共课收费{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
String characters=“AZERTYUIOPQSDFGHJKLMWXCVBNazertyuiopqsdfghjklmwxcvbn1234567890”；
Random rand=新的Random（）；
//诺姆布雷克拉提尔酒店
整数长度=20；
//可变轮胎
字符串随机字符串=”；
//
字符[]文本=新字符[长度]；
for（int i=0；iimport 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());
}

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());
}

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();
}

import java.util.Random;

public class carteRecharge {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String characters = "AZERTYUIOPQSDFGHJKLMWXCVBNazertyuiopqsdfghjklmwxcvbn1234567890";

        Random rand = new Random();

        //Nombre de caratère à tirer 
        int length = 20;

        //La variable qui contiendra le mot tire
        String randomString = "";

        //
        char[] text = new char[length];

        for(int i = 0; i < length; i++) {
            text[i] = characters.charAt(rand.nextInt(characters.length()));

        }


        for(int i=0; i<text.length; i++) {
            randomString += text[i];
        }

        System.out.print(randomString);


    }

}

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());
}

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

import org.apache.commons.lang3.ArrayUtils;

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

 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
 }