Java 如何随机化字符串中字母的大小写

我想为web应用程序身份验证编写一些自动测试。登录密码区分大小写，并且始终至少包含一个字母字符

我想写一个测试，随机改变一个或多个字母字符的大小写

假设密码字符串是

“123te123st！”

现在我想把这个字符串改为至少包含一个大写字母的字符串。我试图确保登录名仍然不区分大小写，任何大小写的变化都将无法匹配密码

有人知道一种优雅的方法吗？我已经搜索过了（包括Apache Commons），但找不到帮助程序方法。

您可以从中查看，但似乎不能保证它有大写字母。要解决这个问题，您可以获取第一个小写字母，并使用

.toUpper（）

方法将其转换为大写

或者，您可以生成介于0和9、65和90、97和122之间的随机数。第一组应该得到随机数，然后你可以将第二个数字转换为一个字符，得到大写字母，并对最后一个数字执行相同的操作，得到小写字母

这就是说，在测试时，通常会选择预先确定的数据，而不是动态生成数据，因为这会使调试更容易。拥有一个简单的密码池也可能更容易实现，并允许您更好地测试边缘情况

class Case
{
  public static void main(String ar[])
  {
    String s = "upperCase",split[];
    split = s.split("");
    int len = s.length(),i=0;
    while(i!=len)
    {
        if(split[i].toUpperCase() == split[i])
        {   
            System.out.println("Password Contains One UpperCase Latter");
            break;
        }
        i++;
    }
  }
}

通过使用此代码，u可以轻松地检查字符串是否包含大写字母。 如果输出打印“Password Contains One Uppercase later”此消息，则字符串至少包含大写字母

在这种情况下，输出如下所示：

---

要生成字符串的所有大写变体，扫描字符串并将每个字母的位置存储在列表中是有意义的。这将允许您在跳过非字母字符的同时迭代字母

例如，对于字符串

“\u a\u b\u c”

，您希望存储位置

[1,3,5]

接下来，制作一个与字母位置列表长度相同的布尔数组。这将表示大小写颠倒的字母的位置

若要生成下一个大写的变量，请假设布尔数组表示一个二进制数。将1添加到该布尔数，这意味着从开始扫描数组，将每个

true

翻转到

false

，直到到达一个

false

，然后翻转到

true

。翻转每个位时，反转字符串中相应字符的大小写

因此，我们得到以下23-1=7个变量的

“\u a\u b\u c”

：

这是一个完整的Java实现

import java.util.*;
import java.io.*;

public class VaryCaps {

  int wordLength,
      numLetters;
  Integer letterPositions[];
  boolean inverted[];
  StringBuffer buffer;

  public VaryCaps(String word) {
    wordLength = word.length();
    List<Integer> positionList = new ArrayList<Integer>();
    for (int i = 0; i < wordLength; ++i) {
      if (Character.isLetter(word.charAt(i))) {
        positionList.add(i);
      }
    }
    numLetters = positionList.size();
    letterPositions = positionList.toArray(new Integer[numLetters]);
    inverted = new boolean[numLetters];
    buffer = new StringBuffer(word);
  }

  private void invert(int index) {
    int pos = letterPositions[index];
    char ch = buffer.charAt(pos);
    if (Character.isUpperCase(ch)) {
      ch = Character.toLowerCase(ch);
    } else {
      ch = Character.toUpperCase(ch);
    }
    buffer.setCharAt(pos, ch);
    inverted[index] = !inverted[index];
  }

  public String next() {
    int index = 0;
    while (index < numLetters && inverted[index]) {
      invert(index++);
    }
    if (index == numLetters) {
      return null;
    }
    invert(index);
    return buffer.toString();
  }

  public static void main(String[] args) {
    VaryCaps rc = new VaryCaps("_a_b_c_");
    String s;
    while ((s = rc.next()) != null) {
      System.out.println(s);
    }
  }
}

