Coffee break #196. Paano magbasa ng mga file nang tama sa Java 8 at Java 11. Paano mag-uri-uriin ang isang Listahan sa Java, iba't ibang paraan para sa pag-uuri ng mga listahan sa Java

Paano maayos na basahin ang mga file sa Java 8 at Java 11

Source: Medium Sa tutorial na ito, matututunan mo ang ilang tip na kapaki-pakinabang kapag nagpoproseso at nagbabasa ng malalaking file sa Java 8 at Java 11. Ang pagbabasa ng file na matatagpuan sa disk ng iyong computer ay medyo simple sa Java. Sa Java 8 at mas bago, maaari mong gamitin ang klase ng Mga File para dito . Ito ay bahagi ng java.nio.file package , na unang ipinakilala sa Java 7 upang magbigay ng mas mahusay na paraan upang gumana sa mga file at direktoryo. Nasa ibaba ang isang halimbawa kung paano mo magagamit ang klase ng Mga File upang magbasa ng isang file sa 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();
        }
    }
}

Ang halimbawang ito ay gumagamit ng Files.readAllLines() na paraan upang basahin ang lahat ng linya ng isang file at iimbak ang mga ito sa isang List<String> file . Ang paraan ng Paths.get() ay ginagamit upang lumikha ng object ng Path na kumakatawan sa file. Maaari mo ring gamitin ang 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();
        }
    }
}

Sa Java 11, para magbasa ng mga file maaari mong gamitin ang readString() method , binabasa nito ang buong file bilang isang string. Narito ang isang halimbawa kung paano ito gamitin.

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();
        }
    }
}

Kapag nagtatrabaho sa malalaking file sa Java, mahalagang tandaan ang ilang alituntunin:

1. Gumamit ng buffered reader . Binibigyang-daan ka nitong magbasa ng malalaking tipak ng data sa isang pagkakataon, sa halip na magbasa ng isang character o isang linya sa isang pagkakataon.
2. Gumamit ng mas maliit na laki ng buffer : Kapag gumagamit ng buffered reader, makakatulong ang mas maliit na laki ng buffer na bawasan ang paggamit ng memory.
3. Gamitin ang streaming API . Sa halip na i-load ang buong file sa memorya, pinapayagan ka ng streaming API na basahin ang file sa mga bahagi.
4. Gumamit ng parallel thread para iproseso ang file , lalo na kung malaki ang file.
5. Isara ang file pagkatapos basahin: makakatulong ito na magbakante ng mga mapagkukunan.
6. Gamitin ang pahayag ng try-with-resources upang awtomatikong isara ang isang file pagkatapos basahin ito. Tinitiyak nito na ang file ay sarado kahit na may pagbubukod habang binabasa ito.

Nasa ibaba ang isang halimbawa ng paggamit ng try-with-resources statement para magbasa ng file.

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();
        }
    }
}

Sa halimbawang ito, ang isang bagay na BufferedReader ay nilikha sa loob ng isang pahayag ng try-with-resources, na nagsisiguro na awtomatiko itong sarado kapag lumalabas sa block, kahit na may naganap na pagbubukod. Kaya, kapag nagbabasa ng malalaking file sa Java, pinakamahusay na gumamit ng buffered reader, mas maliit na laki ng buffer, streaming API, parallel stream, at isara ang file pagkatapos basahin ito. Bukod pa rito, ang paggamit ng isang try-with-resources statement ay makakatulong na matiyak na ang file ay sarado nang tama kung sakaling magkaroon ng exception.

Paano ayusin ang Listahan sa Java. Iba't ibang Mga Paraan ng Pag-uuri ng Listahan sa Java

Pinagmulan: FreeCodeCamp Sinasaklaw ng post na ito ang iba't ibang paraan ng pag-uuri ng Listahan sa Java: Collections.sort() , stream.sorted() at List.sort() . Minsan ang data ay kailangang isaayos sa isang partikular na pagkakasunud-sunod upang gawing mas madaling maunawaan, mahanap, at maproseso. Tinatawag namin itong prosesong pag-uuri. Gamit ang pag-uuri, maaari mong ayusin ang data hindi lamang sa isang partikular na pagkakasunud-sunod, ngunit ayon din sa pamantayan: halimbawa, ayon sa uri ng data, kabilang ang mga numero, string, at mga bagay. Ang wikang Java ay may mga built-in na pamamaraan para sa pag-uuri, halimbawa sa mga klase ng Collections . Ang pag-uuri ng Java ay kadalasang ginagamit sa mga e-commerce na application kung saan kailangang magpakita ang user ng listahan ng mga produkto. Maaaring pagbukud-bukurin ang mga produkto sa iba't ibang paraan depende sa mga kinakailangan na itinakda ng user, tulad ng presyo, rating, brand, at iba pa. Halimbawa, kung gusto ng user na makita ang lahat ng produkto na pinagsunod-sunod ayon sa presyo sa pataas na pagkakasunud-sunod, maaaring gumamit ang application ng algorithm ng pag-uuri upang ayusin ang mga produkto sa ganoong pagkakasunud-sunod. Sa ganitong paraan, kapag nag-browse ang isang user ng mga produkto, makikita niya muna ang pinakamurang mga produkto at makakagawa siya ng desisyon sa pagbili nang naaayon.

Paano gamitin ang pamamaraang Collections.Sort() sa Java

Ang isa sa mga pinakakaraniwang paraan upang pagbukud-bukurin ang data sa Java ay ang paggamit ng Collections.sort() method . Bilang default, inaayos nito ang listahan sa pataas na pagkakasunud-sunod. Narito ang isang halimbawa ng paggamit ng paraan ng Collections.sort() upang pagbukud-bukurin ang isang Listahan ng mga 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);
    }
}

