Vergleichen von Zeichen in Java

Es ist schon eine Weile her, seit ich getan habe, alle Java so meine syntax ist nicht die größte im moment.

Ich möchte, um zu überprüfen, die eine char-variable ist eine von 21 spezifischen chars, was ist der kürzeste Weg, kann ich dies tun?

Beispiel:

if(symbol == ('A'|'B'|'C')){}

Scheint nicht zu funktionieren. Muss ich es schreiben wie:

if(symbol == 'A' || symbol == 'B' etc.)

InformationsquelleAutor der Frage Alex | 2011-02-17

59

Wenn Sie Ihre Eingabe ist ein Zeichen und die Zeichen, die Sie überprüft sind meist aufeinander, Sie könnten versuchen, diese:
```
if ((symbol >= 'A' && symbol <= 'Z') || symbol == '?') {
    //...
}
```
Allerdings, wenn Ihr input ist ein string ein kompakter Ansatz (aber langsamer), ist die Verwendung eines regulären Ausdrucks mit einer Charakter-Klasse:
```
if (symbol.matches("[A-Z?]")) {
    //...
}
```
Wenn Sie einen Charakter, müssen Sie zuerst, um es in einen string konvertieren, bevor Sie können einen regulären Ausdruck verwenden:
```
if (Character.toString(symbol).matches("[A-Z?]")) {
    //...
}
```
InformationsquelleAutor der Antwort Mark Byers
9

Wenn Sie wissen, alle Ihre 21 Zeichen im Voraus, dass Sie schreiben können Sie alle, wie eine Schnur, und dann überprüfen Sie es wie folgt:
```
char wanted = 'x';
String candidates = "abcdefghij...";
boolean hit = candidates.indexOf(wanted) >= 0;
```
Ich denke, das ist der kürzeste Weg.

InformationsquelleAutor der Antwort Marc
5

Die erste Anweisung, die Sie haben ist wahrscheinlich nicht das, was Sie wollen... 'A'|'B'|'C' ist eigentlich bitweise operation 🙂

Ihre zweite Aussage ist richtig, aber Sie haben 21 ORs.

Wenn die 21 Zeichen sind "konsekutiv" die oben genannten Lösungen ist in Ordnung.

Wenn nicht können Sie pre-berechnen einer hash-Satz der gültigen Zeichen und tun Sie etwas wie
```
if (validCharHashSet.contains(symbol))...
```
InformationsquelleAutor der Antwort Alvin
3

Könnte es klarer geschrieben als eine switch-Anweisung mit fall-z.B. durch
```
switch (symbol){
    case 'A':
    case 'B':
      //Do stuff
      break;
     default:
}
```
InformationsquelleAutor der Antwort Richard Miskin

Wenn Sie bestimmte chars sein sollte:

Collection<Character> specificChars = Arrays.asList('A', 'D', 'E');  //more chars
char symbol = 'Y';
System.out.println(specificChars.contains(symbol));   //false
symbol = 'A';
System.out.println(specificChars.contains(symbol));   //true

InformationsquelleAutor der Antwort smas

2

Mit Guave:
```
if (CharMatcher.anyOf("ABC...").matches(symbol)) { ... }
```
Oder wenn viele dieser Zeichen sind eine Auswahl, wie "A" , "U", aber einige sind nicht:
```
CharMatcher.inRange('A', 'U').or(CharMatcher.anyOf("1379"))
```
Können Sie auch erklären, dass diese als static final - Feld, damit der matcher muss nicht jedes mal erstellt.
```
private static final CharMatcher MATCHER = CharMatcher.anyOf("ABC...");
```
InformationsquelleAutor der Antwort ColinD

Option 2 funktionieren wird. Sie können auch ein Set<Character> oder

char[] myCharSet = new char[] {'A', 'B', 'C', ...};
Arrays.sort(myCharSet);
if (Arrays.binarySearch(myCharSet, symbol) >= 0) { ... }

InformationsquelleAutor der Antwort rlibby

1

diese:
```
if ("ABCDEFGHIJKLMNOPQRSTUVWXYZ".contains(String.valueOf(yourChar)))
```
beachten Sie, dass Sie nicht brauchen, um erstellen Sie einen separaten String mit den Buchstaben von A-Z.

InformationsquelleAutor der Antwort Daniel He
0

Ja, Sie brauchen, es zu schreiben, wie die zweite Zeile. Java nicht hat, die python-Stil syntaktischen Zucker von Ihrer ersten Linie.

Alternativ könnten Sie Ihre gültige Werte in ein array und überprüfen Sie für die Existenz von symbol im array.

InformationsquelleAutor der Antwort Endophage

pseudocode wie ich habe nicht ein java-sdk auf mich:

Char candidates = new Char[] { 'A', 'B', ... 'G' };

foreach(Char c in candidates)
{
    if (symbol == c) { return true; }
}
return false;

InformationsquelleAutor der Antwort tenpn

Können Sie einfach schreiben Sie Ihre chars als Strings, und verwenden Sie die equals-Methode.

Beispiel:

String firstChar = "A";
String secondChar = "B";
String thirdChar = "C";


    if (firstChar.equalsIgnoreCase(secondChar)) || 
            (firstChar.equalsIgnoreCase(thirdChar))) //As many equals as you want
    {
        System.out.println(firstChar + " is the same as " + secondChar);
    }
    else 
    {
        System.out.println(firstChar + " is different than " + secondChar);
    }

InformationsquelleAutor der Antwort Anony

0

Einen Weg, es zu tun mit einem List<Character> konstruiert überlastet convenience factory-Methoden in java9 ist als :
```
if(List.of('A','B','C','D','E').contains(symbol) {
    //do something
}
```
InformationsquelleAutor der Antwort nullpointer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.