A Classe String Parte 6

`intern()`

intern()– Retorna uma representação canônica para o objeto de sequência.

public String intern() – Retorna uma representação canônica para o objeto de sequência.

Um pool de strings, inicialmente vazio, é mantido em particular pela classe String.

Quando o método interno é chamado, se o pool já contiver uma string igual a esse objeto String, conforme determinado pelo método equals (Object), a string do pool será retornada. Caso contrário, esse objeto String será adicionado ao pool e uma referência a esse objeto String será retornada.

Daqui resulta que, para quaisquer duas cadeias s e t, s.intern () == t.intern () é verdadeira se e somente se s.equals (t) for verdadeira.

Todas as strings literais e expressões constantes com valor de string são internadas. Literais de sequência são definidos na seção 3.10.5 da Especificação de linguagem Java ™.

Retornos:

uma sequência que possui o mesmo conteúdo que essa sequência, mas que é garantida a partir de um conjunto de sequências exclusivas.

Consulte Especificação da linguagem Java:

3.10.5 String Literals

Fonte do código: https://www.javatpoint.com/java-string-intern

public class InternExample{  
public static void main(String args[]){  
String s1=new String("hello");  
String s2="hello";  
String s3=s1.intern();//returns string from pool, now it will be same as s2  
System.out.println(s1==s2);//false because reference variables are pointing to different instance  
System.out.println(s2==s3);//true because reference variables are pointing to same instance  
}}

public class InternExample{

public static void main(String args[]){

String s1=new String("hello");

String s2="hello";

String s3=s1.intern();//returns string from pool, now it will be same as s2

System.out.println(s1==s2);//false because reference variables are pointing to different instance

System.out.println(s2==s3);//true because reference variables are pointing to same instance

}}

isBlank()

isBlank() – Retorna true se a string estiver vazia ou contiver apenas pontos de código de espaço em branco, caso contrário, false.

public boolean isBlank() – Retorna true se a string estiver vazia ou contiver apenas pontos de código de espaço em branco, caso contrário, false.

Retornos:

true se a string estiver vazia ou contiver apenas pontos de código de espaço em branco, caso contrário, false

Esse método existe desde a versão 11.

Veja também:

Character.isWhitespace(int)

Fonte do código: https://howtodoinjava.com/java11/check-blank-string/

public class Main 
{
    public static void main(String[] args) 
    {
        System.out.println( "ABC".isBlank() );          //false
 
        System.out.println( " ABC ".isBlank() );        //false
 
        System.out.println( "  ".isBlank() );           //true
 
        System.out.println( "".isBlank() );             //true
    }
}

public class Main

{

public static void main(String[] args)

{

System.out.println( "ABC".isBlank() ); //false

System.out.println( " ABC ".isBlank() ); //false

System.out.println( " ".isBlank() ); //true

System.out.println( "".isBlank() ); //true

}

isEmpty()

isEmpty() – Retorna true se, e somente se, length () for 0.

public boolean isEmpty() – Retorna true se, e somente se, length () for 0.

Retornos:

true se length () for 0, caso contrário false

Esse método existe desde a versão 1.6.

Fonte do código: https://cursos.alura.com.br/forum/topico-duvida-metodo-isempty-25050

public class TestaString {
     static boolean isNullOrEmpty(String a) {
        return a == null || a.isEmpty();
    } 

    public static void main(String[] args) {
        TestaString ts = new TestaString();
        String stringNula=null;
        System.out.println(ts.isNullOrEmpty(stringNula));
    }
}

public class TestaString {

static boolean isNullOrEmpty(String a) {

return a == null || a.isEmpty();

}

public static void main(String[] args) {

TestaString ts = new TestaString();

String stringNula=null;

System.out.println(ts.isNullOrEmpty(stringNula));

}

join(CharSequence delimiter, CharSequence… elements)

join(CharSequence delimiter, CharSequence… elements) – Retorna uma nova String composta de cópias dos elementos CharSequence unidos a uma cópia do delimitador especificado.

public static String join(CharSequence delimiter, CharSequence… elements) – Retorna uma nova String composta de cópias dos elementos CharSequence unidos a uma cópia do delimitador especificado.

Por exemplo,