Ang code sa itaas ay lumilikha ng isang listahan ng mga integer, nagdaragdag ng apat na numero dito, pinagbubukod-bukod ang listahan, at pagkatapos ay ipi-print ang pinagsunod-sunod na listahan sa console. Gumagamit ito ng mga klase mula sa Java Standard Library upang magsagawa ng mga operasyon, kabilang ang java.util.Collections , java.util.List , at java.util.ArrayList . Ang output ay ang mga sumusunod: Maaari mo ring pagbukud-bukurin ang isang listahan ng mga custom na bagay gamit ang Collections.sort() method . Para magawa ito, kakailanganin mong gumawa ng comparator at ipasa ito bilang argumento sa Collections.sort() method . Ang comparator ay isang object na nagpapatupad ng java.util.Comparator interface . Ito ay may iisang callable method, compare() , na naghahambing ng dalawang object at nagbabalik ng integer na nagpapahiwatig ng kanilang relative order. Narito ang isang halimbawa ng kung paano gumamit ng comparator upang pagbukud-bukurin ang isang listahan ng mga custom na bagay:

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();
    }
}

Ang code na ipinapakita sa itaas ay lumilikha ng isang listahan ng mga Person object , nagdaragdag ng ilang Person object sa listahan , pinagbubukod-bukod ang listahan gamit ang custom comparator ( PersonComparator ), at pagkatapos ay i-print ang pinagsunod-sunod na listahan. Ang klase ng Tao ay may dalawang field, pangalan at edad , pati na rin ang mga pamamaraan ng getter para sa mga field na ito. Ang klase ng PersonComparator ay nagpapatupad ng interface ng Comparator at nilalampasan ang paraan ng paghahambing upang pagbukud-bukurin ang mga bagay ng Tao ayon sa edad ( edad ). Ang output ng program na ito ay magiging ganito: Ang pamamaraang Collections.sort() ay pinakamahusay na ginagamit kapag mayroon kang koleksyon ng mga bagay na gusto mong pagbukud-bukurin ayon sa isa o higit pang mga field. Halimbawa, kung mayroon kang koleksyon ng mga object ng Empleyado at gusto mong pagbukud-bukurin ang mga ito ayon sa apelyido, maaari mong gamitin ang paraan ng Collections.sort() at magpasa ng custom na comparator na naghahambing sa mga apelyido ng mga object ng Employee .

Paano gamitin ang List.Sort() na pamamaraan sa Java

Inaayos ng pamamaraang ito ang listahan sa pataas na pagkakasunud-sunod. Narito kung paano ito gumagana:

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]
    }
}

Sa loob ng pangunahing paraan , ang Arrays.asList ay lumilikha ng isang listahan ng mga integer na tinatawag na mga numero . Pagkatapos ay pinag-uuri-uriin ng code ang listahang ito ng mga numero gamit ang default na paraan ng pag-uuri, dahil ang null ay ipinapasa sa paraan ng pag-uuri . Panghuli, ang pinagsunod-sunod na listahan ay naka-print sa console gamit ang System.out.println method . Ang output ay [1, 2, 3, 4, 5] . Ang List.sort() ay kapaki-pakinabang kapag mayroon kang listahan ng mga elemento na kailangang ayusin. Halimbawa, kung mayroon kang listahan ng mga string at gusto mong pagbukud-bukurin ang mga ito ayon sa alpabeto, maaari mong gamitin ang List.sort() na paraan upang gawin ito . Ang List.sort() ay isang instance na paraan ng klase ng Listahan at pinag-uuri-uri ang mga elemento sa pagkakasunud-sunod na tinutukoy ng kanilang natural na pagkakasunud-sunod o ang ibinigay na pagpapatupad ng Icomparer .

Paano gamitin ang stream.sorted() na pamamaraan sa Java

Sa Java 8 at mas bago, maaari mong gamitin ang Stream API upang pagbukud-bukurin ang isang listahan. Nagbibigay ito ng pinagsunod-sunod na paraan , na maaaring gamitin upang pag-uri-uriin ang mga elemento ng isang stream. Narito ang isang halimbawa kung paano pag-uri-uriin ang isang listahan ng mga integer gamit ang isang stream:

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]

    }
}

Tulad ng nakikita mo, ang listahan ng mga numero ay na-convert sa isang stream gamit ang stream() method . Ang sorted() method ay tinatawag na para pag-uri-uriin ang mga elemento sa stream . Ang paraan ng collect(Collectors.toList()) ay ginagamit upang kolektahin ang mga pinagsunod-sunod na elemento pabalik sa isang listahan. Ang resulta ay isang bagong listahan na naglalaman ng mga pinagsunod-sunod na elemento. Ang output ay [1, 2, 3, 4, 5] . stream.sorted() ay pinakamahusay na ginagamit kapag mayroon kang isang stream ng mga elemento na kailangang ayusin. Halimbawa, kung mayroon kang stream ng mga integer at gusto mong pagbukud-bukurin ang mga ito sa pataas na pagkakasunud-sunod, mas mainam na gamitin ang stream.Sorted() na paraan para dito .

Konklusyon

Sa tutorial na ito, natutunan mo na may ilang paraan para pagbukud-bukurin ang isang listahan sa Java - ang Collections.sort() method , ang stream.sorted() method , at ang List.sort() method . Alin sa mga pamamaraang ito ang pinakamahusay na gamitin ay depende sa mga partikular na pangangailangan ng gawaing nasa kamay. Umaasa ako na ang artikulong ito ay nagbigay sa iyo ng tamang impormasyon sa kung paano ayusin ang isang listahan sa Java. Maligayang coding!