Java 如何检查字符串中的字符是否等于数组中的任何位置？

我试图比较字符串的第一个字符，以确保它不等于数组中的任何位置。代码如下：

if(string.charAt(0) != array[0] || string.charAt(0) != array[1])
{
    //Code here
}

---

我检查了一个实际代码中有10个位置的数组，但这太多了，无法键入。有没有更简单的方法？如果是这样的话，怎么做？

在阵列中循环并检查每个位置。如果找到匹配的标志，请设置标志

for (char c : array) {
    if (string.charAt(0) != c) {
         // Code here
         break;
    }
}

boolean flag = false;
for (int i = 0; i < array.length; i++) {
    if (string.charAt(0) == array[i]) {
        flag = true;
        break;
    }
}

if (flag) {
    // Indicates that one of them was equal. 
} else {
    // None of them was equal.
}

boolean标志=false；
for（int i=0；i

在阵列中循环并检查每个位置。如果找到匹配的标志，请设置标志

boolean flag = false;
for (int i = 0; i < array.length; i++) {
    if (string.charAt(0) == array[i]) {
        flag = true;
        break;
    }
}

if (flag) {
    // Indicates that one of them was equal. 
} else {
    // None of them was equal.
}

boolean标志=false；
for（int i=0；i

在阵列中循环并检查每个位置。如果找到匹配的标志，请设置标志

boolean flag = false;
for (int i = 0; i < array.length; i++) {
    if (string.charAt(0) == array[i]) {
        flag = true;
        break;
    }
}

if (flag) {
    // Indicates that one of them was equal. 
} else {
    // None of them was equal.
}

boolean标志=false；
for（int i=0；i

在阵列中循环并检查每个位置。如果找到匹配的标志，请设置标志

boolean flag = false;
for (int i = 0; i < array.length; i++) {
    if (string.charAt(0) == array[i]) {
        flag = true;
        break;
    }
}

if (flag) {
    // Indicates that one of them was equal. 
} else {
    // None of them was equal.
}

boolean标志=false；
for（int i=0；i

对循环使用

