如何检查字符串中是否出现单个字符？

在Java中，有一种检查条件的方法：

“此单个字符是否完全出现在字符串x中”

不使用循环？

您可以使用string.indexOf('a')。

如果该字符a存在于string：

它返回此对象表示的字符序列中该字符首次出现的索引，如果未出现该字符，则返回-1。

• String.contains() 检查字符串是否包含指定的char值序列
• String.indexOf() 它返回指定字符或子字符串首次出现在字符串中的索引（此方法有4种变化）

我不确定原始海报到底在问什么。由于indexOf（...）和contains（...）都可能在内部使用循环，也许他正在寻找是否可以在没有循环的情况下实现？我可以想到两种方法，其中一种当然是复发：

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

另一个远不那么优雅，但是完整性...：

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

当然，随着您需要支持越来越长的字符串，行数会增加。但是根本没有循环/重复。如果您担心length（）使用循环，甚至可以删除长度检查。

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

您可以使用String该类中的2种方法。

• String.contains() 检查字符串是否包含指定的char值序列
• String.indexOf() 它返回指定字符或子字符串首次出现的字符串中的索引，如果找不到该字符，则返回-1（此方法有4个变体）

方法1：

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

方法2：

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

链接：Zach Scrivena

要检查字符串中是否不存在某些字符，您至少需要查看字符串中的每个字符。因此，即使您没有显式使用循环，它也会具有相同的效率。话虽如此，您可以尝试使用str.contains（“” + char）。

如果需要经常检查相同的字符串，则可以预先计算字符出现的次数。这是一个使用长数组中包含的位数组的实现：

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

是的，在字符串类上使用indexOf（）方法。有关此方法，请参见API文档

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

输出量

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

以下是您要找的东西吗？

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

一旦使用循环/递归，您将无法检查char是否完全出现在某个字符串中，而不会至少遍历该字符串（诸如indexOf之类的内置方法也使用一个循环）

如果没有。您查找字符串中的字符x的次数比我使用Set数据结构所建议的长度要多得多，因为这比简单地使用set数据结构更有效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

使用set，您将能够在恒定时间 O（1）中检查字符是否存在于字符串中，但是您还将使用额外的内存（空间复杂度为O（n））。

我为此使用了string.includes（）方法，如果找到了字符串或字符，该方法将返回true或false。请参阅以下文档。

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

//这只是主要...您可以使用带缓冲的阅读器或扫描仪

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