     String message = String.join("-", "Java", "is", "cool");
     // message returned is: "Java-is-cool"

1 2	String message = String.join("-", "Java", "is", "cool"); // message returned is: "Java-is-cool"

Observe que se um elemento for nulo, “nulo” será adicionado.

Parâmetros:

delimitador – o delimitador que separa cada elemento
elementos – os elementos para unir.

Retornos:

uma nova String composta pelos elementos separados pelo delimitador

Lança:

NullPointerException – se delimitador ou elementos for nulo

Esse método existe desde a versão 1.8.

Veja também:

StringJoiner

Fonte do código: https://www.journaldev.com/24730/java-string-join

List&lt;String> words = Arrays.asList(new String[] { "Hello", "World", "2019" });
String msg = String.join(" ", words);
System.out.println(msg);

List<String> words = Arrays.asList(new String[] { "Hello", "World", "2019" });

String msg = String.join(" ", words);

System.out.println(msg);

join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

join(CharSequence delimiter, Iterable<? extends CharSequence> elements) – Retorna uma nova String composta de cópias dos elementos CharSequence unidos a uma cópia do delimitador especificado.

public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) – Retorna uma nova String composta de cópias dos elementos CharSequence unidos a uma cópia do delimitador especificado.

Por exemplo,

     List&lt;String> strings = List.of("Java", "is", "cool");
     String message = String.join(" ", strings);
     //message returned is: "Java is cool"

     Set&lt;String> strings =
         new LinkedHashSet&lt;>(List.of("Java", "is", "very", "cool"));
     String message = String.join("-", strings);
     //message returned is: "Java-is-very-cool"

List<String> strings = List.of("Java", "is", "cool");

String message = String.join(" ", strings);

//message returned is: "Java is cool"

Set<String> strings =

new LinkedHashSet<>(List.of("Java", "is", "very", "cool"));

String message = String.join("-", strings);

//message returned is: "Java-is-very-cool"

Observe que, se um elemento individual for nulo, “nulo” será adicionado.

Parâmetros:

delimitador – uma sequência de caracteres usada para separar cada um dos elementos na String resultante
elementos – um Iterável que terá seus elementos unidos.

Retornos:

uma nova String que é composta a partir do argumento dos elementos

Lança:

NullPointerException – se delimitador ou elementos for nulo

Esse método existe desde a versão 1.8.

Veja também:

join(CharSequence,CharSequence...), StringJoiner

Fonte do código: https://www.w3resource.com/java-tutorial/string/string_join.php

import java.util.ArrayList;
import java.util.List;

public class ListJoin {

