Was ist ein Anagramm in Java?

In Java ein „Anagramm„funktioniert ähnlich wie ein Palindrom, jedoch mit einem größeren Umfang. Es ist so beschaffen, dass es in beiden Fällen anhand der enthaltenen Zeichen nach Zeichenfolgen suchen kann. Dieser Ansatz kommt zum Tragen, während Duplikate in den Aufzeichnungen vermieden werden. Außerdem kann es zur Identifizierung der verwendeten gemeinsamen Zeichen in den Zeichenfolgen verwendet werden.

In diesem Blog wird das Konzept des Java-„Anagramms“ diskutiert.

Was ist ein „Anagramm“ in Java?

Die beiden Zeichenfolgen gelten als „Anagramm“, wenn eine Zeichenfolge durch Anordnen der Zeichen der anderen Zeichenfolge erstellt werden kann. Beispiele hierfür sind „Herz, Erde“, „scharf, Knie“ usw.

Beispiel 1: Überprüfen, ob ein String ein Anagramm ist, mithilfe der Klasse „Arrays“.

In diesem Beispiel wird eine Prüfung der Anagrammzeichenfolgen mithilfe der Klasse „Arrays“ durchgeführt:

import java.util.*;public class Anagram {
public static void main(String[] args) {
  String firstString = "Heart";
  String secondString = "Earth";
  firstString = firstString.toUpperCase();
  secondString = secondString.toUpperCase();
  if(firstString.length() == secondString.length()) {
  char[] firstcharArray = firstString.toCharArray();
  char[] secondcharArray = secondString.toCharArray();
  Arrays.sort(firstcharArray);
  Arrays.sort(secondcharArray);
  boolean out = Arrays.equals(firstcharArray, secondcharArray);
  if(out == true) {
    System.out.println(firstString + " and " + secondString + " are anagram");
}
  else {
    System.out.println(firstString + " and " + secondString + " are not anagram");
}}
}}

Gemäß dem obigen Code:

  • Importieren Sie das Paket „java.util.*“, um die Arbeit mit allen Funktionen im „java.util“ Paket.
  • Initialisieren Sie die beiden Zeichenfolgen, die auf „Anagramm“ überprüft werden müssen.
  • Verknüpfen Sie im nächsten Schritt das „toUpperCase()”-Methode mit beiden Zeichenfolgen, um die Groß-/Kleinschreibung zu vermeiden, während die Prüfung angewendet wird, sodass die Zeichen in Großbuchstaben umgewandelt werden.
  • Jetzt die „toCharArray()Die Methode wandelt beide Zeichenfolgen in Zeichenarrays um.
  • Sortieren Sie außerdem beide konvertierten Zeichenarrays der Zeichenfolgen mithilfe des „Arrays.sort()“ Methode.
  • Diese Sortierung hilft bei der Überprüfung auf die enthaltenen Zeichen in beiden Zeichenfolgen.
  • Verwenden Sie zum Schluss das „gleich()”-Methode, die einen booleschen Typ zurückgibt, um zu prüfen, ob die resultierenden Zeichenfolgen gleich sind, und um die entsprechende „if/else“-Bedingung aufzurufen.

Ausgabe

Diese Ausgabe bestätigt, dass es sich bei beiden Zeichenfolgen um Anagramme handelt.

Beispiel 2: Überprüfen, ob ein String ein Anagramm ist, mithilfe der Klasse „StringBuilder“.

Diese spezielle Klasse kann auch implementiert werden, um über eine benutzerdefinierte Funktion eine Prüfung der übergebenen Zeichenfolgen durchzuführen:

import java.util.*;public class Anagram2 {
public static boolean checkAnagram(String firstString, String secondString) {
  char[] chars = firstString.toCharArray();
  StringBuilder obj = new StringBuilder(secondString);
  for (char x : chars) {
  int index = obj.indexOf("" + x);
  if (index != -1) {
    obj.deleteCharAt(index);
}
  else {
    return false;
}}
  return obj.length() == 0 ? true : false;
}
public static void main(String args[]){
System.out.println(checkAnagram("heart", "earth"));
System.out.println(checkAnagram("keen", "know"));
}}

In dieser Code-Implementierung:

  • Definieren Sie die Funktion „checkAnagram()“ vom Typ Boolean mit den Strings als Parametern, die später als Argumente übergeben werden müssen.
  • Wandeln Sie in seiner Definition die frühere Zeichenfolge in ein Zeichenarray um, indem Sie „toCharArray()“ Methode.
  • Erstellen Sie außerdem ein StringBuilder-Objekt mit dem Schlüsselwort „new“ und dem Konstruktor „StringBuilder()“ mit der letztgenannten Zeichenfolge als Konstruktorparameter.
  • Verwenden Sie anschließend die „for“-Schleife und die „if/else“-Bedingungen in Kombination, um anhand der früheren Zeichenfolge zu prüfen, ob die letztere Zeichenfolge vorliegt.
  • Es ist so, dass „Index von()Die Methode sucht nach dem Index der iterierten Zeichen der letzteren Zeichenfolge und löscht dieses Zeichen, wenn es in Bezug auf die vorherige Zeichenfolge gefunden wird.
  • Überprüfen Sie nun die Länge der letztgenannten Zeichenfolge und rufen Sie den entsprechenden booleschen Wert auf.
  • Rufen Sie in „main“ die definierte Funktion zweimal auf, indem Sie die angegebenen Zeichenfolgen übergeben, die auf „ überprüft werden sollen.Anagramm“.

Ausgabe

Diese booleschen Werte werden von der Funktion zurückgegeben und zeigen an, dass die ersteren Zeichenfolgen Anagramme sind, während dies bei den letzteren nicht der Fall ist.

Beispiel 3: Mit „HashMap“ prüfen, ob ein String ein Anagramm ist

In dieser speziellen Demonstration kann eine „HashMap“ verwendet werden, um nach Anagrammen zu suchen:

import java.util.*;public class Anagram3 {
public static boolean checkAnagram(String x, String y){
  if (x.length() != y.length()) {
  return false;
}
  HashMap<Character, Integer> map = new HashMap<>();
  for (int i = 0; i < x.length(); i++) {
  if (map.containsKey(x.charAt(i))) {
    map.put(x.charAt(i),
    map.get(x.charAt(i)) + 1);
}
  else {
    map.put(x.charAt(i), 1);
}}
  for (int i = 0; i < y.length(); i++) {
  if (map.containsKey(y.charAt(i))) {
    map.put(y.charAt(i),
    map.get(y.charAt(i)) - 1);
}
  else {
    return false;
}}
  Set<Character> keys = map.keySet();
  for (Character a : keys) {
  if (map.get(a) != 0) {
    return false;
}}
  return true;
}
public static void main(String[] args){
String firstString = "heart";
String secondString = "earth";
if (checkAnagram(firstString, secondString))
  System.out.print("The Strings " + firstString+" and "+secondString+" are anagram");
else
  System.out.print("The Strings" + firstString+" and "+secondString+" are not  anagram");
}}

In diesem Codeausschnitt:

  • Definieren Sie ebenfalls eine Funktion, deren Parameter die angegebenen Zeichenfolgen sind, die auf Anagramme überprüft werden sollen.
  • Überprüfen Sie in der Funktionsdefinition die Länge beider übergebener Zeichenfolgen und geben Sie „false“ zurück, wenn sie nicht gleich sind.
  • Erstellen Sie außerdem ein HashMap-Objekt, durchlaufen Sie die Zeichen der vorherigen Zeichenfolge in einer Schleife und hängen Sie es an HashMap an.
  • Analysieren Sie, ob HashMap das iterierte Zeichen bereits enthält oder nicht. Wenn ja, erhöhen Sie die Anzahl um „1” für diesen bestimmten Charakter. Andernfalls platzieren Sie diesen Charakter auf der Karte und setzen Sie die Anzahl auf „1“, wenn der Charakter zum ersten Mal konfrontiert wird. Anschließend durchlaufen Sie die letzte Zeichenfolge.
  • Überprüfen Sie auf ähnliche Weise, ob das iterierte Zeichen in HashMap vorhanden ist. Wenn ja, verringern Sie die Anzahl dieses Zeichens um „1” um anzudeuten, dass das aktuell iterierte Zeichen bereits gezählt wurde.
  • Dadurch wird sichergestellt, dass alle Zeichen der ersten Zeichenfolge auch in der zweiten Zeichenfolge vorhanden sind.
  • Extrahieren und durchlaufen Sie nun alle Schlüssel von HashMap und prüfen Sie, ob alle Schlüssel „0“ sind. Wenn ja, bedeutet dies, dass es sich um ein Anagramm handelt.
  • Definieren Sie abschließend in „main“ die angegebenen Zeichenfolgen und übergeben Sie diese Werte an die aufgerufene Funktion, um das entsprechende Ergebnis basierend auf den „if/else“-Bedingungen zurückzugeben.

Ausgabe

Dieses Ergebnis bedeutet, dass es sich bei den definierten Zeichenfolgen um Anagramme handelt.

Abschluss

Die beiden Zeichenfolgen werden als Anagramme betrachtet, wenn eine Zeichenfolge durch Anordnen der Zeichen der anderen Zeichenfolge erstellt werden kann. Diese Prüfung kann mit der Funktion „Arrays“ Klasse, „StringBuilder” Klasse, oder über „HashMap“. Dieser Blog demonstrierte das Konzept und die Funktionsweise des Java-„Anagramms“.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen