HackerRank #12 | Strings Introduction | 🇧🇷
Tags: java, compareto, comparable, substring
Published: 2021-08-26 21:17:38

[Este exercício](https://www.hackerrank.com/challenges/java-strings-introduction/problem) pede que, a partir da entrada de duas strings, o console retorne:

* O número de caracteres através do tamanho da `string` (length)
* `No` para que as strings estejam na ordem alfabética correta ou `Yes` se estiverem na ordem alfabética incorreta ou equivalente*.
* A concatenação das strings, sendo que a primeira letra de cada palavra deve ser impressa em maiúsculo. 

O passo a passo para a resolução desse problema é:

* Declarar uma variável `Scanner`
* Escanear a `String A` e a `String B`
* Somar o tamanho da `String A` com o Tamanho da `String B`
`System.out.println(A.length() + B.length());`
* Usar o método `.compareTo()` para comparar a ordem alfabética da `String A` com a `String B`

#### Interface java.lang.Comparable e método .compareTo()

O método `.compareTo()` faz parte da `interface Comparable` e organiza, por default, em ordem alfanumérica. Isso significa que organize em ordem crescente (para números) ou alfabética (para letras).
Veja o exemplo:

```
public CPF implements Comparable {

    private int numero;

    public int compareTo (CPF novoCPF){

      if (this.numero < outroCPF.numero) {
        return -1;
    }

      if (this.numero > outroCPF.numero) {
        return 1;
    }

      if (this.numero == outroCPF.numero) {
        return 0;
    }
}
```

No primeiro `if`, o `.compareTo()` retorna um número negativo indicando que o `this` deve vir _antes_ de outroCPF. O exemplo usa -1 para ilustrar, mas poderia ser qualquer número negativo.
No segundo `if`, o `.compareTo()` retorna um número positivo para que o `this` venha _depois_ do outroCPF. O exemplo usa 1 para ilustrar, mas poderia ser qualquer número positivo.
No terceiro `if`, se ambos foram iguais, o retorno será 0 e a ordem será mantida. Neste caso, o default é zero (0).

=========

Por fim, a última etapa é a de organizar as strings de forma que a primeira letra de cada palavra fique em maiúsculo. Para isso, usamos o método `substring()`, da classe String.
O método `substring()` retorna outra string, derivada da primeira string.
Aqui alguns exemplos:

```
 "unhappy".substring(2) returns "happy"
 "Harbison".substring(3) returns "bison"
 "emptiness".substring(9) returns "" (an empty string)
```

Quando passamos dois parâmetros na substring (ex: `.substring(0,10)`), significa que estamos selecionando aquela quantidade de caracteres. Exemplo:

```
String stringExemplo = "JavaScript e Java";
String resultado = stringExemplo.substring(0,10)
System.out.println(resultado);

Console:
JavaScript
```

Isso porque a palavra JavaScript tem 10 letras e selecionamos de 0 a 10.
Vamos usar essa seleção, mas de 0 a 1, para pegar a primeira letra das palavras que declararmos nas strings.
Dessa forma, o código vai ficar:

```
        String A1 = (A.substring(0, 1)).toUpperCase() + A.substring(1);
        String B1 = (B.substring(0, 1)).toUpperCase() + B.substring(1);
```

Por fim, somamos `A.substring(1)` e `B.substring(1)` porque precisamos dizer ao computador que voltaremos a imprimir os caracteres (a começar pela posição 1) em letras minúsculas. Sem essa adição, a impressão no console termina na primeira letra maiúscula, deixando de imprimir o resto em minúsculo.
Caso quiséssemos delimitar a quantidade de caracteres minúsculos, poderíamos usar dois parâmetros (1, 10) e depois voltar a imprimir caracteres maiúsculos usando um ou dois parâmetros.

=========

O código final fica assim:

```
    public static void main(String[] args) {
        
        Scanner scanner = new Scanner(System.in);
        String A = scanner.next();
        String B = scanner.next();

        int sum = A.length() + B.length();
        System.out.println(sum);

        if(A.compareTo(B) > 0){
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }

        String A1 = (A.substring(0,1)).toUpperCase() + A.substring(1);
        String B1 = (B.substring(0,1)).toUpperCase() + B.substring(1); ;


        System.out.println(A1 + " " + B1);
        
    }
}
```

=========

* Observação:

> O método compareTo() usa o sistema menor para maior. Sendo assim, A < B < C < D < E ... < Z. Isso significa que, quando mais perto de Z, maior o "valor" de um caracter. E quanto mais perto de A, menor o seu valor. É por isso que pode parecer confuso que uma letra que vem primeiro retorne "No", mas é porque ela é menos "valiosa" do que uma letra que vem depois.

=========

#### Referências:

- [Substring](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#substring(int)) : Oracle
- [CompareTo](https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html) : Oracle
- [CompareTo](https://blog.caelum.com.br/ordenando-colecoes-com-comparable-e-comparator/) : Caelum
- [CompareTo](https://www.guj.com.br/t/usando-compareto/132830/2) : Guj

============

Essa publicação faz parte de uma série de exercícios resolvidos em Java no HackerRank. Acesse a série completa:

- [HackerRank #6 | Scanner e End-of-file](https://dev.to/beatrizmaciel/hackerrank-6-scanner-e-endoffile-462c)
- [HackerRank #7 | Int to String / String to Int](https://dev.to/beatrizmaciel/hackerrank-7-int-em-string-e-vice-versa-4n1e)
- [HackerRank #8 | Date and Time](https://dev.to/beatrizmaciel/hackerrank-8-date-and-time-1f78)
- [HackerRank #9 | Static Initializer Block](https://dev.to/beatrizmaciel/hackerrank-9-static-initializer-block-48ha)
- [HackerRank #10 | Currency Formatter](https://dev.to/beatrizmaciel/hackerrank-10-currency-formatter-22oj)
- [HackerRank #11 | DataTypes](https://dev.to/beatrizmaciel/hackerrank-11-datatypes-2e9h)
- HackerRank #12 | Strings Introduction
- [HackerRank #13 | Substring Comparisons](https://dev.to/beatrizmaciel/hackerrank-13-substring-comparisons-57ha)
- [HackerRank #14 | Abstract Class](https://dev.to/beatrizmaciel/hackerrank-14-abstract-class-3h5d)
- [HackerRank #18 | BigInteger](https://dev.to/beatrizmaciel/hackerrank-18-biginteger-4jad)
- [HackerRank #19 | Loops II](https://dev.to/beatrizmaciel/hackerrank-19-loops-ii-385n)
- [HackerRank #20 | String Reverse](https://dev.to/beatrizmaciel/hackerrank-20-string-reverse-nec)
- [HackerRank #23 | Instanceof keyword](https://dev.to/beatrizmaciel/hackerrank-23-instanceof-keyword-3lh6)
- [HackerRank #26 | Generics](https://dev.to/beatrizmaciel/hackerrank-26-generics-55p8)
- [HackerRank #27 | 1D Array](https://dev.to/beatrizmaciel/hackerrank-27-1d-array-5f80)
- [HackerRank #28 | Anagrams](https://dev.to/beatrizmaciel/hackerrank-28-anagrams-boi)
- [HackerRank #33 | Arraylist](https://dev.to/beatrizmaciel/hackerrank-33-arraylist-2lj1)
- [HackerRank #34 | Exception Handling Try / Catch](https://dev.to/beatrizmaciel/hackerrank-34-exception-handling-try-catch-144f)
- [HackerRank #36 | Exception Handling](https://dev.to/beatrizmaciel/hackerrank-35-exception-handling-44e)
- [HackerRank #37 | List](https://dev.to/beatrizmaciel/hackerrank-37-list-4gmj)
- [HackerRank #38 | SubArray](https://dev.to/beatrizmaciel/hackerrank-38-subarray-1693)
- [HackerRank #39 | HashSet](https://dev.to/beatrizmaciel/hackerrank-39-hashset-3jb3)
- [HackerRank #40 | Java Dequeue](https://dev.to/beatrizmaciel/hackerrank-40-java-dequeue--497h)