    public static void main(String[] args) {
        // join(CharSequence delimiter, Iterable&lt;? extends CharSequence> elements)
        List&lt;String> strList = new ArrayList&lt;String>();
        strList.add("w3r");
        strList.add("Join");
        strList.add("Example");
        // joining with comma as delimiter
        String finalStr = String.join(";", strList);
        System.out.println();
        System.out.println("str - " + finalStr);
        System.out.println();
    }
}

import java.util.ArrayList;

import java.util.List;

public class ListJoin {

public static void main(String[] args) {

// join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

List<String> strList = new ArrayList<String>();

strList.add("w3r");

strList.add("Join");

strList.add("Example");

// joining with comma as delimiter

String finalStr = String.join(";", strList);

System.out.println();

System.out.println("str - " + finalStr);

System.out.println();

}

lastIndexOf(int ch)

lastIndexOf(int ch) – Retorna o índice dentro dessa cadeia de caracteres da última ocorrência do caractere especificado.

public int lastIndexOf(int ch) – Retorna o índice dentro dessa cadeia de caracteres da última ocorrência do caractere especificado. Para valores de ch no intervalo de 0 a 0xFFFF (inclusive), o índice (em unidades de código Unicode) retornado é o maior valor k, de modo que:

this.charAt(k) == ch

é verdade. Para outros valores de ch, é o maior valor k, de modo que:

this.codePointAt(k) == ch

é verdade. Nos dois casos, se esse caractere não ocorrer nessa sequência, -1 será retornado. A String é pesquisada para trás, iniciando no último caractere.

Parâmetros:

ch – um caractere (ponto de código Unicode).

Retornos:

o índice da última ocorrência do caractere na sequência de caracteres representada por esse objeto, ou -1 se o caractere não ocorrer.

Código fonte: https://beginnersbook.com/2013/12/java-string-lastindexof-method-example/

public class JavaExample {  
   public static void main(String[] args) {  
	String str = "beginnersbook is for beginners";
	char ch = 'b';
	char ch2 = 's';
	String subStr = "beginners";
	int posOfB = str.lastIndexOf(ch);
	int posOfS = str.lastIndexOf(ch2);
	int posOfSubstr = str.lastIndexOf(subStr);
	System.out.println(posOfB);
	System.out.println(posOfS);
	System.out.println(posOfSubstr);
   }  
}

public class JavaExample {

public static void main(String[] args) {

String str = "beginnersbook is for beginners";

char ch = 'b';

char ch2 = 's';

String subStr = "beginners";

int posOfB = str.lastIndexOf(ch);

int posOfS = str.lastIndexOf(ch2);

int posOfSubstr = str.lastIndexOf(subStr);

System.out.println(posOfB);

System.out.println(posOfS);

System.out.println(posOfSubstr);

}

lastIndexOf(int ch, int fromIndex)

lastIndexOf(int ch, int fromIndex) – Retorna o índice dentro dessa cadeia de caracteres da última ocorrência do caractere especificado, pesquisando para trás, iniciando no índice especificado.

public int lastIndexOf(int ch, int fromIndex) – Retorna o índice dentro dessa cadeia de caracteres da última ocorrência do caractere especificado, pesquisando para trás, iniciando no índice especificado. Para valores de ch no intervalo de 0 a 0xFFFF (inclusive), o índice retornado é o maior valor k, de modo que:

(this.charAt(k) == ch) && (k <= fromIndex)

é verdade. Para outros valores de ch, é o maior valor k, de modo que:

(this.codePointAt(k) == ch) && (k <= fromIndex)

é verdade. Nos dois casos, se esse caractere não ocorrer nessa seqüência na posição ou antes do índice, -1 será retornado.

Todos os índices são especificados em valores de caracteres (unidades de código Unicode).

Parâmetros:

ch – um caractere (ponto de código Unicode).

fromIndex – o índice para iniciar a pesquisa. Não há restrição no valor de fromIndex. Se for maior que ou igual ao comprimento dessa string, terá o mesmo efeito que se fosse igual a um menor que o comprimento dessa string: essa string inteira poderá ser pesquisada. Se for negativo, terá o mesmo efeito como se fosse retornado -1: -1.

Retornos:

o índice da última ocorrência do caractere na sequência de caracteres representada por este objeto que é menor ou igual a fromIndex, ou -1 se o caractere não ocorrer antes desse ponto.

Código fonte: https://www.tutorialspoint.com/java/java_string_lastindexof_chfromindex.htm

import java.io.*;
public class Test {

   public static void main(String args[]) {
      String Str = new String("Welcome to Tutorialspoint.com");
      System.out.print("Found Last Index :" );
      System.out.println(Str.lastIndexOf( 'o', 5 ));
   }
}

import java.io.*;

public class Test {

public static void main(String args[]) {

String Str = new String("Welcome to Tutorialspoint.com");

System.out.print("Found Last Index :" );

System.out.println(Str.lastIndexOf( 'o', 5 ));

}

lastIndexOf(String str)

lastIndexOf(String str) – Retorna o índice nessa sequência da última ocorrência da substring especificada.

public int lastIndexOf(String str) – Retorna o índice nessa sequência da última ocorrência da substring especificada, pesquisando para trás, iniciando no índice especificado.

O índice retornado é o maior valor k para o qual:

     k &lt;= Math.min(fromIndex, this.length()) &amp;&amp;
                   this.startsWith(str, k)

1 2	k <= Math.min(fromIndex, this.length()) && this.startsWith(str, k)

Se não existir esse valor de k, -1 será retornado.

Parâmetros:

str – a substring a ser pesquisada.
fromIndex – o índice para iniciar a pesquisa.

Retornos:

o índice da última ocorrência da substring especificada, pesquisando para trás a partir do índice especificado ou -1 se não houver essa ocorrência.

Código fonte: https://www.tutorialspoint.com/java/java_string_lastindexof_str.htm

import java.io.*;
public class Test {

