Coffee break #196. Cara membaca fail dengan betul dalam Java 8 dan Java 11. Bagaimana untuk mengisih Senarai dalam Java, pelbagai kaedah untuk mengisih senarai dalam Java

Cara membaca fail dalam Java 8 dan Java 11 dengan betul

Sumber: Sederhana Dengan tutorial ini, anda akan mempelajari beberapa petua yang berguna semasa memproses dan membaca fail besar dalam Java 8 dan Java 11. Membaca fail yang terletak pada cakera komputer anda agak mudah dalam Java. Dalam Java 8 dan lebih baru, anda boleh menggunakan kelas Fail untuk ini . Ia adalah sebahagian daripada pakej java.nio.file , yang pertama kali diperkenalkan di Java 7 untuk menyediakan cara yang lebih cekap untuk bekerja dengan fail dan direktori. Di bawah ialah contoh bagaimana anda boleh menggunakan kelas Fail untuk membaca fail dalam Java 8.

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileReader {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("file.txt");
            String content = Files.readString(path);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Contoh ini menggunakan kaedah Files.readAllLines() untuk membaca semua baris fail dan menyimpannya dalam fail List<String> . Kaedah Paths.get() digunakan untuk mencipta objek Path yang mewakili fail. Anda juga boleh menggunakan Files.lines :

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.Files;

public class FileReader {
    public static void main(String[] args) {
        try {
            Files.lines(Paths.get("file.txt"))
                .forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dalam Java 11, untuk membaca fail anda boleh menggunakan kaedah readString() , ia membaca keseluruhan fail sebagai rentetan. Berikut ialah contoh cara menggunakannya.

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileReader {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("file.txt");
            String content = Files.readString(path);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Apabila bekerja dengan fail besar dalam Java, adalah penting untuk mengingati beberapa garis panduan:

1. Gunakan pembaca penimbal . Ia membolehkan anda membaca sebahagian besar data pada satu masa, dan bukannya membaca satu aksara atau satu baris pada satu masa.
2. Gunakan saiz penimbal yang lebih kecil : Apabila menggunakan pembaca penimbal, saiz penimbal yang lebih kecil boleh membantu mengurangkan penggunaan memori.
3. Gunakan API penstriman . Daripada memuatkan keseluruhan fail ke dalam memori, API penstriman membolehkan anda membaca fail dalam bahagian-bahagian.
4. Gunakan benang selari untuk memproses fail , terutamanya jika fail itu besar.
5. Tutup fail selepas membaca: ini akan membantu membebaskan sumber.
6. Gunakan pernyataan cuba-dengan-sumber untuk menutup fail secara automatik selepas membacanya. Ini memastikan bahawa fail ditutup walaupun pengecualian berlaku semasa membacanya.

Di bawah ialah contoh menggunakan pernyataan cuba-dengan-sumber untuk membaca fail.

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.Files;
import java.util.List;

public class FileReader {
    public static void main(String[] args) {
        try (BufferedReader reader = Files.newBufferedReader(Paths.get("file.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dalam contoh ini, objek BufferedReader dicipta dalam pernyataan cuba-dengan-sumber, yang memastikan ia ditutup secara automatik apabila keluar dari blok, walaupun pengecualian berlaku. Jadi, apabila membaca fail besar dalam Java, sebaiknya gunakan pembaca penimbal, saiz penimbal yang lebih kecil, API penstriman, strim selari dan tutup fail selepas membacanya. Selain itu, menggunakan pernyataan cuba-dengan-sumber boleh membantu memastikan fail ditutup dengan betul sekiranya berlaku pengecualian.

Bagaimana untuk mengisih Senarai dalam Java. Pelbagai Kaedah Isih Senarai dalam Java

Sumber: FreeCodeCamp Siaran ini merangkumi pelbagai kaedah pengisihan Senarai dalam Java: Collections.sort() , stream.sorted() dan List.sort() . Kadangkala data perlu disusun dalam susunan tertentu untuk memudahkan untuk memahami, mencari dan memproses. Kami memanggil proses pengisihan ini. Menggunakan pengisihan, anda boleh menyusun data bukan sahaja dalam susunan tertentu, tetapi juga mengikut kriteria: contohnya, mengikut jenis data, termasuk nombor, rentetan dan objek. Bahasa Java mempunyai kaedah terbina dalam untuk mengisih, contohnya dalam kelas Koleksi . Pengisihan Java sering digunakan dalam aplikasi e-dagang di mana pengguna perlu memaparkan senarai produk. Produk boleh diisih dalam pelbagai cara bergantung pada keperluan yang ditetapkan pengguna, seperti harga, penilaian, jenama dan sebagainya. Contohnya, jika pengguna ingin melihat semua produk diisih mengikut harga dalam tertib menaik, aplikasi boleh menggunakan algoritma pengisihan untuk menyusun produk dalam susunan tersebut. Dengan cara ini, apabila pengguna menyemak imbas produk, dia akan dapat melihat produk yang paling murah terlebih dahulu dan membuat keputusan pembelian dengan sewajarnya.

Cara menggunakan kaedah Collections.Sort() dalam Java

Salah satu cara yang paling biasa untuk mengisih data dalam Java ialah menggunakan kaedah Collections.sort() . Secara lalai, ia mengisih senarai dalam tertib menaik. Berikut ialah contoh menggunakan kaedah Collections.sort() untuk mengisih Senarai integer:

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<Integer>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(2);

        Collections.sort(numbers);

        System.out.println("Sorted List: " + numbers);
    }
}

Kod di atas mencipta senarai integer, menambah empat nombor padanya, mengisih senarai, dan kemudian mencetak senarai diisih ke konsol. Ia menggunakan kelas daripada Pustaka Standard Java untuk melaksanakan operasi, termasuk java.util.Collections , java.util.List , dan java.util.ArrayList . Outputnya adalah seperti berikut: Anda juga boleh mengisih senarai objek tersuai menggunakan kaedah Collections.sort() . Untuk melakukan ini, anda perlu mencipta pembanding dan menyampaikannya sebagai hujah kepada kaedah Collections.sort() . Pembanding ialah objek yang melaksanakan antara muka java.util.Comparator . Ia mempunyai kaedah boleh panggil tunggal, compare() , yang membandingkan dua objek dan mengembalikan integer yang menunjukkan susunan relatifnya. Berikut ialah contoh cara menggunakan pembanding untuk mengisih senarai objek tersuai:

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 20));

        Collections.sort(people, new PersonComparator());

        System.out.println("Sorted List: " + people);
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

class PersonComparator implements java.util.Comparator<Person> {
    @Override
    public int compare(Person a, Person b) {
        return a.getAge() - b.getAge();
    }
}

Kod yang ditunjukkan di atas mencipta senarai objek Person , menambah beberapa objek Person pada senarai , mengisih senarai menggunakan pembanding tersuai ( PersonComparator ), dan kemudian mencetak senarai yang diisih. Kelas Orang mempunyai dua medan, nama dan umur , serta kaedah pengambil untuk medan ini. Kelas PersonComparator melaksanakan antara muka Comparator dan mengatasi kaedah perbandingan untuk mengisih objek Person mengikut umur ( umur ). Output program ini akan menjadi seperti ini: Kaedah Collections.sort() paling sesuai digunakan apabila anda mempunyai koleksi objek yang ingin anda isi mengikut satu atau lebih medan. Contohnya, jika anda mempunyai koleksi objek Pekerja dan anda ingin mengisihnya mengikut nama keluarga, anda boleh menggunakan kaedah Collections.sort() dan lulus pembanding tersuai yang membandingkan nama akhir objek Pekerja .

Cara menggunakan kaedah List.Sort() dalam Java

Kaedah ini mengisih senarai dalam tertib menaik. Begini cara ia berfungsi:

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
        numbers.sort(null);
        System.out.println(numbers); // prints [1, 2, 3, 4, 5]
    }
}

Di dalam kaedah utama , Arrays.asList mencipta senarai integer yang dipanggil nombor . Kod kemudian mengisih senarai nombor ini menggunakan kaedah isihan lalai, kerana nol dihantar kepada kaedah isihan . Akhir sekali, senarai yang diisih dicetak ke konsol menggunakan kaedah System.out.println . Outputnya ialah [1, 2, 3, 4, 5] . List.sort() berguna apabila anda mempunyai senarai elemen yang perlu diisih. Sebagai contoh, jika anda mempunyai senarai rentetan dan anda ingin mengisihnya mengikut abjad, anda boleh menggunakan kaedah List.sort() untuk melakukan ini . List.sort() ialah kaedah contoh kelas List dan mengisih elemen dalam susunan yang ditentukan oleh susunan semula jadinya atau pelaksanaan Icomparer yang diberikan .

Cara menggunakan kaedah stream.sorted() dalam Java

Dalam Java 8 dan lebih baru, anda boleh menggunakan API Strim untuk mengisih senarai. Ia menyediakan kaedah diisih , yang boleh digunakan untuk mengisih unsur aliran. Berikut ialah contoh cara mengisih senarai integer menggunakan strim:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
        List<Integer> sortedList = numbers.stream().sorted().collect(Collectors.toList());
        System.out.println(sortedList); // prints [1, 2, 3, 4, 5]

    }
}

Seperti yang anda lihat, senarai nombor ditukar kepada aliran menggunakan kaedah stream() . Kaedah sorted() kemudiannya dipanggil untuk mengisih elemen dalam stream . Kaedah collect(Collectors.toList()) digunakan untuk mengumpul elemen yang diisih kembali ke dalam senarai. Hasilnya ialah senarai baharu yang mengandungi elemen yang diisih. Outputnya ialah [1, 2, 3, 4, 5] . stream.sorted() paling sesuai digunakan apabila anda mempunyai aliran elemen yang perlu diisih. Sebagai contoh, jika anda mempunyai aliran integer dan anda ingin mengisihnya dalam tertib menaik, maka lebih baik menggunakan kaedah stream.Sorted() untuk ini .

Kesimpulan

Dalam tutorial ini, anda mengetahui bahawa terdapat beberapa cara untuk mengisih senarai dalam Java - kaedah Collections.sort() , kaedah stream.sorted() dan kaedah List.sort() . Antara kaedah ini yang manakah terbaik untuk digunakan bergantung pada keperluan khusus tugasan yang sedang dijalankan. Saya harap artikel ini telah memberi anda maklumat yang betul tentang cara mengisih senarai dalam Java. Selamat mengekod!