Mengapa Java String tidak memiliki metode manipulasi string statis?

Mengapa desainer Java tidak membuat versi statis metode manipulasi string di java.lang.Stringkelas? Metode berikut adalah apa yang saya rujuk, tetapi pertanyaannya dapat diperluas ke metode non-statis lainnya di kelas juga.

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)

Hanya memiliki versi non-statis dari metode ini memaksa pemeriksaan null secara eksplisit di mana saja metode seperti itu harus dipanggil. Misalnya, hanya dengan memanggil saja example = example.trim()akan mengarah ke NullPointerException jika String example = null. Jadi programmer harus melakukan cek kosong boilerplate berikut:

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

Saya akan membayangkan akan jauh lebih nyaman jika Stringmemiliki versi statis dari metode ini (mungkin bahkan secara eksklusif ), yang akan menggunakan string input sebagai argumen pertama:

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

Ini akan menyebabkan kode bersih yang ditulis oleh programmer yang akan secara otomatis menangani kasus nol dengan hanya mengembalikan nol, daripada memaksa programmer untuk secara eksplisit menangani kasus nol. The kembali dari nol masuk akal bagi saya karena memanipulasi nol string yang harus menghasilkan nol tali, bukan kesalahan.

Mengapa desainer Java tidak memikirkan ini ketika mereka mendesain Stringkelas di Java 1 atau Java 2, atau bahkan menambahkan fungsi seperti itu di versi Java yang lebih baru?

Kembalinya nol masuk akal bagi saya karena memanipulasi string nol harus menghasilkan string nol, bukan kesalahan

Nah, itu pendapat Anda . Orang lain mungkin berpendapat bahwa operasi String pada objek nol, yang tidak mengandung String, tidak masuk akal dan karenanya harus membuang Pengecualian

Mengapa "desainer Java" melakukan atau tidak melakukan sesuatu yang sulit dijawab.

Sudah ada perpustakaan di luar sana yang dapat melakukan operasi String null-safe, misalnya StringUtils dari Apache Commons. Anda dapat menggunakan itu atau perpustakaan serupa jika Anda membutuhkannya.

Penambahan berdasarkan komentar Anda

Membaca komentar, sepertinya masalah sebenarnya yang Anda hadapi adalah Anda harus memeriksa nullseluruh kode Anda. Itu bisa menjadi indikator dari desain program yang buruk tanpa kontrak yang jelas antara antarmuka. Anda mungkin ingin membaca Menghindari pernyataan "! = Null" di Jawa?

IMO keseluruhan "jika arg adalah null kembali null" pendekatan untuk menulis metode tidak perlu meningkatkan kompleksitas siklus program Anda.

Libo Java awal menggunakan pendekatan return null, tetapi orang-orang JDK selalu dijaga terhadap null dengan pengecualian.

Dengan waktu, saya pikir pendekatan yang terakhir telah keluar sebagai pemenang yang jelas.

Mengapa? Karena bidang nol memecah banyak prinsip oo. Anda tidak bisa memperlakukan mereka sebagai anggota kelas polimorfik. Ini berarti bahwa Anda selalu harus kode kasus khusus untuk null, dan karenanya kompleksitas siklomatik Anda melonjak ketika Anda harus menganggap bahwa hal-hal dapat menjadi nol.

Untuk menyelesaikan masalah Anda, pertimbangkan untuk menggunakan pola objek nol daripada mengandalkan bidang nol.

Tidak mengatakan ini alasannya, tetapi kecuali untuk toString, semua metode ini dengan mudah dikemas dalam kelas pembantu statis, sedangkan kebalikannya tidak benar.

Yaitu jika Anda ingin Stings.toUpper (input string) kode untuk itu mudah untuk ditulis, tetapi jika Anda ingin instance.toUpper dan semua yang Anda miliki adalah String.toUpper, well, itu tidak mungkin ... kecuali mereka memperkenalkan metode ekstensi, yang kemungkinan besar bahkan tidak dipertimbangkan pada saat itu.

Dalam java, string itu adalah objek. Itu pilihan desain.

Referensi objek bisa nol dan nol jika tidak ada objek yang ditugaskan padanya. Jika Anda memanggil objek seperti itu, NullPointerException dilemparkan. Itu perilaku standar.

Desainer Java membuat pilihan memiliki string sebagai objek dan memiliki metode yang melempar pengecualian null-pointer adalah apa yang Anda dapatkan jika Anda ingin string menjadi objek.

Mengapa desainer Java tidak memikirkan ini ketika mereka mendesain kelas String di Java 1 atau Java 2, atau bahkan menambahkan fungsi seperti itu di versi Java yang lebih baru?

Mereka mungkin memang memikirkannya dan memilih untuk menggabungkan perilaku-o.