import java.util.*；
导入java.io.*；
公共类varycap{
int字长，
努姆莱特；
整数字母位置[]；
布尔倒[]；
字符串缓冲区；
公共VaryCaps（字符串字）{
wordLength=word.length（）；
列表位置列表=新的ArrayList（）；
for（int i=0；i

您可以这样尝试：

public class Test{

    public static void main(String[] args){
        String s = "1a23test12hjsd2"; // Take it as a password
        char[] c= s.toCharArray(); //Convert string in chararray
        boolean flag= false;
        StringBuilder s1= new StringBuilder();
        for(int d:c){
            if(d>=97 && d<=122 && !flag){ //Converting lowercase to upper case
                d=d-32;
                flag=true;
            }
            s1.append((char)d);
        }
        System.out.println(s1);
    }
}

公共类测试{
公共静态void main（字符串[]args）{
String s=“1a23test12hjsd2”；//将其作为密码
char[]c=s.toCharArray（）；//转换chararray中的字符串
布尔标志=假；
StringBuilder s1=新的StringBuilder（）；
对于（int d:c）{
如果（d>=97&&d，则可以使用该类生成随机密码，并对大写字母进行约束

import java.util.Random;

public class RandomPasswordGenerator {
    private static final String ALPHA_CAPS  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String ALPHA   = "abcdefghijklmnopqrstuvwxyz";
    private static final String NUM     = "0123456789";
    private static final String SPL_CHARS   = "!@#$%^&*_=+-/";

    public static char[] generatePswd(int minLen, int maxLen, int noOfCAPSAlpha, 
            int noOfDigits, int noOfSplChars) {
        if(minLen > maxLen)
            throw new IllegalArgumentException("Min. Length > Max. Length!");
        if( (noOfCAPSAlpha + noOfDigits + noOfSplChars) > minLen )
            throw new IllegalArgumentException
            ("Min. Length should be atleast sum of (CAPS, DIGITS, SPL CHARS) Length!");
        Random rnd = new Random();
        int len = rnd.nextInt(maxLen - minLen + 1) + minLen;
        char[] pswd = new char[len];
        int index = 0;
        for (int i = 0; i < noOfCAPSAlpha; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = ALPHA_CAPS.charAt(rnd.nextInt(ALPHA_CAPS.length()));
        }
        for (int i = 0; i < noOfDigits; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = NUM.charAt(rnd.nextInt(NUM.length()));
        }
        for (int i = 0; i < noOfSplChars; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = SPL_CHARS.charAt(rnd.nextInt(SPL_CHARS.length()));
        }
        for(int i = 0; i < len; i++) {
            if(pswd[i] == 0) {
                pswd[i] = ALPHA.charAt(rnd.nextInt(ALPHA.length()));
            }
        }
        return pswd;
    }

    private static int getNextIndex(Random rnd, int len, char[] pswd) {
        int index = rnd.nextInt(len);
        while(pswd[index = rnd.nextInt(len)] != 0);
        return index;
    }
}

import java.util.Random；
公共类随机密码生成器{
私有静态最终字符串ALPHA_CAPS=“abcdefghijklmnopqrstuvxyz”；
私有静态最终字符串ALPHA=“abcdefghijklmnopqrstuvxyz”；
私有静态最终字符串NUM=“0123456789”；
私有静态最终字符串SPL_CHARS=“！@#$%^&*_=+-/”；
公共静态字符[]generatePwd（int-minLen、int-maxLen、int-noOfCAPSAlpha、，
int noOfDigits，int noOfSplChars）{
如果（最小>最大）
抛出新的IllegalArgumentException（“最小长度>最大长度！”）；
if（（noOfCAPSAlpha+noOfDigits+noOfSplChars）>minLen）
抛出新的IllegalArgumentException
（“最小长度应至少为（大写、数字、SPL字符）长度之和！”）；
随机rnd=新随机（）；
int len=rnd.nextInt（maxLen-minLen+1）+minLen；
char[]pswd=新字符[len]；
int指数=0；
对于（int i=0；iimport java.util.Random;

public class RandomPasswordGenerator {
    private static final String ALPHA_CAPS  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String ALPHA   = "abcdefghijklmnopqrstuvwxyz";
    private static final String NUM     = "0123456789";
    private static final String SPL_CHARS   = "!@#$%^&*_=+-/";

    public static char[] generatePswd(int minLen, int maxLen, int noOfCAPSAlpha, 
            int noOfDigits, int noOfSplChars) {
        if(minLen > maxLen)
            throw new IllegalArgumentException("Min. Length > Max. Length!");
        if( (noOfCAPSAlpha + noOfDigits + noOfSplChars) > minLen )
            throw new IllegalArgumentException
            ("Min. Length should be atleast sum of (CAPS, DIGITS, SPL CHARS) Length!");
        Random rnd = new Random();
        int len = rnd.nextInt(maxLen - minLen + 1) + minLen;
        char[] pswd = new char[len];
        int index = 0;
        for (int i = 0; i < noOfCAPSAlpha; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = ALPHA_CAPS.charAt(rnd.nextInt(ALPHA_CAPS.length()));
        }
        for (int i = 0; i < noOfDigits; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = NUM.charAt(rnd.nextInt(NUM.length()));
        }
        for (int i = 0; i < noOfSplChars; i++) {
            index = getNextIndex(rnd, len, pswd);
            pswd[index] = SPL_CHARS.charAt(rnd.nextInt(SPL_CHARS.length()));
        }
        for(int i = 0; i < len; i++) {
            if(pswd[i] == 0) {
                pswd[i] = ALPHA.charAt(rnd.nextInt(ALPHA.length()));
            }
        }
        return pswd;
    }

    private static int getNextIndex(Random rnd, int len, char[] pswd) {
        int index = rnd.nextInt(len);
        while(pswd[index = rnd.nextInt(len)] != 0);
        return index;
    }
}