将字符串中的各个字母大写

Question

我正在研究一个面试问题：

将字符串中的第2、4、8、16个字母大写

输入-“字符串中的字母”

输出-“字符串中的字符”

这是我的解决方案：

public static void main(String[] args) {
    String input = "letters in a string";

    String output = input.substring(0, 1) + input.substring(1, 2).toUpperCase() + input.substring(2, 3)
            + input.substring(3, 4).toUpperCase() + input.substring(4, 7) + input.substring(7, 8).toUpperCase()
            + input.substring(8, 15) + input.substring(15, 16).toUpperCase() + input.substring(15);
    System.out.println(output);

}

有什么方法可以在不对偏移号进行硬编码的情况下将其概括化？ 总的来说，我要寻找的是-给定我们要大写的字母号，我们的程序应该在不改变核心逻辑的情况下就此进行工作，并且在复杂性方面也应该高效？

Answer 1

假设您想将字符设置在功率乘以2（2、4、8、16、32、64 ...）的范围内，则可以简单地使用循环。

问题是， String不可变（不能更改），并且应尽可能避免在循环内进行String串联（好的，在您的情况下，这可能没什么大不了，但这仍然是一个好习惯）。

为此，您可以将String转换为char数组（ String#toCharArray() ）或使用StringBuilder ，例如...

String text = "letters in a string";
int index = 2;
StringBuilder sb = new StringBuilder(text);
while (index < sb.length()) {
    sb.setCharAt(index - 1, Character.toUpperCase(sb.charAt(index - 1)));
    index *= 2;
    System.out.println(index);
}

System.out.println(sb.toString());

lEtTers in a stRing输出lEtTers in a stRing

Answer 2

是的，您可以执行此操作而无需对偏移量进行硬编码。 这是一个例子：

int[] toCaps = new int[]{2, 4, 8, 16};
String input = "letters in a string";
String newString = "";
for(int i = 0; i < input.length(); i++){
    boolean b = false;
    for(int j : toCaps){
        if(i == (j-1)){//Subtract 1 since the indexing starts at 0.
            b = true;
        }
    }
    if(b){
        newString += Character.toUpperCase(input.charAt(i));
    }else{
        newString += input.charAt(i);
    }
}
System.out.println(newString);

现在，toCaps数组中的数字将是转换为大写字母的字符串的位置。

Answer 3

也许你可以做类似的事情

public static String capitalize(String s, int[] array)//array would be the indexes you want to be caps.
{
  char[] stringChars = new char[s.length];
  for(int x = 0; x < stringChars.length; x++)
  {
    stringChars[x] = s.charAt(x);
  }
  String finalString;
  boolean matches;
  for(int x = 0; x < stringChars.length; x++)
  {
    for(int y = 0; y < array.length; y++)
    {
      if(array[y] == x)
        {
         matches = true;
         break;
        }
       if(matches == true)
         stringChars[x] = Character.toUppercase(stringChars[x]);
       finalString += stringChars[x];
    }
  }
  return finalString;
}

我尚未测试此代码，可能存在一些错误，但可以正常工作。

Answer 4

正如其他人所述，最好的方法是编写一种可以多次使用的方法。 尝试这个：

public static String capitalize(String string, int[] caps) {
    if (caps[caps.length - 1] > string.length()) {
        return "String not long enough.";
    }
    StringBuilder sb = new StringBuilder(string);
    for (int i : caps) {
        sb.setCharAt(i - 1, Character.toUpperCase(sb.charAt(i - 1)));
    }
    return sb.toString();
}


public static void main(String[] args) {
    int[] caps = {2, 4, 8, 16};
    System.out.println(capitalize("letters in a string", caps));
}

Answer 5

我认为这是最好的方法：

//here index is the nth letter to capitalize, i.e. 2 changes the character
//at index 1, hence the subtraction
public String capitalize(String s, int index)
{
    StringBuilder sb = new StringBuilder(s);
    sb.setCharAt(index - 1, Character.toUpperCase(sb.charAt(index - 1)));
    return (sb.toString());
}

//indices in the array should the follow the same convention as above
public String capitalize(String s, int[] indices)
{
    for (int i = 0; i < indices.length; i++)
    {
        s = Capitalize(s, indices[i]);
    }
    return s;
}

从这里开始，对检索到的输入调用方法很简单。

编辑：返回随机查看之后，在循环中创建StringBuilder可能会很昂贵，因为它仅在一个方法体内有用。 更好的方法是扩展模式，以将StringBuilder引用传递给方法中的字符串（以某种私有方式），以避免始终创建一个新的字符串。

Answer 6

我更安全的实现：

public static String toCapitalizedCase(String givenString) {
    if(TextUtils.isEmpty(givenString)){
        return givenString;
    }
    String[] arr = givenString.toLowerCase().split(" ");
    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < arr.length; i++) {
        sb.append(Character.toUpperCase(arr[i].charAt(0)))
                .append(arr[i].substring(1)).append(" ");
    }
    return sb.toString().trim();
}