English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Java 基礎教程

Controllo dei flussi Java

Array Java

Orientazione ad oggetti Java (I)

Orientazione ad oggetti Java (II)

Orientazione ad oggetti Java (III)

Java 异常处理

List Java

Queue (coda) Java

Map di Java

Set di Java

Input/Output (I/O) Java

Reader/Writer Java

Altri argomenti Java

Programma Java per verificare se una stringa è una重组 (scarto) valida di altre due stringhe

Completo di esempi Java

In questo esempio, esamineremo se una stringa è una重组 (scarto) valida di altre due stringhe in Java.

Per comprendere questo esempio, dovresti conoscere i seguentiProgrammazione JavaArgomento:

Esempio: verificare se una stringa è una重组 valida delle altre due stringhe

class Main {
  //controlla se la stringa di risultato è una scrittura disordinata valida delle prime due stringhe
  static boolean shuffleCheck(String first, String second, String result) {
    //controlla se la lunghezza del risultato è uguale a
    //somma delle lunghezze della prima e della seconda
    if (first.length() + second.length() != result.length()) {
      return false;
    }
    //variabili per tracciare i caratteri di ciascuna delle tre stringhe
    int i = 0, j = 0, k = 0;
    //percorre tutti i caratteri del risultato
    while (k != result.length()) {
      //controlla se il primo carattere del risultato corrisponde al primo carattere della prima stringa
      if (i < first.length() && first.charAt(i) == result.charAt(k)) {
        i++;
      //controlla se il primo carattere del risultato corrisponde al primo carattere della seconda stringa
      } else if (j < second.length() && second.charAt(j) == result.charAt(k)) {
        j++;
      //se i caratteri non corrispondono
      } else {
        return false;
      }
      //accesso al carattere successivo del risultato
      k++;
    }
    //dopo aver acceduto a tutti i caratteri del risultato
     //se la prima o la seconda hanno alcuni caratteri rimasti
    if (i < first.length() || j < second.length()) {
      return false;
    }
    return true;
  }
  public static void main(String[] args) {
    String first = "XY";
    String second = "12";
    String[] results = {"1XY2", "Y12X"};
    //chiamata del metodo per verificare se la stringa di risultato è
    //mescola di first e second
    per (String result : results) {
      se (shuffleCheck(first, second, result) == true) {
        System.out.println(result + " è " + first + " e " + second + "重组valida");
      }
      else {
        System.out.println(result + " non è " + first + " e " + second + "重组valida");
      }
    }
  }
}

Risultato di output

1XY2 è una重组valida di XY e 12
Y12X non è una重组valida di XY e 12

Nell'esempio sopra, abbiamo un array di stringhe chiamato results. Contiene due stringhe: 1XY2 e Y12X. Stiamo controllando se queste due stringhe sono stringhe validhe first(XY) e second(12).

Qui, il programma dice che 1XY2 è una permutazione valida XY e 12. Ma Y12X non è una permutazione valida.

Questo è perché Y12X ha cambiato l'ordine delle stringhe XY. Qui, Y viene utilizzato per il precedente X. Pertanto, come重组valida, l'ordine delle stringhe deve essere mantenuto.

Completo di esempi Java