for(int i = 0; i < array.length; i++){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

int i = 0;
while(i < array.length){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

为什么他妈的不让我们螺旋迭代和做一些递归。（假设数组的类型为char）。其他的方法更好，我只是想证明你可以用递归来实现

boolean checkChar(String string Char[] array){
    return checkCharHelper(string, array, 0);
}

boolean checkCharHelper(String string, Char[] array, int index){
   if(index >= string.length){
      return false;
   }
   if(string.charAt(0) != array[i])
   {
      //Code here
     return true;
   }
   return checkCharHelper(string, array, index + 1);  
}

---

对循环使用

for(int i = 0; i < array.length; i++){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

int i = 0;
while(i < array.length){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

为什么他妈的不让我们螺旋迭代和做一些递归。（假设数组的类型为char）。其他的方法更好，我只是想证明你可以用递归来实现

boolean checkChar(String string Char[] array){
    return checkCharHelper(string, array, 0);
}

boolean checkCharHelper(String string, Char[] array, int index){
   if(index >= string.length){
      return false;
   }
   if(string.charAt(0) != array[i])
   {
      //Code here
     return true;
   }
   return checkCharHelper(string, array, index + 1);  
}

---

对循环使用

for(int i = 0; i < array.length; i++){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

int i = 0;
while(i < array.length){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

为什么他妈的不让我们螺旋迭代和做一些递归。（假设数组的类型为char）。其他的方法更好，我只是想证明你可以用递归来实现

boolean checkChar(String string Char[] array){
    return checkCharHelper(string, array, 0);
}

boolean checkCharHelper(String string, Char[] array, int index){
   if(index >= string.length){
      return false;
   }
   if(string.charAt(0) != array[i])
   {
      //Code here
     return true;
   }
   return checkCharHelper(string, array, index + 1);  
}

---

对循环使用

for(int i = 0; i < array.length; i++){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

int i = 0;
while(i < array.length){
    if(string.charAt(0) != array[i])
    {
       //Code here
       break;
    }  
}

为什么他妈的不让我们螺旋迭代和做一些递归。（假设数组的类型为char）。其他的方法更好，我只是想证明你可以用递归来实现

boolean checkChar(String string Char[] array){
    return checkCharHelper(string, array, 0);
}

boolean checkCharHelper(String string, Char[] array, int index){
   if(index >= string.length){
      return false;
   }
   if(string.charAt(0) != array[i])
   {
      //Code here
     return true;
   }
   return checkCharHelper(string, array, index + 1);  
}

---

使用

List

代替静态数组，然后也使用

List#contains（）

方法

示例代码：

List<Character> list = Arrays.asList('a', 'b', 'c');
if (!list.contains(string.charAt(0))) {
    System.out.println("not found in array");
}

List List=Arrays.asList（'a'，'b'，'c'）；
如果（！list.contains（string.charAt（0）））{
System.out.println（“在数组中找不到”）；
}

使用

List

代替静态数组，然后也使用

List#contains（）

方法

示例代码：

List<Character> list = Arrays.asList('a', 'b', 'c');
if (!list.contains(string.charAt(0))) {
    System.out.println("not found in array");
}

List List=Arrays.asList（'a'，'b'，'c'）；
如果（！list.contains（string.charAt（0）））{
System.out.println（“在数组中找不到”）；
}

使用

List

代替静态数组，然后也使用

List#contains（）

方法

示例代码：

List<Character> list = Arrays.asList('a', 'b', 'c');
if (!list.contains(string.charAt(0))) {
    System.out.println("not found in array");
}

List List=Arrays.asList（'a'，'b'，'c'）；
如果（！list.contains（string.charAt（0）））{
System.out.println（“在数组中找不到”）；
}

使用

List

代替静态数组，然后也使用

List#contains（）

方法

示例代码：

List<Character> list = Arrays.asList('a', 'b', 'c');
if (!list.contains(string.charAt(0))) {
    System.out.println("not found in array");
}

List List=Arrays.asList（'a'，'b'，'c'）；
如果（！list.contains（string.charAt（0）））{
System.out.println（“在数组中找不到”）；
}

Java8POWA

int[] array = {'a','b','c'};
String s1 = "cat";
String s2 = "dog";

boolean res1 = Arrays.stream(array).anyMatch(c -> c==s1.charAt(0));
boolean res2 = Arrays.stream(array).anyMatch(c -> c==s2.charAt(0));

System.out.println(res1); //true
System.out.println(res2); //false

爪哇8波瓦

int[] array = {'a','b','c'};
String s1 = "cat";
String s2 = "dog";

boolean res1 = Arrays.stream(array).anyMatch(c -> c==s1.charAt(0));
boolean res2 = Arrays.stream(array).anyMatch(c -> c==s2.charAt(0));

System.out.println(res1); //true
System.out.println(res2); //false

爪哇8波瓦

int[] array = {'a','b','c'};
String s1 = "cat";
String s2 = "dog";

boolean res1 = Arrays.stream(array).anyMatch(c -> c==s1.charAt(0));
boolean res2 = Arrays.stream(array).anyMatch(c -> c==s2.charAt(0));

System.out.println(res1); //true
System.out.println(res2); //false

爪哇8波瓦

int[] array = {'a','b','c'};
String s1 = "cat";
String s2 = "dog";

boolean res1 = Arrays.stream(array).anyMatch(c -> c==s1.charAt(0));
boolean res2 = Arrays.stream(array).anyMatch(c -> c==s2.charAt(0));

System.out.println(res1); //true
System.out.println(res2); //false

---

为它创建一个单独的方法，遍历数组并将数组中的每个字符与给定字符（在本例中为字符串的第一个字符）进行比较

 private boolean charInArray(char[] chars, char c){
        for(char x: chars)
           if(c == x) return true;

        return false;
 }

你可以这样称呼它：

if(!charInArray(array, string.charAt(0)){
    //do something
}

---

为它创建一个单独的方法，遍历数组并将数组中的每个字符与给定字符（在本例中为字符串的第一个字符）进行比较

 private boolean charInArray(char[] chars, char c){
        for(char x: chars)
           if(c == x) return true;

        return false;
 }

你可以这样称呼它：

if(!charInArray(array, string.charAt(0)){
    //do something
}

---

为它创建一个单独的方法，遍历数组并将数组中的每个字符与给定字符（在本例中为字符串的第一个字符）进行比较

 private boolean charInArray(char[] chars, char c){
        for(char x: chars)
           if(c == x) return true;

        return false;
 }

你可以这样称呼它：

if(!charInArray(array, string.charAt(0)){
    //do something
}

---

为它创建一个单独的方法，遍历数组并将数组中的每个字符与给定字符（在本例中为字符串的第一个字符）进行比较

 private boolean charInArray(char[] chars, char c){
        for(char x: chars)
           if(c == x) return true;

        return false;
 }

你可以这样称呼它：

if(!charInArray(array, string.charAt(0)){
    //do something
}

---

我认为for循环是最好的选择。循环遍历数组，检查字符串开头字符的每个索引

//Your string
String yourString = "some string";

boolean interrupt = false;

for (int i = 0; i < array.length; i++) {
     if(yourString.charAt(0).equalsIgnoreCase(array[i])) {
          interrupt = true;
          break;
     }
}
if(interrupt) {
    System.out.println("Found in array");
}
else {
    System.out.println("Not found in array");

//您的字符串
String yourString=“some String”；
布尔中断=假；
for（int i=0；i

我认为for循环是最好的选择。循环数组，检查每个索引中字符串开头的字符

//Your string
String yourString = "some string";

boolean interrupt = false;

for (int i = 0; i < array.length; i++) {
     if(yourString.charAt(0).equalsIgnoreCase(array[i])) {
          interrupt = true;
          break;
     }
}
if(interrupt) {
    System.out.println("Found in array");
}
else {
    System.out.println("Not found in array");

//您的字符串
String yourString=“some String”；
布尔中断=假；
for（int i=0；i

我认为for循环是最好的选择。循环数组，检查每个索引中字符串开头的字符

//Your string
String yourString = "some string";

boolean interrupt = false;

for (int i = 0; i < array.length; i++) {
     if(yourString.charAt(0).equalsIgnoreCase(array[i])) {
          interrupt = true;
          break;
     }
}
if(interrupt) {
    System.out.println("Found in array");
}
else {
    System.out.println("Not found in array");

//您的字符串
String yourString=“some String”；
布尔中断=假；
for（int i=0；i