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

时间：2009-02-03 05:38:43

标签： java validation string character

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

“这个单个字符在字符串x中是否显示”

没有使用循环？

18 个答案:

答案 0 :(得分：241)

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

  

如果'a'中存在string，则会返回索引（＆gt; = 0）。如果不是，则返回-1。因此，非负返回值意味着'a' is present in the string。

答案 1 :(得分：134)

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

答案 2 :(得分：30)

我不确定原始海报究竟是在问什么。由于indexOf（...）并且包含（...）两个可能在内部使用循环，也许他正在寻找这个是否可能没有循环？我可以想到两种方式，一种方法当然是复发：

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（）使用循环，您甚至可以删除长度检查。

答案 3 :(得分：12)

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

答案 4 :(得分：4)

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

答案 5 :(得分：4)

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

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

答案 6 :(得分：2)

是的，在字符串类上使用indexOf（）方法。 See the API documentation for this method

答案 7 :(得分：2)

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

  • 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

答案 8 :(得分：1)

String.contains(String) 或 String.indexOf(String) - 建议

"abc".contains("Z"); // false - correct
"zzzz".contains("Z"); // false - correct
"Z".contains("Z"); // true - correct
"?and?".contains("?"); // true - correct
"?and?".contains("?"); // false - correct
"?and?".indexOf("?"); // 0 - correct
"?and?".indexOf("?"); // -1 - correct

String.indexOf(int) 并仔细考虑 String.indexOf(char) 与字符到 int 的加宽

"?and?".indexOf("?".charAt(0)); // 0 though incorrect usage has correct output due to portion of correct data
"?and?".indexOf("?".charAt(0)); // 0 -- incorrect usage and ambiguous result
"?and?".indexOf("?".codePointAt(0)); // -1 -- correct usage and correct output

Java 世界中关于字符的讨论是模棱两可的

char 或 Character 的值是否可以视为单个字符？

否。在 unicode 字符的上下文中，char 或 Character 有时可以是 part of a single character，并且在逻辑上不应被视为 a complete single character。

如果不是，应该将什么视为单个字符（逻辑上）？

任何支持 Unicode 字符编码的系统都应该将 unicode 的代码点视为单个字符。

因此 Java 应该非常清楚和响亮地做到这一点，而不是将过多的内部实现细节暴露给用户。

String 类不擅长抽象（尽管它需要大量的 understanding of its encapsulations to understand the abstraction ???，因此需要 anti-pattern）。

它与一般的 char 用法有何不同？

char 只能映射到基本多语言平面中的一个字符。

只有 codePoint - int 可以覆盖整个 Unicode 字符范围。

为什么会有这种差异？

char 在内部被视为 16-bit 无符号值，并且无法使用仅使用 2-bytes 的 UTF-16 内部表示来表示所有 unicode 字符。有时，16-bit 范围内的值必须与另一个 16-bit 值组合才能正确定义字符。

不要太冗长，indexOf、charAt、length 等方法的用法应该更加明确。真诚地希望 Java 能够添加具有明确定义的抽象的新 UnicodeString 和 UnicodeCharacter 类。

更喜欢contains而不是indexOf(int)的原因

  1. 实际上，Java 中有许多代码流将逻辑字符视为 char。
  2. 在 Unicode 上下文中，char 是不够的
  3. 虽然 indexOf 接受 int，但从 char 到 int 的转换会屏蔽用户，并且用户可能会执行类似 str.indexOf(someotherstr.charAt(0)) 的操作（除非用户知道确切的上下文）
  4. 因此，将所有内容都视为 CharSequence（又名 String）更好
    public static void main(String[] args) {
        System.out.println("?and?".indexOf("?".charAt(0))); // 0 though incorrect usage has correct output due to portion of correct data
        System.out.println("?and?".indexOf("?".charAt(0))); // 0 -- incorrect usage and ambiguous result
        System.out.println("?and?".indexOf("?".codePointAt(0))); // -1 -- correct usage and correct output
        System.out.println("?and?".contains("?")); // true - correct
        System.out.println("?and?".contains("?")); // false - correct
    }

语义

  1. char 可以处理大多数实际用例。为了将来的可扩展性，在编程环境中使用代码点仍然更好。
  2. codepoint 应该处理几乎所有与编码相关的技术用例。
  3. 尽管如此，Grapheme Clusters 仍不属于 codepoint 抽象级别的范围。
  4. 如果char成本太高（翻倍），存储层可以选择int接口。除非存储成本是唯一的指标，否则最好使用 codepoint。此外，最好将存储视为 byte 并将语义委托给围绕存储构建的业务逻辑。
  5. 语义可以在多个级别进行抽象。 codepoint 应该成为最低级别的接口，并且可以在运行时环境中围绕 codepoint 构建其他语义。

答案 9 :(得分：1)

如果您在JAVA中看到 indexOf 的源代码：

public int indexOf(int ch, int fromIndex) {

        final int max = value.length;

        if (fromIndex < 0) {

            fromIndex = 0;

        } else if (fromIndex >= max) {

            // Note: fromIndex might be near -1>>>1.

            return -1;

        }


        if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {

            // handle most cases here (ch is a BMP code point or a

            // negative value (invalid code point))

            final char[] value = this.value;

            for (int i = fromIndex; i < max; i++) {

                if (value[i] == ch) {

                    return i;

                }

            }

            return -1;

        } else {

            return indexOfSupplementary(ch, fromIndex);

        }

    }

您可以看到它使用for循环来查找字符。请注意，您可以在代码中使用的每个 indexOf 都等于一个循环。

因此，不可避免地要对单个字符使用循环。

但是，如果要查找具有更多不同形式的特殊字符串，请使用util.regex等有用的库，它会部署更强大的算法来匹配具有正则表达式的字符或字符串模式。例如，查找字符串中的电子邮件：

String regex = "^(.+)@(.+)$";
 
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(email);

如果您不喜欢使用正则表达式，只需使用一个循环和charAt，然后尝试一次循环就涵盖所有情况。

请注意，递归方法比循环具有更多的开销，因此不建议这样做。

答案 10 :(得分：1)

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

答案 11 :(得分：0)

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

答案 12 :(得分：0)

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

答案 13 :(得分：0)

以下是您要找的内容吗？

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

答案 14 :(得分：0)

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

如果没有。在很多情况下，您查找字符串 x 中的char是否比字符串的长度多得多，这比我推荐使用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））。 / p>

答案 15 :(得分：0)

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'

答案 16 :(得分：-1)

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

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

答案 17 :(得分：-4)

//这只是主要...你可以使用枯萎的缓冲读卡器或扫描仪

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...
相关问题
最新问题