Kelas kemudahan untuk bekerja dengan rentetan di Jawa

1. StringTokenizerkelas

Dan kini beberapa lagi senario biasa yang melibatkan kerja dengan rentetan. Bagaimanakah anda membahagikan rentetan kepada beberapa bahagian? Terdapat beberapa cara untuk melakukan ini.

split()kaedah

Cara pertama untuk memisahkan rentetan kepada beberapa bahagian adalah dengan menggunakan split()kaedah. Ungkapan biasa yang mentakrifkan rentetan pembatas khas mesti diluluskan sebagai hujah. Anda akan mengetahui apakah ungkapan biasa dalam pencarian Java Multithreading .

Contoh:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Mudah, tetapi kadang-kadang pendekatan ini berlebihan. Jika terdapat banyak pembatas (contohnya, ruang, aksara baris baharu, tab, noktah), maka anda perlu membina ungkapan biasa yang agak kompleks. Sukar untuk dibaca dan oleh itu sukar untuk diubah suai.

StringTokenizerkelas

Java mempunyai kelas khas yang seluruh tugasnya adalah untuk memisahkan rentetan kepada subrentetan.

Kelas ini tidak menggunakan ungkapan biasa: sebaliknya, anda hanya lulus dalam rentetan yang terdiri daripada pembatas. Kelebihan pendekatan ini ialah ia tidak memecahkan keseluruhan rentetan menjadi kepingan sekaligus, sebaliknya bergerak dari awal hingga akhir satu langkah pada satu masa.

Kelas mempunyai pembina dan dua kaedah penting. Kami menghantar pembina rentetan yang kami bahagikan kepada bahagian, dan rentetan yang terdiri daripada satu set aksara pembatas.

String nextToken()

boolean hasMoreTokens()

Kelas ini entah bagaimana mengingatkan kelas Pengimbas, yang juga mempunyai nextLine()dan hasNextLine()kaedah.

Anda boleh membuat StringTokenizerobjek dengan arahan ini:

StringTokenizer name = new StringTokenizer(string, delimiters);

Di manakah stringtali itu dibahagikan kepada bahagian. Dan delimitersialah rentetan, dan setiap aksara di dalamnya dianggap sebagai pembatas. Contoh:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Ambil perhatian bahawa setiap aksara dalam rentetan yang diluluskan sebagai rentetan kedua kepada StringTokenizerpembina dianggap sebagai pemisah.

2. String.format()kaedah dan StringFormatterkelas

Satu lagi kaedah menarik kelas String ialah format().

Katakan anda mempunyai pelbagai pembolehubah yang menyimpan data. Bagaimanakah anda memaparkannya pada skrin dalam satu baris? Sebagai contoh, kami mempunyai beberapa data (lajur kiri) dan output yang dikehendaki (lajur kanan):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Kod anda mungkin kelihatan seperti ini:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Kod sedemikian tidak boleh dibaca. Dan jika nama pembolehubah lebih panjang, maka kod akan menjadi lebih sukar:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Tidak boleh dibaca, bukan?

Tetapi ini adalah situasi biasa dalam program dunia sebenar, jadi saya ingin memberitahu anda tentang cara untuk menulis kod ini dengan lebih ringkas dan lebih ringkas.

String.format

Kelas String mempunyai format()kaedah statik: ia membolehkan anda menentukan corak untuk memasang rentetan dengan data. Penampilan umum arahan adalah seperti berikut:

String name = String.format(pattern, parameters);

Contoh:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

Parameter pertama kaedah format()ialah rentetan format yang mengandungi semua teks yang dikehendaki bersama-sama dengan aksara khas yang dipanggil penentu format (seperti %ddan %s) di tempat yang anda perlukan untuk memasukkan data.

Kaedah format()menggantikan ini %sdan %dpenentu format dengan parameter yang mengikut rentetan format dalam senarai parameter. Jika kita ingin memasukkan rentetan, maka kita tulis %s. Jika kita ingin memasukkan nombor, maka penentu format ialah %d. Contoh:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Berikut ialah senarai pendek penentu format yang boleh digunakan dalam rentetan format:

%s

%d

%f

%b

%c

%t

%%

Penentu ini menunjukkan jenis data, tetapi terdapat juga penentu yang menunjukkan susunan data. Untuk mendapatkan hujah dengan nombornya (penomboran bermula dari satu), anda perlu menulis " " bukannya " ". Contoh:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$dakan mendapat hujah ke-3, %2$dakan mendapat hujah kedua, dan %dakan mendapat hujah pertama. Penentu format %sdan %dmerujuk kepada hujah tanpa mengira penentu seperti %3$datau%2$s

3. Kolam Rentetan

Setiap rentetan yang dinyatakan dalam kod sebagai literal rentetan disimpan dalam kawasan memori yang dipanggil semasa StringPoolprogram sedang berjalan. StringPoolialah tatasusunan khas untuk menyimpan rentetan. Tujuannya adalah untuk mengoptimumkan storan rentetan:

Pertama, rentetan yang dinyatakan dalam kod mesti disimpan di suatu tempat, bukan? Kod terdiri daripada arahan, tetapi data (terutamanya, rentetan besar) mesti disimpan dalam memori secara berasingan daripada kod. Hanya rujukan kepada objek rentetan muncul dalam kod.

Kedua, semua literal rentetan yang sama mesti disimpan dalam ingatan sekali sahaja. Dan itulah cara ia berfungsi. Apabila kod kelas anda dimuatkan oleh mesin Java, semua literal rentetan ditambahkan pada StringPooljika ia belum ada di sana. Jika mereka sudah ada, maka kami hanya menggunakan rujukan rentetan daripada StringPool.

Sehubungan itu, jika anda menetapkan literal yang sama kepada beberapa Stringpembolehubah dalam kod anda, maka pembolehubah ini akan mengandungi rujukan yang sama. Satu literal akan ditambahkan pada StringPoolsekali sahaja. Dalam semua kes lain, kod akan mendapat rujukan kepada rentetan yang telah dimuatkan dalam StringPool.

Inilah kira-kira cara ia berfungsi:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

Itulah sebabnya pembolehubah adan bakan menyimpan rujukan yang sama.

intern()kaedah

Dan bahagian yang terbaik ialah anda boleh menambahkan sebarang rentetan secara pemrograman pada StringPool. Untuk melakukan ini, anda hanya perlu memanggil kaedah Stringpembolehubah intern().

Kaedah ini intern()akan menambah rentetan kepada StringPooljika ia belum ada, dan akan mengembalikan rujukan kepada rentetan dalam StringPool.

Jika dua rentetan yang sama ditambah pada kaedah StringPoolmenggunakan intern(), kaedah tersebut mengembalikan rujukan yang sama. Ini boleh digunakan untuk membandingkan rentetan dengan rujukan. Contoh:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Anda tidak mungkin menggunakan kaedah ini dengan kerap, tetapi orang suka bertanya tentang kaedah ini dalam temu bual . Jadi lebih baik mengetahuinya daripada tidak tahu.