Warum verfügt Java String nicht über Methoden zur Bearbeitung statischer Zeichenfolgen?

Warum haben Java-Designer in der java.lang.StringKlasse keine statischen Versionen von String-Manipulationsmethoden erstellt ? Die folgenden Methoden sind das, worauf ich mich beziehe, aber die Frage kann auch auf andere nicht statische Methoden in der Klasse ausgeweitet werden.

concat(String)                        substring(int, int)
replace(char, char)                   toLowerCase()
replace(CharSequence, CharSequence)   toLowerCase(Locale)
replaceAll(String, String)            toString()
replaceFirst(String, String)          toUpperCase()
split(String)                         toUpperCase(Locale)
split(String, int)                    trim()
substring(int)

Wenn nur nicht statische Versionen dieser Methoden vorhanden sind, wird die explizite Nullprüfung überall dort erzwungen, wo eine solche Methode aufgerufen werden muss. Zum Beispiel example = example.trim()würde ein einfacher Aufruf zu NullPointerException if führen String example = null. Der Programmierer muss also den folgenden Null-Check für das Boilerplate durchführen:

if (example != null)
    example = example.trim();
// OR:
example = (example==null) ? null : example.trim();
example = (example==null) ? null : example.substring(5);

Ich würde mir vorstellen, dass es viel praktischer gewesen wäre, wenn Stringstatische Versionen dieser Methoden (vielleicht sogar ausschließlich ) verwendet worden wären, bei denen die Eingabezeichenfolge als erstes Argument herangezogen würde:

example = String.trim(example);
example = String.replace(example, 'a', 'b');
example = String.substring(example, 5);

Dies hätte zu einem saubereren Code geführt, der von Programmierern geschrieben wurde und der sich automatisch um Nullfälle gekümmert hätte, indem einfach Null zurückgegeben wurde, anstatt die Programmierer zu zwingen, explizit Nullfälle zu behandeln. Die Rückgabe von null ist für mich sinnvoll, da die Manipulation einer Nullzeichenfolge zu einer Nullzeichenfolge und nicht zu einem Fehler führen sollte.

Warum haben Java-Designer nicht daran gedacht, als sie die StringKlasse in Java 1 oder Java 2 entworfen oder in einer späteren Java-Version sogar eine solche Funktionalität hinzugefügt haben?

Die Rückgabe von null ist für mich sinnvoll, da die Manipulation einer Nullzeichenfolge zu einer Nullzeichenfolge und nicht zu einem Fehler führen sollte

Nun, das ist deine Meinung. Andere argumentieren möglicherweise, dass Zeichenfolgenoperationen für ein Nullobjekt, das keine Zeichenfolge enthält, keinen Sinn ergeben und daher eine Ausnahme auslösen sollten

Warum "Java-Designer" etwas getan oder nicht getan haben, ist schwer zu beantworten.

Es gibt bereits Bibliotheken, die nullsichere String-Operationen ausführen können, z. B. StringUtils von Apache Commons. Sie können diese oder ähnliche Bibliotheken verwenden, wenn Sie sie benötigen.

Hinzufügung basierend auf Ihren Kommentaren

Beim Lesen der Kommentare scheint das eigentliche Problem zu sein, dass Sie den nullgesamten Code überprüfen müssen. Dies kann ein Hinweis auf ein schlechtes Programmdesign ohne klar definierte Verträge zwischen den Schnittstellen sein. Möglicherweise möchten Sie "! = Null" -Anweisungen in Java vermeiden lesen ?

IMO erhöht der gesamte Ansatz "if arg is null return null" zum Schreiben von Methoden unnötigerweise die zyklomatische Komplexität Ihres Programms.

Frühe Java-Bibliotheken verwendeten den Return-Null-Ansatz, aber die JDK-Leute schützten sich immer mit Ausnahmen vor Null.

Ich denke, mit der Zeit hat sich der letztgenannte Ansatz als klarer Gewinner herausgestellt.

Warum? Da Nullfelder eine Menge von OO-Prinzipien brechen. Sie können sie einfach nicht als Mitglieder einer polymorphen Klasse behandeln. Dies bedeutet, dass Sie immer Sonderfälle für null codieren müssen, und daher steigt Ihre zyklomatische Komplexität an, wenn Sie davon ausgehen müssen, dass die Dinge null sein können.

Um Ihre Probleme zu lösen, sollten Sie das Nullobjektmuster verwenden, anstatt sich auf Nullfelder zu verlassen.

Dies ist nicht der Grund, aber mit Ausnahme von toString lassen sich alle diese Methoden leicht in eine statische Hilfsklasse einkapseln, während das Gegenteil nicht zutrifft.

Das heißt, wenn Sie Stings.toUpper (Stringeingabe) wollen, ist der Code dafür einfach zu schreiben, aber wenn Sie instance.toUpper wollen und alles, was Sie haben, ist String.toUpper, na ja, das ist unmöglich ... es sei denn, sie führen Erweiterungsmethoden ein. was damals höchstwahrscheinlich nicht einmal in Betracht gezogen wurde.

In Java ist diese Zeichenfolge ein Objekt. Das ist eine Designentscheidung.

Objektreferenzen können null sein und sind null, wenn kein Objekt zugewiesen ist. Wenn Sie ein solches Objekt aufrufen, wird eine NullPointerException ausgelöst. Das ist normales Verhalten.

Java-Designer entschieden sich dafür, Zeichenfolgen als Objekt zu haben und diese Methoden Nullzeiger-Ausnahmen auszulösen, was Sie erhalten, wenn Zeichenfolgen Objekte sein sollen.

Warum haben Java-Designer nicht daran gedacht, als sie die String-Klasse in Java 1 oder Java 2 entworfen oder in einer späteren Java-Version sogar eine solche Funktionalität hinzugefügt haben?

Sie haben wahrscheinlich darüber nachgedacht und beschlossen, oo-Verhalten zu integrieren.