So kürzen Sie einen String in Java

Truncate bedeutet, etwas zu kürzen und die Methode wird Trunkierung genannt. In der Programmierung bezieht es sich häufig auf Datentypen oder Variablen. Beim Programmieren kommt es häufig vor, dass bei der Verarbeitung größerer Datenmengen oder der Aufrechterhaltung der Datenintegrität ein Teil der Zeichenfolge verschoben werden muss. In der Java-Programmierung gibt es verschiedene Methoden, mit denen eine Zeichenfolge abgeschnitten werden kann.

In diesem Artikel werden die Kürzungen in der Java-Programmierung und verschiedene Methoden, mit denen eine Zeichenfolge gekürzt werden kann, ausführlich erläutert.

Wie schneide ich einen String in Java ab?

Unter Trunkierung versteht man in Java das Abschneiden von Ziffern vom Typ float/double oder das Entfernen einiger Zeichen einer Zeichenfolge. Der Dezimalteil einer beliebigen Zahl kann entfernt werden, um eine ganze Zahl zu bilden. Nachdem die Kürzung abgeschlossen ist, wird die Zahl auf den nächsten Wert gerundet. Man kann dies also auch als Annäherung an eine Zahl bezeichnen. Es wird häufig verwendet, wenn Zahlen dividiert werden sollen und der resultierende Wert eine ganze Zahl sein soll.

Beispiel

Betrachten wir eine Zahl num=639,6383929 und die Kürzung wird angewendet, um zwei Nachkommastellen zu haben. Die resultierende ganze Zahl ist 639,63.

Hier ist ein Flussdiagramm, das beschreibt, wie verschiedene Zahlen gekürzt werden können:

In diesem Artikel werden verschiedene Methoden zum Abschneiden einer Zeichenfolge erläutert. Lassen Sie uns jede Methode im Detail besprechen.

Methode 1: Verwendung des JDK

Eine Zeichenfolge kann mithilfe des JDK abgeschnitten werden. Java verfügt über eine Reihe nützlicher Funktionen, die das Abschneiden einer Zeichenfolge ermöglichen. Lassen Sie uns verschiedene Beispiele diskutieren, um verschiedene Funktionen zum Abschneiden einer Zeichenfolge in Java zu untersuchen.

Beispiel: 1 mit substring()

Die Java-String-Klasse verfügt über eine praktische Methode namens Substring. substring() gibt einen Teil der Zeichenfolge zwischen den vom Benutzer angegebenen Indizes zurück. Schauen wir uns den folgenden Code an, um zu sehen, wie er funktioniert:

public class Main {
    public static void main(String[] args) {
        String txt = "TRUNCATE THIS STRING!";
        int len = 14;
        String res = substring(txt, len);
        System.out.println(res);
    }
      static String substring(String txt, int len) {
        if (txt.length() <= len) {
            return txt;
        } else {
            return txt.substring(0, len);
        }
    }
    }

Im obigen Code,

  • Der Code definiert ein Java öffentliche Hauptklasse
  • Die Hauptmethode public static void main(String[] args) ist definiert. Dies ist die Anfangsphase, in der das Programm ausgeführt wird.
  • Ein Faden txt wird initialisiert und sagt: „Diese Zeichenkette abschneiden!„. Diese Zeichenfolge wird entsprechend der angegebenen Länge gekürzt.
  • Eine ganzzahlige Variable len Es wird definiert, auf welchen Wert gesetzt wird 14. Es wird die maximale Länge sein und die txt Die Zeichenfolge wird abgeschnitten.
  • Alsubstring Es wird eine statische Methode definiert, die einen String zurückgibt und zwei Parameter akzeptiert txt Und len die zuvor definiert wurden. Dadurch wird die Eingabezeichenfolge gekürzt, wenn sie den Grenzwert überschreitet.
  • Innerhalb der Teilstring-Methode gibt es eine bedingte Prüfung. Wenn die Länge der Zeichenfolge txt kleiner oder gleich ist, wird die Zeichenfolge nicht abgeschnitten. Wenn die Länge größer ist, geht die Methode zu sonst blockieren wo die Teilstring-Methode aufgerufen wird.
  • Die abgeschnittene Zeichenfolge wird zurückgegeben und durchgedruckt System.out.println().

Ausgabe

Die Ausgabe zeigt, wie ein String mit der substring()-Methode von Java gekürzt wird:

Beispiel 2: Verwendung von split()

Eine weitere Möglichkeit zum Abschneiden einer Zeichenfolge ist die Verwendung der Funktion split(). split() trennt die Zeichenfolge in verschiedene Segmente. „positiver Rückblick„ist eine reguläre Ausdrucksfunktion, die eine bestimmte Anzahl von Zeichen am Anfang der Zeichenfolge abgleicht. Schauen wir uns den folgenden Code an, um zu sehen, wie er funktioniert:

public class Main {
    public static void main(String[] args) {
        String txt = "A Java program is running!";
        int len = 14;
        String res = split(txt, len);
        System.out.println(res);
    }
    static String split(String text, int length) {
    String[] results = text.split("(?<=\\G.{" + length + "})");
    return results[0];
    }
    }

Im obigen Code:

  • Eine statische Zeichenfolgenfunktion mit dem Namen Teilt übernimmt den String-Parameter Text und int-Variable Länge. Die Methode hilft dabei, die Eingabezeichenfolge in Segmente bestimmter Längen aufzuteilen und das erste Segment zu extrahieren
  • Die Methode text.split wird verwendet, um die Eingabezeichenfolgen aufzuteilen. Der Ausdruck ‚(?<=\\G. {“ + Länge + „})‚ Wo \\GDie Position befindet sich am Ende des letzten Spiels oder am Anfang des ersten Spiels.{“ + Länge + „} Passt das wiederholte Zeichen an die Häufigkeit an, mit der die Länge wiederholt wird. (?<=…) ist ein positive Look-Behind-Behauptung Dadurch wird sichergestellt, dass dem Trennzeichen ein bestimmtes Muster vorangestellt ist.
  • Die zurückgegebene Zeichenfolge wird im gespeichert Ergebnisarray.
  • Die Funktionalität wird dann in der Zeichenfolge txt ausgecheckt, die besagt:Ein Java-Programm läuft!‚. Die angegebene Länge beträgt 14 Daher wird die Zeichenfolge auf bis zu 14 Zeichen gekürzt.
  • Die resultierende Zeichenfolge wird durchgedruckt System.out.println(res).

Ausgabe

Die Ausgabe zeigt, wie eine Zeichenfolge mithilfe der JDK-Funktionalität split() gekürzt werden kann:

Beispiel 3: Verwendung der Pattern-Klasse

Die Musterklasse führt einen regulären Ausdruck aus, der mit dem Anfang des Strings bis zu einer bestimmten Anzahl von Zeichen übereinstimmt. Betrachten Sie zum Beispiel {1, „Länge+“}. Der reguläre Ausdruck sollte mindestens einem und maximal der Länge von Zeichen entsprechen. Der folgende Code erklärt, wie eine Zeichenfolge mithilfe der Musterklasse abgeschnitten werden kann:

public class Main {
    static String pattern(String text, int length) {
        Optional<String> result = Pattern.compile(".{1," + length + "}")
            .matcher(text)
            .results()
            .map(MatchResult::group)
            .findFirst();

        return result.isPresent() ? result.get() : "";
    }
        public static void main(String[] args) {
        String txt = "I love to code!";
        int len = 10;
        String res = pattern(txt, len);
        System.out.println(res);
    }
}

Im obigen Code:

  • Die im Code verwendeten erforderlichen Klassen werden über importiert java.util.regex importieren.* Und java.util importieren.*
  • Es wird eine Hauptklasse definiert, die die Methode zum Abschneiden einer Zeichenfolge enthält
  • Die Musterfunktion benötigt zwei Parameter, Text und Länge, um den Text mithilfe eines regulären Ausdrucksmusters in Segmente aufzuteilen.
  • pattern.compile(“. {1“, + Länge + „}“) Kompiliert das Regex-Muster, das den Teilzeichenfolgen bis zur Länge entspricht. Die Übereinstimmungen werden in die konvertiert MatchResult Objekte und dann zugeordnet, um die passenden Teilzeichenfolgen zu erhalten. Der erste übereinstimmende Teilstring wird mit extrahiert findFirst und wird in einem optionalen gespeichert.
  • Die reguläre Ausdrucksmethode gibt die übereinstimmende Teilzeichenfolge zurück, die am Anfang steht. Es wird eine leere Zeichenfolge zurückgegeben, sofern keine Übereinstimmung vorliegt.
  • Die Hauptmethode enthält eine Textzeichenfolge ‚Ich liebe es zu programmieren!‚, der als Textparameter an die Musterfunktion mit dem Längenparameter as übergeben wird 10. Die resultierende Zeichenfolge wird abgeschnitten und als „angezeigt“.ich liebe‚.

