Question

我正在处理一个面试问题：

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

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

输出 - “在一个stRing中的lEtTers”

这是我的解决方案：

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

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

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

6 个答案: