Строка с большой буквы - лучший способ

Question

Какой метод капитализации лучше?

мой:

char[] charArray = string.toCharArray();
charArray[0] = Character.toUpperCase(charArray[0]);
return new String(charArray);

или

commons lang - StringUtils.capitalize:

return new StringBuffer(strLen)
            .append(Character.toTitleCase(str.charAt(0)))
            .append(str.substring(1))
            .toString();

Я думаю, что мой лучше, но я бы лучше спросил.

Answer 1

Полагаю, ваша версия будет немного более производительной, поскольку она не выделяет столько временных объектов String.

Я бы пошел на это (при условии, что строка не пуста):

StringBuilder strBuilder = new StringBuilder(string);
strBuilder.setCharAt(0, Character.toUpperCase(strBuilder.charAt(0))));
return strBuilder.toString();

Однако обратите внимание, что они не эквивалентны в том, что один использует toUpperCase () , а другой использует toTitleCase () .

Из сообщения на форуме :

Заглавная буква <> прописная буква
Unicode определяет три вида отображения случаев: строчные, прописные и заглавные буквы. Разница между прописной и titlecasing персонажа или персонажа последовательность можно увидеть в соединении символы (то есть один символ, который представляет compount из двух символов).

Например, в Unicode символ U + 01F3 - ЛАТИНСКОЕ МАЛЕНЬКОЕ ПИСЬМО DZ. (Позволять мы пишем этот составной символ используя ASCII как "dz".) Этот символ
прописные буквы до символа U + 01F1, LATIN КАПИТАЛ ПИСЬМО ДЗ. (Что составляет
в основном "DZ".) Но это титулы на символ U + 01F2, ЛАТИНСКИЙ КАПИТАЛ
ПИСЬМО D С МАЛЫМ ПИСЬМОМ Z. (Который мы можем написать "Dz".)

character uppercase titlecase
--------- --------- ---------
dz        DZ        Dz

Answer 2

Если бы я писал библиотеку, я бы постарался убедиться, что мой Unicode правильно настроен, прежде чем беспокоиться о производительности. С макушки головы:

int len = str.length();
if (len == 0) {
    return str;
}
int head = Character.toUpperCase(str.codePointAt(0));
String tail = str.substring(str.offsetByCodePoints(0, 1));
return new String(new int[] { head }).concat(tail);

(я бы, вероятно, также посмотрел разницу между заголовком и заглавными буквами до того, как зафиксировал).

Answer 3

Производительность равна.

Ваш код копирует символ [], вызывая string.toCharArray() и new String(charArray).

Код апача на buffer.append(str.substring(1)) и buffer.toString(). В коде apache есть дополнительный строковый экземпляр с содержимым base char [1, length]. Но это не будет скопировано при создании экземпляра String.

Answer 4

StringBuilder (начиная с Java 5 и выше) работает быстрее, чем StringBuffer, если вам не нужно, чтобы он был безопасным для потоков, но, как говорили другие, вам нужно проверить, лучше ли это, чем ваше решение в вашем случае.

Answer 5

StringBuffer объявлен потокобезопасным, поэтому его использование может быть менее эффективным (но не стоит ставить на него, прежде чем делать некоторые практические тесты).

Answer 6

Если вы используете заглавные буквы только для ограниченного числа слов, вам лучше их кэшировать.

@Test
public void testCase()
{
    String all = "At its base, a shell is simply a macro processor that executes commands. The term macro processor means functionality where text and symbols are expanded to create larger expressions.\n" +
            "\n" +
            "A Unix shell is both a command interpreter and a programming language. As a command interpreter, the shell provides the user interface to the rich set of GNU utilities. The programming language features allow these utilities to be combined. Files containing commands can be created, and become commands themselves. These new commands have the same status as system commands in directories such as /bin, allowing users or groups to establish custom environments to automate their common tasks.\n" +
            "\n" +
            "Shells may be used interactively or non-interactively. In interactive mode, they accept input typed from the keyboard. When executing non-interactively, shells execute commands read from a file.\n" +
            "\n" +
            "A shell allows execution of GNU commands, both synchronously and asynchronously. The shell waits for synchronous commands to complete before accepting more input; asynchronous commands continue to execute in parallel with the shell while it reads and executes additional commands. The redirection constructs permit fine-grained control of the input and output of those commands. Moreover, the shell allows control over the contents of commands’ environments.\n" +
            "\n" +
            "Shells also provide a small set of built-in commands (builtins) implementing functionality impossible or inconvenient to obtain via separate utilities. For example, cd, break, continue, and exec cannot be implemented outside of the shell because they directly manipulate the shell itself. The history, getopts, kill, or pwd builtins, among others, could be implemented in separate utilities, but they are more convenient to use as builtin commands. All of the shell builtins are described in subsequent sections.\n" +
            "\n" +
            "While executing commands is essential, most of the power (and complexity) of shells is due to their embedded programming languages. Like any high-level language, the shell provides variables, flow control constructs, quoting, and functions.\n" +
            "\n" +
            "Shells offer features geared specifically for interactive use rather than to augment the programming language. These interactive features include job control, command line editing, command history and aliases. Each of these features is described in this manual.";
    String[] split = all.split("[\\W]");

    // 10000000
    // upper Used 606
    // hash Used 114

    // 100000000
    // upper Used 5765
    // hash Used 1101

    HashMap<String, String> cache = Maps.newHashMap();

    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++)
    {

        String upper = split[i % split.length].toUpperCase();

//            String s = split[i % split.length];
//            String upper = cache.get(s);
//            if (upper == null)
//            {
//                cache.put(s, upper = s.toUpperCase());
// 
//            }
    }
    System.out.println("Used " + (System.currentTimeMillis() - start));
}

Текст выбирается из здесь .

В настоящее время мне нужно прописныеимя таблицы и столбцы, много-много раз, но они ограничены. Использование хэш-карты для кэширования будет лучше.

: -)

Answer 7

/**
     * capitalize the first letter of a string
     * 
     * @param String
     * @return String
     * */
    public static String capitalizeFirst(String s) {
        if (s == null || s.length() == 0) {
            return "";
        }
        char first = s.charAt(0);
        if (Character.isUpperCase(first)) {
            return s;
        } else {
            return Character.toUpperCase(first) + s.substring(1);
        }
    }

Answer 8

используйте этот метод для заглавных букв строки. все работает без ошибок

public String capitalizeString(String value)
{
    String string = value;
    String capitalizedString = "";
    System.out.println(string);
    for(int i = 0; i < string.length(); i++)
    {
        char ch = string.charAt(i);
        if(i == 0 || string.charAt(i-1)==' ')
            ch = Character.toUpperCase(ch);
        capitalizedString += ch;
    }
    return capitalizedString;
}

Answer 9

посмотрите на этот вопрос titlecase-translation . apache FTW.

Answer 10

Не уверен, в чем разница между toUpperCase и toTitleCase, но выглядит так, как будто ваше решение требует на один экземпляр класса String меньше, тогда как реализация commons lang требует двух (substring и toString создают новые строки, которые я предполагаю, поскольку String неизменны).

Является ли это "лучше" (думаю, вы имеете в виду быстрее), я не знаю. Почему вы не профилируете оба решения?