Ausgabe

Die folgende Ausgabe zeigt, wie eine Zeichenfolge mithilfe der JDK-Funktionalitätsmusterklasse gekürzt werden kann:

Beispiel 4: Die codePoints()-Methode von charSequence

Die codePoints()-Funktionen von charSequence konvertieren einen String in Codepunktwerte. Schauen wir uns den folgenden Code an, der erläutert, wie die Stream-API zum Abschneiden einer Zeichenfolge verwendet werden kann:

public class Main {
    static String codePoints(String text, int length) {
    return text.codePoints()
      .limit(length)
      .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
      .toString();
}
        public static void main(String[] args) {
        String txt = "Java is my favorite programming language!";
        int len = 20;
        String res = codePoints(txt, len);
        System.out.println(res);
    }
}

Im obigen Code,

  • Die Hauptklasse enthält eine statische String-Funktion codePoints, die die Parameter text und length akzeptiert.
  • codePoints wird für Text aufgerufen, der einen Streamn von Unicode-Punkten für die Zeichen im Text zurückgibt.
  • Grenze(Länge) Begrenzt die Anzahl der Codepunkte im Stream auf den angegebenen Wert Länge.
  • .sammeln(…) sammelt die begrenzten Codepunkte für die StringBuilder Objekt. Zum Zweck der Sammlung der Charaktere a StringBuilder Objekt wird erstellt.
  • appendCodePoint Gibt an, wie an jeden Codepunkt angehängt werden kann StringBuilder. anhängen Integriert die Codepunkte zusammen.
  • Die Funktion toString() wird aufgerufen StringBuilder wodurch der Codepunkt erfasst wird Zeichenfolge.
  • Die Hauptfunktion enthält einen Beispieltext mit der Aufschrift „Java ist meine Lieblingsprogrammiersprache!‚, das auf bis zu 15 Zeichen gekürzt wird. Die resultierende Zeichenfolge wird in gespeichert res und wird mit gedruckt System.out.println(res).

Ausgabe:

Die folgende Ausgabe zeigt, wie eine Zeichenfolge mithilfe der JDK-Funktionalität codePoints() gekürzt werden kann:

Methode 2: Nutzung der Guava-Bibliothek

Eine Zeichenfolge kann mithilfe der Guava-Bibliothek und deren Funktionen abgeschnitten werden. Die Guava-Bibliothek enthält verschiedene Sammlungen wie Multisets.

Hinzufügen der Guava-Bibliothek zur Datei pox.xml

Durch die Integration der Guava-Bibliotheksabhängigkeit in die Datei pox.xml werden Funktionen wie split() bereitgestellt, mit denen die Zeichenfolge abgeschnitten werden kann. So ist die Bibliothek integriert:

<dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.0.1-jre</version>
</dependency>

Durch die Integration der Guava-Abhängigkeit in die Datei pom.xml kann eine Zeichenfolge abgeschnitten werden. Der folgende Code erklärt, wie eine Zeichenfolge mithilfe der Guava-Bibliothek abgeschnitten werden kann:

import com.google.common.base.Splitter;
public class Main {
    public static void main(String[] args) {
        String txt = "Split the string already!";
        int len = 15;
        String res = splitter(txt, len);
        System.out.println(res);
    }

static String splitter(String text, int length) {
    Iterable<String> parts = Splitter.fixedLength(length)
      .split(text);
    return parts.iterator()
      .next();
}
}

Im obigen Code:

  • Die Funktion „split()“ aus der Guava-Bibliothek wird importiert.
  • Der Splitter Die Methode benötigt zwei Parameter: Text und Länge.
  • splitter.fixedLength(länge) Erstellt einen Instanzsplitter, der den Eingabetext entsprechend der angegebenen angegebenen Länge aufteilt.
  • .split(text) wird aufgerufen Splitter den Text in verschiedene Teile aufteilen, was zu einem führt Iterable welches diese Teile enthalten wird
  • parts.iterator().next() erhält das erste Segment aus den geteilten Teilen
  • Die Splitter-Funktion wird für eine Beispielzeichenfolge aufgerufen txt das sagt ‚Teilen Sie die Saite schon!‚ mit der len-Variablen gleich 15, was der Anzahl der im ersten Segment enthaltenen Zeichen entspricht.
  • Das Ergebnis ‚Teilen Sie den Strang‚ wird mit gedruckt System.out.println(res)

Ausgabe

Die folgende Ausgabe zeigt, wie eine Zeichenfolge mithilfe der Funktion „split()“ aus der Guava-Bibliothek gekürzt werden kann:

Methode 3: Nutzung der Apache Commons Library

Die Apache Commons Lang-Bibliothek enthält eine Klasse namens „StringUtils“ zur Manipulation der Strings. Es wird verwendet, wenn wir die Apache Commons-Abhängigkeit in pom.xml integrieren.

Hinzufügen der Guava-Bibliothek zur pox.xml-Datei

Durch die Integration der Guava-Bibliotheksabhängigkeit in die Datei pox.xml werden Funktionen wie split() bereitgestellt, mit denen die Zeichenfolge abgeschnitten werden kann. So ist die Bibliothek integriert:

<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version> </dependency>

Schauen wir uns verschiedene Beispiele an, die die Apache Commons Library zum Abschneiden der Zeichenfolge verwenden.

Beispiel 1: Verwendung von left() von StringUtils

Mit left() der Apache-Commons-Bibliotheksfunktion StringUtils kann der String gekürzt werden. Der Code zum Reduzieren der Zeichenfolge mithilfe der Funktion left() ist unten angegeben:

import org.apache.commons.lang3.StringUtils;
public class Main {

    public static void main(String[] args) {
        String txt = "Coding in Java is Fun!";
        int len = 18;
        String res = left(txt, len);
        System.out.println(res);
    }

    static String left(String text, int length) {
        return StringUtils.left(text, length);
    }
}

Im obigen Code:

  • Der StringUtils’s left() Funktion wird aus importiert Apaches Commons Library.
  • Die Funktion left() hat Text Und Länge als seine Parameter. Die Länge ist die Anzahl der Zeichen, auf die der Text gekürzt wird.
  • Die Beispielzeichenfolge txt Programmieren in Java macht Spaß!” wird auf eine Länge von gekürzt 18.
  • Die resultierende abgeschnittene Zeichenfolge ‚Codierung in Java ist‚ wird mit gedruckt System.out.println(res).

Ausgabe

Die folgende Ausgabe zeigt, wie eine Zeichenfolge mithilfe der left()-Funktionalität von StringUtils aus der Apache Commons-Bibliothek abgeschnitten werden kann:

Beispiel 2: Verwendung von truncate() von StringUtils

Mit truncate() der Apache-Commons-Bibliotheksfunktion StringUtils kann die Zeichenfolge abgeschnitten werden. Der Code zum Kürzen der Zeichenfolge mithilfe der Funktion truncate() ist unten angegeben:

import org.apache.commons.lang3.StringUtils;
public class Main {
    public static void main(String[] args) {        int len = 20;
        String txt = "Exploring different coding languages!";
        String res = truncate(txt, len);
        System.out.println(res);
    }
    public static String truncate(String text, int length) {
        return StringUtils.truncate(text, length);
    }
}

Im obigen Code:

  • Der truncate() von StringUtils Funktion wird aus importiert Apaches Commons Library.
  • Die Funktion trucate() benötigt zwei Parameter Text Und Länge. Die Länge gibt die Zeichen an, die aus der Zeichenfolge abgeschnitten werden.
  • Die Beispielzeichenfolge txt Erkundung verschiedener Programmiersprachen” wird auf eine Länge von gekürzt 20.
  • Die resultierende abgeschnittene Zeichenfolge ‚Verschiedenes erkundent‘ wird mit gedruckt System.out.println(res).

Ausgabe

Die folgende Ausgabe zeigt, wie eine Zeichenfolge mithilfe der left()-Funktionalität von StringUtils aus der Apache Commons-Bibliothek abgeschnitten werden kann:

Abschluss:

Eine Zeichenfolge wird durch verschiedene Methoden wie JDK-Methoden, die substring()-, split()- und codePoints()-Funktionen umfassen, oder Bibliotheken wie Apache Commons und Guava abgeschnitten. Diese Bibliotheken enthalten verschiedene Funktionen wie split(), truncate() und left(), die einen String bis zu einer bestimmten Länge kürzen können. In diesem Artikel wurden verschiedene Möglichkeiten zum Abschneiden einer Zeichenfolge erläutert und die Methoden anhand relevanter Beispiele veranschaulicht.

Kommentar verfassen

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

Nach oben scrollen