[RESOLVIDO] - Conversão Camel Case

Programação Java
#1

Boa Noite, pessoal estou com uma dúvida aqui. Tenho esta função toCamelCase que recebe uma string como parâmetro e a converte para o padrão camelcase.
A função abaixo:

public static String toCamelCase(String strData) {
		StringBuilder sb = new StringBuilder();
		StringTokenizer st = new StringTokenizer(strData," ");
		
		while (st.hasMoreTokens()) {
			String strWord = st.nextToken();
			sb.append(Character.toUpperCase(strWord.charAt(0)));
			sb.append(strWord.substring(1).toLowerCase());
		}
		return sb.toString();
	}

Agora o problema. Exemplo: Quando tenho uma string “TESTE DE FUNCIONAMENTO CAMEL CASE” como parametro o returno é igual a “TesteDeFuncionamentoCamelCase”. Porém eu gostaria de manter os espaços, eu sei que poderia concatenar um espaço no final de cada palavra porém suponhamos que temos uma String teste = “TestaNdo CamEl cASE”, isso ai com vários espaços.
Eu gostaria de manter essa quantidade de espaços!!! Por isso que ficou a dúvida, como faço para não perder os espaços de maneira prática sem gambiarra?

Desde já agradeço

#2

Ué, cara…

Se você concatenar os espaços você vai ter exatamente o mesmo número de espaços que tinha antes.

Só pra constar, o camelCase não deve ter espaços.

#3

Argh, StringTokenizer? Eu faria isso assim:

package guj;

/**
 * Concordo que este método "toCamelCase" é mais ineficiente que seu método (que não usa strings intermediárias).
 * Entretanto, escrevi o método desse jeito para ensinar duas coisas:
 * a) Como quebrar o problema em partes reutilizáveis (criei 3 métodos, não um só, e todos os 3 são
 * reutilizáveis)
 * b) Como evitar o uso de StringTokenizer (cujo comportamento é um pouco esquisito, comparando com o de String.split) 
 */
public class TesteCamelCase {
    
    public static String join (String[] parts, String separator) {
        StringBuilder sb = new StringBuilder();
        if (parts.length > 0) {
            sb.append(parts[0]);
            for (int i = 1; i < parts.length; ++i) {
                sb.append (separator).append (parts[i]);
            }
        }
        return sb.toString();
    }
    
    public static String join (String[] parts) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < parts.length; ++i) {
            sb.append (parts[i]);
        }
        return sb.toString();
    }
    
    public static String toCamelCase (String strData, boolean keepBlanks) {
        String[] parts = strData.split("\\s+");
        for (int i = 0; i < parts.length; ++i) {
            if (parts[i].length() > 1)
                parts [i] = Character.toUpperCase(parts[i].charAt(0)) + parts[i].substring(1).toLowerCase();
            else
                parts [i] = parts[i].toUpperCase();
        }
        if (keepBlanks)
            return join (parts, " ");
        else
            return join (parts);
    }
    
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println (toCamelCase ("O TESTE DE FUNCIONAMENTO de CAMEL CASE", false));
        System.out.println (toCamelCase ("TestaNdo o CamEl cASE", true));
    }

}
#4

A propósito, o Rodrigo atentou que se conservar os espaços, isso não seria “CamelCase” mas sim um outro método que existe no Word, que é o de “Capitalize” (deixar as iniciais das palavras em maiúsculas).

Obviamente, um Capitalize mais esperto iria levar em conta algumas regras da língua portuguesa. Na língua portuguesa, ao escrever um título, as iniciais de quase todas as palavras ficam em maíuscula, exceto:
a) Quando elas forem siglas - nesse caso, você deve consultar uma lista de siglas (ONU é toda em maiúsculas, mas Unesp não)
b) Quando forem algumas palavras curtas (normalmente alguns artigos, preposições, e conjunções, como “de”, “da”, “em”, “ao”, “o”, “a”, “que”). Exemplo:

Mensalão: Pena do STF a Marcos Valério já Soma 11 Anos e 8 Meses

No caso acima, temos uma sigla (“STF”), algumas palavras curtas (“a” e “e”).

#5

Então pessoal, obrigado pela ajuda. Sei que o camel case não possui espaços, porém eu queria fazer uma função com o mesmo comportamento da SalStrProperX do centura.
Consegui resolver utilizando o StringTokenizer, segue abaixo o código:

public static String toCamelCase(String strData) {
		StringBuilder sb = new StringBuilder();
		StringTokenizer st = new StringTokenizer(strData, " ", true);
		while (st.hasMoreTokens()) {
			String strWord = st.nextToken();
			sb.append(Character.toUpperCase(strWord.charAt(0)));
			sb.append(strWord.substring(1).toLowerCase());
		}
		return sb.toString();
	}

Falows

#6

Procure não usar classes ultrapassadas que só são mantidas para não quebrar a compatibilidade com código antigo. [quote]StringTokenizer is a legacy class that is retained for compatibility reasons although its use is discouraged in new code. It is recommended that anyone seeking this functionality use the split method of String or the java.util.regex package instead.[/quote]

#7

Sintomas de que o professor de Java não se atualizou:
a) Ensinar StringTokenizer e float (em vez de String.split e double)
b) Ensinar Vector e não usar generics

#8

E o famoso Hashtable, que nem segue o padrão de nomeação de classes.

#9