Coffee break #149. Paano mag-upgrade mula sa Java 8 hanggang Java 17. Iba't ibang paraan upang umulit sa isang listahan sa Java

Paano mag-migrate mula sa Java 8 hanggang Java 17

Source: Medium Gamit ang publication na ito, madali kang makakapag-upgrade mula sa Java 8 hanggang Java 17. Ang bawat bagong release ng Java, lalo na kung pinag-uusapan natin ang tungkol sa long-term support (LTS) na bersyon, ay nagbibigay sa mga developer ng maraming bagong feature at function, na nag-aalis naunang natuklasang mga error at pinapabuti ang pagganap. Ngunit sa ngayon, sa kabila ng katotohanan na ang Java 17 ay inilabas halos isang taon na ang nakalipas, ang pinakasikat na bersyon ng wika ay ang Java 8 pa rin. Marami ang nag-aalangan na mag-upgrade, sa paniniwalang ang bagong bersyon ng Java ay hindi ganap na tugma sa mga nakaraang bersyon, at ang pag-upgrade dito ay mangangailangan ng maraming pagsisikap. Sa personal, sa tingin ko ito ay kinakailangan upang mag-upgrade. Gumagamit na ako ng Java 17, kahit na nagkaroon ako ng ilang mga problema sa pag-upgrade. Bilang karagdagan, ito ay nagkakahalaga ng pagsasaalang-alang na ang Java 8 ay matagal nang tumigil na maging isang libreng serbisyo. Ang pagganap ng Java 17 ay mas mahusay. Halimbawa, sa paggamit ng ZGC, hindi mo na kailangang mag-alala tungkol sa pag-configure ng mga setting ng pangongolekta ng basura. Kung gusto mong lumipat mula sa Java 8 patungong Java 17, kailangan mong gumawa ng ilang karagdagang trabaho. Dahil napuntahan ko na ang rutang ito, maibabahagi ko ang aking karanasan sa paglipat sa bagong bersyon.

I-update ang bersyon ng Maven compiler plugin

Para sa ilang developer, maaaring masyadong luma ang bersyon ng Maven compiler plugin. Kung gusto mong magtrabaho sa Java 17, ang bersyon ng plugin ng Maven compiler ay dapat na hindi bababa sa 3.5.4.

I-update ang mga dependency

Ang unang hakbang kapag nag-a-upgrade mula sa Java 8 hanggang Java 17 ay ang pag-update ng iyong mga dependency. Dahil ang dependency na orihinal mong ginamit ay malamang na hindi sumusuporta sa Java 17, kakailanganin mong i-update ito kung gusto mong bawasan ang epekto ng pag-upgrade ng bersyon. Kung hindi, maaari kang makaharap ng maraming problema. 1. Halimbawa, ang Lombok ay magdudulot ng error sa compilation. Ang impormasyon ng error ay ang mga sumusunod: Dahil ini-inject ng Lombok ang nabuong code sa oras ng pag-compile at ginagamit ang mga klase mula sa com.sun.tools.javac.* package , kailangan mong i-update ang Lombok sa pinakabagong bersyon. Malulutas nito ang problema. 2. Ang koneksyon ng zookeeper ay magtapon ng UnresolvedAddressException error , ang impormasyon ng error ay ang sumusunod: Ang dahilan para sa error ay na sa Java 15 ang toString paraan para sa InetSocketAddressHolder ay refactored . Kung gumagamit ka ng maven, maaari mong gamitin ang mvn versions:display-dependency-updates command upang suriin ang mga update sa dependency. Magiging ganito ang resulta:

Magdagdag ng dependency

Kung nag-compile ka sa JAXB, makakatanggap ka ng error. Ito ay dahil ang JAXB ay inalis mula sa Java 11. Kaya kailangan mong magdagdag ng ilang dependency ng JAXB Maven. Bilang karagdagan dito, inaalis din ng Java 11 ang mga module ng Java EE at CORBA, kaya kakailanganin mong manu-manong magdagdag ng mga pakete ng javax.

Pangangasiwa sa InaccessibleObjectException

Kung gumamit ka ng reflection sa iyong application, lalo na setAccessible(true) , malamang na makakatanggap ka ng InaccessibleObjectException error kapag nagsimula ang application. Ang error ay sanhi ng modular system ng platform ng Java, na nagbibigay-daan sa pag-access lamang sa ilalim ng ilang mga kundisyon:

1. Ang klase ay dapat na pampubliko.
2. Dapat mong i-export ang iyong sariling mga pakete.

Upang malutas ang error na ito, maaari mong manu-manong itakda ang module sa publiko. Upang gawin ito, kailangan mong idagdag ang --add-opens na opsyon sa Java startup command line tulad ng ipinapakita sa ibaba. O maaari mong baguhin ang iyong Java code upang tuluyang malutas ang problemang ito.

module java.base {
    exports java.lang;
}

Sa pangkalahatan, pagkatapos malutas ang lahat ng mga isyu sa itaas, dapat gumana nang maayos ang iyong application sa Java 17. Umaasa ako na ang artikulong ito ay makakatulong sa iyong lumipat sa Java 17.

Iba't ibang paraan upang umulit sa isang listahan sa Java

Pinagmulan: Rrtutors Sa artikulong ito, matututo tayo ng ilang paraan para umulit sa isang listahan sa Java. Ang balangkas ng Koleksyon ay may interface ng Listahan na nagpapahintulot sa amin na mapanatili ang isang nakaayos na koleksyon ng mga bagay. Ang interface ng Listahan ay ipinatupad ng ArrayList, LinkedList, Stack, at Vector. Malaking bilang ng mga Java application ang gumagamit ng ArrayList at LinkedList. Mayroong ilang mga paraan upang umulit sa isang listahan, bawat isa ay may sariling katangian.

Paano umulit sa isang listahan sa Java

Maaari kang gumamit ng tatlong paraan upang ulitin ang isang listahan sa Java:

• Gamit ang advanced na Para sa Loop na paraan.
• Gamit ang pamamaraan ng iterator.
• Ulitin ang mga elemento para sa Bawat isa.

1. Gamit ang advanced na Para sa Loop na paraan.

Ito ay isang bersyon ng basic para sa loop na maaaring magamit upang umulit sa isang listahan. Narito ang isang halimbawa:

import java.util.ArrayList;
import java.util.List;
public class Enhanced_for_loop {
            public static void main(String[] args) {
        List<Integer> figurez = new ArrayList<>();
        figurez.add(100);
        figurez.add(200);
        figurez.add(300);
        figurez.add(400);
        for(int i: figurez) {
            System.out.print(i+ " ");
        }
            }
}

Konklusyon:

2. Gamit ang pamamaraan ng iterator.

Maaari ka ring gumamit ng mga iterator upang umulit sa isang listahan. Ang mga iterator ay partikular na kapaki-pakinabang kapag kailangan mong baguhin ang isang iterable na listahan. Halimbawa:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Iterate_List_using_Iterators {
            public static void main(String[] args) {
                        List<Integer> numbari = new ArrayList<>();
                        numbari.add(100);
                        numbari.add(200);
                        numbari.add(300);
                    Iterator<Integer> itr = numbari.iterator();
                    while(itr.hasNext()) {
                        int i = itr.next();
                        System.out.print(i+ " ");
                        if(i==3) {
                            itr.remove();
                        }

            }
            }
}

Konklusyon:

3. Ulitin ang mga elemento para sa Bawat.

Matapos maidagdag ang mga function ng lambda sa Java, ipinakilala ng syntax ng wika ang forEach function, na nagbibigay-daan sa iyong umulit sa anumang koleksyon. Ang sumusunod na halimbawa ng code ay nagpapakita kung paano mo magagamit ang para sa bawat paraan upang umulit sa isang listahan:

import java.util.ArrayList;
import java.util.List;
public class Iterate_List_using_ForeEach_iterable {
            public static void main(String[] args) {
                        List<Integer> numbari = new ArrayList<>();
                        numbari.add(1);
                        numbari.add(2);
                        numbari.add(3);
                        numbari.add(4);
                        numbari.forEach(System.out::println);
            }
}

Konklusyon: