import java.util.Arrays;
import java.util.List;
import java.util.StringJoiner;
import java.util.stream.IntStream;

public class StringMethodsJava {
    public static void main( String[] args )
    {
        // no Java SE 8, a classe String recebeu atenção especial.
        // é possível fazer bridge entre String e Stream API
        // para criar uma Stream a partir de uma String
        String s = "Java 8 rocks!";
        IntStream stream = s.chars();
        // IntFunction accepts an int-valued argument and produces a result
        // sintaxe: mapToObj(IntFunction<? extends T> mapper)
        stream.mapToObj( value -> (char) value )
              .map( Character::toUpperCase )
              .forEach( System.out::print );

        // antes do Java 7, concatenação de Strings era uma tarefa onerosa
        // havia criação/remoção de múltiplas strings intermediárias,
        String s1 = "Hello";
        String s2 = "World";
        String s3 = s1 + " " + s2; // não era eficiente antes do Java 7

        // alternativa 1: usar StringBuffer---mas StringBuffer é synchronized +lenta :(
        StringBuffer sb = new StringBuffer(  );
        s3 = sb.append( s1 ).append( " " ).append( s2 ).toString();
        //  alternativa 2: usar StringBuilder do Java 5, que NÃO é synchronized +rápida :)
        StringBuilder sbu = new StringBuilder(  );
        s3 = sbu.append( s1 ).append( " " ).append( s2 ).toString();
        // a partir do Java 7, a JVM ficou esperta e compila todas as concatenações com ´+´
        // nos bastidores usando StringBuilder, para fins de otimização
        // para desenvolvedor não se preocupar com concatenações com ´+´

        // no Java SE 8, ficou ainda mais fácil: pode-se agrupar valores String
        // com delimitadores mais facilmente com o método
        // estático String.join() ou usando a classe StringJoiner
        StringJoiner stringJoiner = new StringJoiner( " "  );
        s3 = stringJoiner.add( s1 ).add( s2 ).toString();
        s3 = String.join( " ", s1, s2 ); // faz a mesma coisa que o anterior

        // outro exemplo:
        List<String> lista = Arrays.asList( "Recife", "Campina", "Patos", "Natal" );
        String agrupada = String.join( "#", lista );
        System.out.println( agrupada ); // Recife#Campina#Patos#Natal

        // StringJoiner class. Veja delimitador: "," prefixo: "{" sufixo: "}"
        StringJoiner joiner = new StringJoiner( ",", "{", "}" );
        joiner.setEmptyValue( "{}" ); // o que será impresso se StringJoiner estiver vazia
        System.out.println( joiner ); // vai sair {}

        // adicionando itens na StringJoiner
        // joiner.add( "Recife" ).add( "Campina" ).add( "Patos" ).add( "Natal" );
        lista.forEach( str -> joiner.add( str ) );
        System.out.println( joiner ); // {Recife,Campina,Patos,Natal}

        // merging StringJoiners
        StringJoiner joiner2 = new StringJoiner( "," );
        joiner2.add( "Salvador" ).add( "Aracajú" );

        joiner.merge( joiner2 ); // joiner original irá receber novos itens e ajustar sufixo automati/te
        System.out.println( joiner ); // {Recife,Campina,Patos,Natal,Salvador,Aracajú}

        // Java 11 -> String::repeat()
        String repeat = "+ ".repeat( 16 ); // repeat ==> "+ + + + + + + + + + + + + + + + "

        // Java 11 -> String::isBlank()
        //    true if the string is empty or contains only whitespace codepoints, otherwise false
        String strEspacos = "      ";
        strEspacos.trim().equals( "" ); // true, mas trim é limitado... veja problema abaixo
        // problema: trim não conhece os unicode whitespace code points
        String strEspacos2 = "\n\t\t  java  \u2005";
        strEspacos2.trim().equals( "java" ); // false! ==> "java   " há espaço "\u2005" que sobrou (use strip() :) )
        strEspacos2.isBlank(); // false!, mas
        "\n\t\t    \u2005".isBlank(); // true!

        // Java 11 -> String::strip() (is unicode whitespace aware)
        //    Returns a string whose value is this string, with all leading and trailing white space removed.
        strEspacos2.strip(); // ==> "java" strip conhece os unicode whitespace code points :)

        // Java 11 -> String::lines()
        String multilines = "Primeira linha\nSegunda linha\nTerceira linha";
        multilines.lines().forEach( System.out::println );

        // Java 12 -> String::indent
        String mensagem = "Uma linha".indent( 4 ); // "____Uma linha\n" note o \n adicionado no final
        multilines.indent( 3 ).lines().forEach( System.out::println );
        // "Primeira linha\n"
        // "Segunda linha\n"
        // "Terceira linha\n"
        // "   Primeira linha\n"
        // "   Segunda linha\n"
        // "   Terceira linha\n"

        // Java 12 -> String::transform // transforma a String em um novo objeto mediante função
        // transform(Function<String,R> function)
        multilines.transform( str -> str.replace( "\n", "#" ) )
                  .transform( String::toUpperCase )
                  .lines()
                  .forEach( System.out::println ); // PRIMEIRA LINHA#SEGUNDA LINHA#TERCEIRA LINHA
    }
}