算法如何使用streams将这个程序转换成Java8函数式？

Question

问题
我已经写了一个程序来找出给定字符串中字符大小写的所有可能性

例如， 输入——“ab”/“ab”等——任何一种 输出-[“ab”、“ab”、“ab”、“ab”]

代码

算法不正确-请检查以下内容

public static ArrayList<String> permuteUCLC(String a)
{

    String s=new String(a.toLowerCase());
    ArrayList<String> arr = new ArrayList<>();
    arr.add(a);
    int l = a.length();
    for(int i=0;i<=l;i++)
    {
        for(int j=i+1;j<=l;j++)
        {
            arr.add(s.substring(0,i)+s.substring(i,j).toUpperCase()+s.substring(j,l));
        }
    }
    Collections.sort(arr);
    Collections.reverse(arr);
    return arr;
}

---

小心
问了这个问题后，我意识到我的算法是错误的。我会在适当的时候上传正确的算法

---

子序列代码（正确的代码） 这是查找所有子序列并将其置于上套管的代码。假设所有字符都是唯一的。如何找到索引 并以功能化的方式实现它

public static void permuteSubsequence(String a)
{
    int n=a.length();
    for(int i=0;i<(1<<n);i++)
    {
        String buff="";
        for(int j=0;j<n;j++)
        {
            if(((1<<j)&i)!=0) 
            {
                buff=buff+new Character(a.charAt(j)).toString().toUpperCase();
            }
            else
            {
                buff = buff + a.charAt(j);
            }
        }
        System.out.println(buff);
    }
}

从上面的例子中选取索引。i、 例如，1的索引和大写字母

---

请求

如何使用Java streams将上述代码转换为函数式风格

我面临的问题是在map方法中模拟索引范围。 还有，有没有一种方法可以生成字符串流，将相同的字符串复制到所有元素中，类似于IntStream.range(a,b)

public static List<String> permuteStreams(String a)
{
    int l=(int)(Math.pow(2,a.length())-1)
    ArrayList<String> al = new ArrayList<>();
    for(int i=0;i<=l;i++)
        al.add(a);//Generate a stream and copy back into arraylist maybe if possible?

    List<String> sl = al.stream()
      .map()//incomplete code
      .collect(Collectors.toList());
    return sl;
}

Answer 1

有一些事情需要考虑。首先，流api的构建假设流中的位置与您对每个元素所做的任何操作无关。为了自然地适应这一点，您需要重新设计算法，使其不关心索引号

其次，您没有将任何单个字母映射到任何特定的结果（或结果集），因此使用输入字符串的字符流并没有特别大的帮助。你应该寻找其他可以使用流的东西

您为固定非流方法提出的算法实际上非常适合流式处理——将buff的内容粘贴到流中，并通过流api对其进行所有更改。我认为这应该起到作用：

public static List<String> permuteStreams(String a) {
    Stream<StringBuilder> partialSolutions = Stream.of(new StringBuilder(a.length()));

    for (char c : a.toCharArray()) {
        partialSolutions = partialSolutions.flatMap(solution -> Stream.of(
                new StringBuilder(solution).append(Character.toLowerCase(c)),
                solution.append(Character.toUpperCase(c))));
    }

    return partialSolutions.map(StringBuilder::toString).collect(Collectors.toList());
}

或者，如果您不介意将字符串复制操作大约加倍：

public static List<String> permuteStreams(String a) {
    Stream<String> partialSolutions = Stream.of("");

    for (char c : a.toCharArray()) {
        partialSolutions = partialSolutions.flatMap(solution -> Stream.of(
                solution + Character.toLowerCase(c),
                solution + Character.toUpperCase(c));
    }

    return partialSolutions.collect(Collectors.toList());
}

这样可能会节省一些空间，因为StringBuilder会分配额外的容量，以防您不打算进行添加