Java String contains(): Verifica se String contém Substring

⚡ Resumo Inteligente

Java O método `contains()` da classe `String` verifica se uma sequência específica de caracteres existe em uma determinada string, retornando um valor booleano `true` ou `false`. Ele diferencia maiúsculas de minúsculas, aceita um argumento do tipo `CharSequence` e é comumente usado dentro de instruções `if` para testes de substring.

  • 🔎 Objetivo: Verifica se um conjunto específico de caracteres faz parte de uma determinada string.
  • Valor de retorno: Retorna o valor booleano verdadeiro se a sequência for uma substring, caso contrário, retorna falso.
  • 🔡 Maiúsculas e minúsculas: Trata letras maiúsculas e minúsculas de forma diferente, portanto “Example” e “example” não correspondem.
  • ⚠️ exceção: Lança uma exceção NullPointerException quando o argumento passado é nulo.
  • 🔁 Uso comum: Frequentemente usado dentro de instruções if-else para testar a existência de uma substring.

Java Método String contém()

Java Método String contém()

O Java String contém() O método é usado para verificar se o conjunto específico de caracteres faz parte de uma determinada string ou não. Ele retorna um valor booleano verdadeiro se os caracteres especificados forem substring de uma determinada string e retorna falso caso contrário. Pode ser usado diretamente dentro da instrução if.

Sintaxe do método contains() em Java

public boolean String.contains(CharSequence s)

Parâmetros Técnicos

s − Esta é a sequência para pesquisar em Java método contém()

Valor de retorno

O método contains() em Java retorna verdadeiro somente se esta string contiver “s”, caso contrário, falso.

Exceção

NullPointerException - se o valor de s for nulo no Java método contém().

Quando usar o método Contains()?

contém() em Java é um caso comum em Java programação quando você quer verificar se uma String específica contém uma substring específica. Por exemplo, se você quer testar se a String “The big red fox” contém a substring “red.” A string contains() em Java método é útil em tal situação.

Java String contém() Método Exemplo 1:

public class Sample_String {
    public static void main(String[] args) {
        String str_Sample = "This is a String contains Example";
        //Check if String contains a sequence
        System.out.println("Contains sequence 'ing': " + str_Sample.contains("ing"));
        System.out.println("Contains sequence 'Example': " + str_Sample.contains("Example"));
        //String contains method is case sensitive
        System.out.println("Contains sequence 'example': " + str_Sample.contains("example"));
        System.out.println("Contains sequence 'is String': " + str_Sample.contains("is String"));
    }
}

Saída esperada:

Contains sequence 'ing': true
Contains sequence 'Example': true
Contains sequence 'example': false
Contains sequence 'is String': false

Java String contém() Método Exemplo 2:

Java Método String contains() na estrutura if else:

public class IfExample {
    public static void main(String args[]) {
        String str1 = "Java string contains If else Example";
        // In If-else statements you can use the contains() method

        if (str1.contains("example")) {
            System.out.println("The Keyword :example: is found in given string");
        } else {
            System.out.println("The Keyword :example: is not found in the string");
        }
    }
}

Resultado esperado:

The Keyword :example: is not found in the string 

Perguntas Frequentes

Sim. O Java O método `contains()` da classe `String` diferencia maiúsculas de minúsculas. Por exemplo, `"String".contains("string")` retorna `false` porque a capitalização difere. Converta ambas as strings para o mesmo formato (maiúsculas e minúsculas) para que a verificação não diferencie maiúsculas de minúsculas.

O método `contains()` retorna um valor booleano: `true` se a sequência de caracteres especificada for encontrada na string e `false` caso contrário. Ele lança uma exceção `NullPointerException` se o argumento for nulo.

A função `contains()` retorna um valor booleano indicando se uma substring existe, enquanto a função `indexOf()` retorna a posição inteira da substring ou -1 se ela não for encontrada. Use `indexOf()` quando precisar da localização.

Os assistentes de IA podem sugerir o método de string correto, gerar exemplos, explicar a distinção entre maiúsculas e minúsculas e detectar erros, como a ausência de verificações de valores nulos. Eles ajudam os iniciantes a usar métodos como `contains()` corretamente.

Sim. As ferramentas de IA podem gerar Java Código que pesquisa strings usando contains(), indexOf() ou expressões regulares, e explica como cada abordagem funciona para diferentes necessidades de correspondência.

Resuma esta postagem com: