cesarvasconcelos · March 4, 2022 16:21
diff --git a/StringMethodsJava.java b/StringMethodsJava.java
 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
    }
 }
	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
	}
	}
No results found