Bir dizede tek bir karakterin görünüp görünmediğini nasıl kontrol edebilirim?

Java'da durumu kontrol etmenin bir yolu vardır:

"Bu tek karakter x dizgisinde hiç görünüyor mu?"

olmadan bir döngü kullanarak?

Kullanabilirsiniz string.indexOf('a') .

Eğer karakter amevcutsastring :

bu nesne tarafından temsil edilen karakter dizisindeki karakterin ilk oluşumunun dizinini veya karakter oluşmazsa -1 değerini döndürür.

• String.contains() dizenin belirtilen karakter değerleri dizisi içerip içermediğini kontrol eder
• String.indexOf() Belirtilen karakterin veya alt dizenin ilk oluşumunun dizesi içindeki dizini döndürür (bu yöntemin 4 varyasyonu vardır)

Orijinal posterin tam olarak ne istediğinden emin değilim. İndexOf (...) ve içerdiği (...) her ikisi de muhtemelen dahili olarak döngüler kullandığından, belki de bunun bir döngü olmadan mümkün olup olmadığını görmek istiyor? Elimizdeki iki yolu düşünebilirim, biri elbette yinelemeliydi:

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

Diğeri çok daha az zarif ama eksiksizlik ...:

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

Elbette daha uzun ve daha uzun dizeleri desteklemeniz gerektiğinden satır sayısı artar. Ancak hiçbir döngü / tekrarlama yoktur. Bu length () öğesinin bir döngü kullandığından endişeleniyorsanız uzunluk denetimini bile kaldırabilirsiniz.

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

Sınıftan 2 yöntem kullanabilirsiniz String.

• String.contains() dizenin belirtilen karakter değerleri dizisi içerip içermediğini kontrol eder
• String.indexOf() Belirtilen karakterin veya alt dizenin ilk geçtiği dizede dizini döndürür veya karakter bulunmazsa -1 değerini döndürür (bu yöntemin 4 varyasyonu vardır)

Yöntem 1:

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

Yöntem 2:

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

Bağlantılar: Zach Scrivena

Bir dizede bir şey olup olmadığını kontrol etmek için, en azından bir dizgideki her karaktere bakmanız gerekir. Dolayısıyla, açıkça bir döngü kullanmasanız bile, aynı verimliliğe sahip olacaktır. Olduğu söyleniyor, str.contains ("" + char) kullanmayı deneyebilirsiniz.

Aynı dizeyi sık sık kontrol etmeniz gerekiyorsa, karakter oluşumlarını önden hesaplayabilirsiniz. Bu, uzun bir dizide bulunan bir bit dizisini kullanan bir uygulamadır:

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

Evet, string sınıfında indexOf () yöntemini kullanarak. Bu yöntem için API belgelerine bakın

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

Çıktı

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

Aradığınız şey aşağıda mı?

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

Döngü / özyineleme kullanarak en az bir kez dizenin üzerinden geçmeden char'ın bazı dizelerde görünüp görünmediğini kontrol edemezsiniz (indexOf gibi yerleşik yöntemler de bir döngü kullanır)

Hayır ise. Eğer bir karakter dizge x ise dizge uzunluğundan daha fazla ise, bir Set veri yapısı kullanmanızı tavsiye ettiğimden daha fazladır.indexOf

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

Kümeyi kullanarak, karakter dizesinde sabit zaman O (1) olup olmadığını kontrol edebileceksiniz, ancak ek bellek de kullanacaksınız (Alan karmaşıklığı O (n) olacaktır).

Dize veya karakter bulunursa true veya false döndüren string.includes () yöntemini kullandım. Aşağıdaki belgelere bakın.

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

// bu sadece ana ... arabelleğe alınmış okuyucuyu veya tarayıcıyı kullanabilirsiniz

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