Come posso verificare se un singolo carattere appare in una stringa?

In Java c'è un modo per verificare la condizione:

"Questo singolo carattere appare affatto nella stringa x"

senza usare un ciclo?

È possibile utilizzare string.indexOf('a').

Se il carattere aè presente in string:

restituisce l'indice della prima occorrenza del carattere nella sequenza di caratteri rappresentata da questo oggetto, oppure -1 se il carattere non si verifica.

• String.contains() che controlla se la stringa contiene una sequenza specificata di valori char
• String.indexOf() che restituisce l'indice all'interno della stringa della prima occorrenza del carattere o della sottostringa specificata (ci sono 4 varianti di questo metodo)

Non sono sicuro di cosa chieda esattamente il poster originale. Dato che indexOf (...) e contiene (...) entrambi usano probabilmente i cicli internamente, forse sta cercando di vedere se ciò è possibile senza un ciclo? Posso pensare a due mani fuori mano, una ovviamente sarebbe la ricorrenza:

public boolean containsChar(String s, char search) {
    if (s.length() == 0)
        return false;
    else
        return s.charAt(0) == search || containsChar(s.substring(1), search);
}

L'altro è molto meno elegante, ma completezza ...:

/**
 * Works for strings of up to 5 characters
 */
public boolean containsChar(String s, char search) {
    if (s.length() > 5) throw IllegalArgumentException();

    try {
        if (s.charAt(0) == search) return true;
        if (s.charAt(1) == search) return true;
        if (s.charAt(2) == search) return true;
        if (s.charAt(3) == search) return true;
        if (s.charAt(4) == search) return true;
    } catch (IndexOutOfBoundsException e) {
        // this should never happen...
        return false;
    }
    return false;
}

Il numero di linee aumenta man mano che è necessario supportare stringhe sempre più lunghe. Ma non ci sono loop / recidive. Puoi anche rimuovere il controllo della lunghezza se sei preoccupato che quella lunghezza () usi un ciclo.

String temp = "abcdefghi";
if(temp.indexOf("b")!=-1)
{
   System.out.println("there is 'b' in temp string");
}
else
{
   System.out.println("there is no 'b' in temp string");
}

Puoi usare 2 metodi dalla Stringclasse.

• String.contains() che controlla se la stringa contiene una sequenza specificata di valori char
• String.indexOf() che restituisce l'indice all'interno della stringa della prima occorrenza del carattere o della sottostringa specificata o restituisce -1 se il carattere non viene trovato (esistono 4 varianti di questo metodo)

Metodo 1:

String myString = "foobar";
if (myString.contains("x") {
    // Do something.
}

Metodo 2:

String myString = "foobar";
if (myString.indexOf("x") >= 0 {
    // Do something.
}

Collegamenti di: Zach Scrivena

Per verificare se qualcosa non esiste in una stringa, devi almeno guardare ogni carattere in una stringa. Quindi, anche se non usi esplicitamente un loop, avrà la stessa efficienza. Detto questo, puoi provare a usare str.contains ("" + char).

Se è necessario controllare spesso la stessa stringa, è possibile calcolare in anticipo le occorrenze dei caratteri. Questa è un'implementazione che utilizza un array di bit contenuto in un array lungo:

public class FastCharacterInStringChecker implements Serializable {
private static final long serialVersionUID = 1L;

private final long[] l = new long[1024]; // 65536 / 64 = 1024

public FastCharacterInStringChecker(final String string) {
    for (final char c: string.toCharArray()) {
        final int index = c >> 6;
        final int value = c - (index << 6);
        l[index] |= 1L << value;
    }
}

public boolean contains(final char c) {
    final int index = c >> 6; // c / 64
    final int value = c - (index << 6); // c - (index * 64)
    return (l[index] & (1L << value)) != 0;
}}

Sì, utilizzando il metodo indexOf () sulla classe di stringhe. Consulta la documentazione API per questo metodo

package com;
public class _index {

    public static void main(String[] args) {
        String s1="be proud to be an indian";
        char ch=s1.charAt(s1.indexOf('e'));
        int count = 0; 
        for(int i=0;i<s1.length();i++) {
            if(s1.charAt(i)=='e'){
                System.out.println("number of E:=="+ch);
                count++;
            }
        }
        System.out.println("Total count of E:=="+count);
    }
}

String s="praveen";
boolean p=s.contains("s");
if(p)
    System.out.println("string contains the char 's'");
else
    System.out.println("string does not contains the char 's'");

Produzione

string does not contains the char 's'

static String removeOccurences(String a, String b)
{
    StringBuilder s2 = new StringBuilder(a);

    for(int i=0;i<b.length();i++){
        char ch = b.charAt(i);  
        System.out.println(ch+"  first index"+a.indexOf(ch));

        int lastind = a.lastIndexOf(ch);

    for(int k=new String(s2).indexOf(ch);k > 0;k=new String(s2).indexOf(ch)){
            if(s2.charAt(k) == ch){
                s2.deleteCharAt(k);
        System.out.println("val of s2 :             "+s2.toString());
            }
        }
      }

    System.out.println(s1.toString());

    return (s1.toString());
}

you can use this code. It will check the char is present or not. If it is present then the return value is >= 0 otherwise it's -1. Here I am printing alphabets that is not present in the input.

import java.util.Scanner;

public class Test {

public static void letters()
{
    System.out.println("Enter input char");
    Scanner sc = new Scanner(System.in);
    String input = sc.next();
    System.out.println("Output : ");
    for (char alphabet = 'A'; alphabet <= 'Z'; alphabet++) {
            if(input.toUpperCase().indexOf(alphabet) < 0) 
                System.out.print(alphabet + " ");
    }
}
public static void main(String[] args) {
    letters();
}

}

//Ouput Example
Enter input char
nandu
Output : 
B C E F G H I J K L M O P Q R S T V W X Y Z

Di seguito è quello che stavi cercando?

int index = string.indexOf(character);
return index != -1 && string.lastIndexOf(character) != index;

Non sarai in grado di verificare se il carattere appare affatto in una stringa senza che almeno una volta superi la stringa una volta usando loop / ricorsione (i metodi integrati come indexOf usano anche un ciclo)

Se il no. di volte cerchi se un carattere è nella stringa x è molto più lungo della lunghezza della stringa di quanto consiglierei di usare una struttura di dati Set in quanto sarebbe più efficiente del semplice utilizzoindexOf

String s = "abc";

// Build a set so we can check if character exists in constant time O(1)
Set<Character> set = new HashSet<>();
int len = s.length();
for(int i = 0; i < len; i++) set.add(s.charAt(i));

// Now we can check without the need of a loop
// contains method of set doesn't use a loop unlike string's contains method
set.contains('a') // true
set.contains('z') // false

Usando set sarai in grado di verificare se il carattere esiste in una stringa in tempo costante O (1) ma utilizzerai anche memoria aggiuntiva (la complessità dello spazio sarà O (n)).

Ho usato il metodo string.includes () per questo che restituisce vero o falso se viene trovata la stringa o il carattere. Vedi la documentazione qui sotto.

https://www.w3schools.com/jsref/jsref_includes.asp

// questo è solo il principale ... puoi usare un lettore o uno scanner con buffer

string s;
int l=s.length();
int f=0;
for(int i=0;i<l;i++)
   {
      char ch1=s.charAt(i); 
      for(int j=0;j<l;j++)
         {
          char ch2=charAt(j);
          if(ch1==ch2)
           {
             f=f+1;
             s.replace(ch2,'');
           }
          f=0;
          }
     }
//if replacing with null does not work then make it space by using ' ' and add a if condition on top.. checking if its space if not then only perform the inner loop...