   public static void main(String args[]) {
      String Str = new String("Welcome to Tutorialspoint.com");
      String SubStr1 = new String("Tutorials" );
      System.out.print("Found Last Index :" );
      System.out.println( Str.lastIndexOf( SubStr1 ));
   }
}

import java.io.*;

public class Test {

public static void main(String args[]) {

String Str = new String("Welcome to Tutorialspoint.com");

String SubStr1 = new String("Tutorials" );

System.out.print("Found Last Index :" );

System.out.println( Str.lastIndexOf( SubStr1 ));

}

lastIndexOf(String str, int fromIndex)

lastIndexOf(String str, int fromIndex) – Retorna o índice nessa sequência da última ocorrência da substring especificada, pesquisando para trás, iniciando no índice especificado.

public int lastIndexOf(String str, int fromIndex) – Retorna o índice nessa sequência da última ocorrência da substring especificada, pesquisando para trás, iniciando no índice especificado.

O índice retornado é o maior valor k para o qual:

     k &lt;= Math.min(fromIndex, this.length()) &amp;&amp;
                   this.startsWith(str, k)

1 2	k <= Math.min(fromIndex, this.length()) && this.startsWith(str, k)

Se não existir esse valor de k, -1 será retornado.

Parâmetros:

str – a substring a ser pesquisada.
fromIndex – o índice para iniciar a pesquisa.

Retornos:

o índice da última ocorrência da substring especificada, pesquisando para trás a partir do índice especificado ou -1 se não houver essa ocorrência.

Código fonte: https://www.tutorialspoint.com/java/lang/string_lastindexof_string_index.htm

package com.tutorialspoint;

import java.lang.*;

public class StringDemo {

   public static void main(String[] args) {

      String str1 = "Collections of tutorials at tutorials point";
     
      /* search starts from index 17 and if located it returns 
         the index of the first character of the last substring "tutorials" */
      System.out.println("index = " + str1.lastIndexOf("tutorials", 17)); 

      /* search starts from index 9 and returns -1 as substring "admin"
         is not located */
      System.out.println("index = " + str1.lastIndexOf("admin", 9));     
   }
}

package com.tutorialspoint;

import java.lang.*;

public class StringDemo {

public static void main(String[] args) {

String str1 = "Collections of tutorials at tutorials point";

/* search starts from index 17 and if located it returns

the index of the first character of the last substring "tutorials" */

System.out.println("index = " + str1.lastIndexOf("tutorials", 17));

/* search starts from index 9 and returns -1 as substring "admin"

is not located */

System.out.println("index = " + str1.lastIndexOf("admin", 9));

}

length()

length() – Retorna o comprimento dessa string.

public int length() – Retorna o comprimento dessa string. O comprimento é igual ao número de unidades de código Unicode na cadeia de caracteres.

Especificado por:

length in interface CharSequence

Retornos:

o comprimento da sequência de caracteres representados por este objeto.

Código fonte: https://www.javatpoint.com/java-string-length

public class LengthExample{  
public static void main(String args[]){  
String s1="javatpoint";  
String s2="python";  
System.out.println("string length is: "+s1.length());//10 is the length of javatpoint string  
System.out.println("string length is: "+s2.length());//6 is the length of python string  
}}

public class LengthExample{

public static void main(String args[]){

String s1="javatpoint";

String s2="python";

System.out.println("string length is: "+s1.length());//10 is the length of javatpoint string

System.out.println("string length is: "+s2.length());//6 is the length of python string

}}

lines()

lines() – Retorna um fluxo de linhas extraídas dessa sequência, separadas por terminadores de linha.

public Stream<String> lines() – Retorna um fluxo de linhas extraídas dessa sequência, separadas por terminadores de linha.

Um terminador de linha é um dos seguintes: um caractere de avanço de linha “\ n” (U + 000A), um caractere de retorno de carro “\ r” (U + 000D) ou um retorno de carro seguido imediatamente por um avanço de linha “\ r \ n “(U + 000D U + 000A).

Uma linha é uma sequência de zero ou mais caracteres seguida por um terminador de linha ou é uma sequência de um ou mais caracteres seguida pelo final da sequência. Uma linha não inclui o terminador de linha.

O fluxo retornado por esse método contém as linhas dessa sequência na ordem em que ocorrem.

Nota da API:

Essa definição de linha implica que uma string vazia possui zero linhas e que não há uma linha vazia após um terminador de linha no final de uma string.

Nota da Implementação:

Esse método fornece um desempenho melhor que o split (“\ R”) fornecendo elementos preguiçosamente e pesquisando mais rapidamente os novos terminadores de linha.

Retornos:

o fluxo de linhas extraídas dessa sequência

Esse método existe desde a versão 11.

Fonte do código: https://howtodoinjava.com/java11/string-to-stream-of-lines/

import java.io.IOException;
import java.util.stream.Stream;
 
public class Main 
{
    public static void main(String[] args) 
    {
        try
        {
            String str = "A \n B \n C \n D"; 
 
            Stream&lt;String> lines = str.lines();
 
            lines.forEach(System.out::println);
        } 
        catch (IOException e) 
        {
            e.printStackTrace();
        }
    }
}

import java.io.IOException;

import java.util.stream.Stream;

public class Main

{

public static void main(String[] args)

{

try

{

String str = "A \n B \n C \n D";

Stream<String> lines = str.lines();

lines.forEach(System.out::println);

}

catch (IOException e)

{

e.printStackTrace();

}

matches(String regex)

matches(String regex) – Informa se essa sequência corresponde ou não à expressão regular especificada.

public boolean matches(String regex) – Informa se essa sequência corresponde ou não à expressão regular especificada.

Uma invocação desse método no formato str.matches (regex) produz exatamente o mesmo resultado que a expressão

Pattern.matches(regex, str)

Parâmetros:

regex – a expressão regular à qual essa sequência deve ser correspondida

Retornos:

true se, e somente se, essa sequência corresponder à expressão regular fornecida

Lança:

PatternSyntaxException – se a sintaxe da expressão regular for inválida

Esse método existe desde a versão 1.4.

Veja também:

Pattern

Fonte do código: https://www.vogella.com/tutorials/JavaRegularExpressions/article.html

package de.vogella.regex.test;

public class RegexTestStrings {
    public static final String EXAMPLE_TEST = "This is my small example "
            + "string which I'm going to " + "use for pattern matching.";

    public static void main(String[] args) {
        System.out.println(EXAMPLE_TEST.matches("\\w.*"));
        String[] splitString = (EXAMPLE_TEST.split("\\s+"));
        System.out.println(splitString.length);// should be 14
        for (String string : splitString) {
            System.out.println(string);
        }
        // replace all whitespace with tabs
        System.out.println(EXAMPLE_TEST.replaceAll("\\s+", "\t"));
    }
}

package de.vogella.regex.test;

public class RegexTestStrings {

public static final String EXAMPLE_TEST = "This is my small example "

+ "string which I'm going to " + "use for pattern matching.";

public static void main(String[] args) {

System.out.println(EXAMPLE_TEST.matches("\\w.*"));

String[] splitString = (EXAMPLE_TEST.split("\\s+"));

System.out.println(splitString.length);// should be 14

for (String string : splitString) {

System.out.println(string);

}

// replace all whitespace with tabs

System.out.println(EXAMPLE_TEST.replaceAll("\\s+", "\t"));

}

Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/String.html

`intern()`

isBlank()

isEmpty()

join(CharSequence delimiter, CharSequence… elements)

join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

lastIndexOf(int ch)

lastIndexOf(int ch, int fromIndex)

lastIndexOf(String str)

lastIndexOf(String str, int fromIndex)

length()

lines()

matches(String regex)

Classe Controller

Certificação 1Z0-829 – Dia 5

Linguagens de Programação são Necessárias para se Comunicar com um Computador

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

intern()

isBlank()

isEmpty()

join​(CharSequence delimiter, CharSequence… elements)

join​(CharSequence delimiter, Iterable<? extends CharSequence> elements)

lastIndexOf​(int ch)

lastIndexOf​(int ch, int fromIndex)

lastIndexOf​(String str)

lastIndexOf​(String str, int fromIndex)

length()

lines()

matches​(String regex)

Classe Controller

Certificação 1Z0-829 – Dia 5

Linguagens de Programação são Necessárias para se Comunicar com um Computador

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

`intern()`

join(CharSequence delimiter, CharSequence… elements)

join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

lastIndexOf(int ch)

lastIndexOf(int ch, int fromIndex)

lastIndexOf(String str)

lastIndexOf(String str, int fromIndex)

matches(String regex)