Wie kann ich überprüfen, ob ein einzelnes Zeichen in einer Zeichenfolge angezeigt wird?

In Java gibt es eine Möglichkeit, den Zustand zu überprüfen:

"Erscheint dieses einzelne Zeichen überhaupt in Zeichenfolge x?"

ohne Schleife?

Sie können verwenden string.indexOf('a').

Wenn das Zeichen avorhanden ist in string:

Es gibt den Index des ersten Auftretens des Zeichens in der durch dieses Objekt dargestellten Zeichenfolge zurück oder -1, wenn das Zeichen nicht vorkommt.

• String.contains() Hiermit wird überprüft, ob die Zeichenfolge eine bestimmte Folge von Zeichenwerten enthält
• String.indexOf() Dies gibt den Index innerhalb der Zeichenfolge des ersten Auftretens des angegebenen Zeichens oder Teilstrings zurück (es gibt 4 Variationen dieser Methode).

Ich bin mir nicht sicher, was das Originalplakat genau verlangt. Da indexOf (...) und enthält (...) wahrscheinlich beide intern Schleifen verwenden, möchte er vielleicht sehen, ob dies überhaupt ohne Schleife möglich ist? Ich kann mir zwei Möglichkeiten vorstellen, eine wäre natürlich eine Wiederholung:

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

Der andere ist weit weniger elegant, aber die Vollständigkeit ...:

/**
 * 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;
}

Die Anzahl der Zeilen wächst, da Sie natürlich immer längere Zeichenfolgen unterstützen müssen. Es gibt jedoch überhaupt keine Schleifen / Wiederholungen. Sie können die Längenprüfung sogar entfernen, wenn Sie befürchten, dass diese Länge () eine Schleife verwendet.

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");
}

Sie können 2 Methoden aus der StringKlasse verwenden.

• String.contains() Hiermit wird überprüft, ob die Zeichenfolge eine bestimmte Folge von Zeichenwerten enthält
• String.indexOf() Dies gibt den Index innerhalb der Zeichenfolge des ersten Auftretens des angegebenen Zeichens oder Teilstrings zurück oder gibt -1 zurück, wenn das Zeichen nicht gefunden wird (es gibt 4 Variationen dieser Methode).

Methode 1:

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

Methode 2:

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

Links von: Zach Scrivena

Um zu überprüfen, ob in einer Zeichenfolge etwas nicht vorhanden ist, müssen Sie sich zumindest jedes Zeichen in einer Zeichenfolge ansehen. Selbst wenn Sie eine Schleife nicht explizit verwenden, hat sie die gleiche Effizienz. Davon abgesehen können Sie versuchen, str.contains ("" + char) zu verwenden.

Wenn Sie dieselbe Zeichenfolge häufig überprüfen müssen, können Sie die Zeichenvorkommen im Voraus berechnen. Dies ist eine Implementierung, die ein Bit-Array verwendet, das in einem langen Array enthalten ist:

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;
}}

Ja, mit der indexOf () -Methode für die Zeichenfolgenklasse. Weitere Informationen zu dieser Methode finden Sie in der API-Dokumentation

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'");

Ausgabe

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

Ist das unten, wonach Sie gesucht haben?

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

Sie können nicht überprüfen, ob char in einer Zeichenfolge überhaupt angezeigt wird, ohne die Zeichenfolge mindestens einmal mit loop / recursion zu durchlaufen (die integrierten Methoden wie indexOf verwenden auch eine Schleife).

Wenn die Nr. Wenn Sie nachsehen, ob sich ein Zeichen in der Zeichenfolge x befindet, ist dies mehr als die Länge der Zeichenfolge, als ich die Verwendung einer Set- Datenstruktur empfehlen würde, da dies effizienter wäre als die einfache VerwendungindexOf

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

Mit set können Sie überprüfen, ob das Zeichen in einer Zeichenfolge in konstanter Zeit O (1) vorhanden ist, aber Sie verwenden auch zusätzlichen Speicher (die Raumkomplexität beträgt O (n)).

Ich habe dafür die Methode string.includes () verwendet, die true oder false zurückgibt, wenn die Zeichenfolge oder das Zeichen gefunden wird. Siehe die folgende Dokumentation.

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

// Dies ist nur die Hauptsache ... Sie können einen gepufferten Leser oder Scanner verwenden

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...