Coffee break #217. Paano simulan ang Listahan sa Java. 7 Simpleng Trick para Pagbutihin ang Java Productivity: Mga Tip at Halimbawa

Paano simulan ang Listahan sa Java

Pinagmulan: FreeCodeCamp Sinasaklaw ng artikulong ito ang iba't ibang paraan ng pagsisimula ng Listahan sa Java na may mga praktikal na halimbawa. Isa sa mga pangunahing istruktura ng data sa wikang Java ay ang Listahan . Pinapayagan nito ang mga developer na mag-imbak at mamahala ng isang hanay ng mga elemento. Ang pagsisimula ng Listahan sa Java ay isang mahalagang hakbang sa proseso ng pag-unlad dahil tinutukoy nito ang paunang estado ng Listahan at inihahanda ito para sa mga karagdagang operasyon. Mayroong iba't ibang mga paraan upang simulan ang isang Listahan sa Java, ang pagpili ay depende sa mga partikular na kinakailangan ng proyekto:

• Gamit ang ArrayList constructor .
• Gamit ang add() method .
• Gamit ang Arrays.asList() method .
• Gamit ang Stream.of() method .

Tingnan natin ang mga pamamaraang ito nang mas malapitan.

Paano simulan ang isang listahan gamit ang ArrayList constructor

Sa Java, ang klase ng ArrayList ay isang pagpapatupad ng dynamic na array interface List , na nagbibigay-daan sa iyong magdagdag at mag-alis ng mga elemento mula sa isang listahan kung kinakailangan. Ang klase ng ArrayList ay nagbibigay ng ilang mga konstruktor para sa paglikha ng isang halimbawa ng klase. Ang syntax upang lumikha ng isang ArrayList object na walang paunang kapasidad ay:

ArrayList<Object> list = new ArrayList<Object>();

Ang no-argument constructor ay lumilikha ng isang walang laman na listahan ( List ) na may paunang kapasidad na 10 elemento. Kung lumampas ang listahan sa kapasidad na ito, awtomatikong pinapataas ng klase ng ArrayList ang kapasidad sa pamamagitan ng paglikha ng bago, mas malaking array at pagkopya ng mga elemento mula sa lumang array patungo sa bagong array. Bilang kahalili, maaari tayong lumikha ng ArrayList object na may paunang kapasidad gamit ang isang constructor na may isang integer argument, kung saan ang kapasidad ay ang paunang kapasidad ng listahan:

ArrayList<Object> list = new ArrayList<Object>(capacity);

Upang simulan ang isang Listahan na may mga halaga, maaari tayong gumamit ng isang constructor na kumukuha ng isang Koleksyon bilang argumento. Maaari mong ipasa ang anumang object ng koleksyon na nagpapatupad ng interface ng Collection sa constructor na ito , tulad ng isa pang ArrayList o LinkedList . Ang mga elemento ng koleksyon ay idinaragdag sa bagong ArrayList sa pagkakasunud-sunod kung saan sila lumabas sa koleksyon. Narito ang isang halimbawa kung paano lumikha ng isang ArrayList at simulan ito ng mga halaga gamit ang isang constructor na kumukuha ng isang Collection :

import java.util.ArrayList;
import java.util.Arrays;

public class Example {
    public static void main(String[] args) {
        // создаем массив целых чисел
        Integer[] array = {1, 2, 3, 4, 5};

        // создаем список из массива
        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(array));

        // печатаем список
        System.out.println(list); // [1, 2, 3, 4, 5]
    }
}

Sa halimbawang ito, gumawa kami ng array ng mga integer at pagkatapos ay ipapasa ito sa Arrays.asList() na paraan upang lumikha ng List object . Pagkatapos ay ipinapasa namin ang List object na ito sa ArrayList constructor upang lumikha ng bagong ArrayList na may parehong mga elemento tulad ng orihinal na array. Panghuli, ipi-print namin ang mga nilalaman ng listahan gamit ang System.out.println() method .

Paano simulan ang Listahan gamit ang paraan ng add().

Ang paraan ng add() ay malawakang ginagamit sa Java upang magdagdag ng mga elemento sa isang koleksyon o listahan. Available ang paraang ito para sa ilang uri ng koleksyon sa Java, kabilang ang List , Set , at Map . Ang paraan ng add() ay tumatagal ng isang argumento—ang elementong idaragdag sa koleksyon. Pagdating sa pagdaragdag ng mga elemento sa isang vList , ang add() na paraan ay lalong kapaki-pakinabang dahil ang mga listahan sa Java ay mga order na koleksyon na maaaring maglaman ng mga duplicate. Ang paraan ng add() ay maaaring gamitin upang magdagdag ng mga elemento sa dulo ng isang listahan, na ginagawa itong isang maginhawang paraan upang simulan ang isang Listahan na may ilang mga paunang halaga. Narito ang isang halimbawa kung paano gamitin ang add() na paraan upang simulan ang isang Listahan sa Java:

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

public class ListExample {
    public static void main(String[] args) {
        // создаем новый ArrayList
        List<String> myList = new ArrayList<>();

        // добавляем элементы в список, используя метод the add()
        myList.add("apple");
        myList.add("banana");
        myList.add("cherry");

        // печатаем содержимое списка
        System.out.println(myList);
    }
}

Sa halimbawang ito, lumikha muna kami ng bagong ArrayList na pinangalanang myList . Pagkatapos ay gagamitin namin ang paraan ng add() upang magdagdag ng tatlong string ("mansanas", "saging" at "cherry") sa dulo ng listahan. Pagkatapos ay i-print namin ang mga nilalaman ng listahan gamit ang System.out.println() method . Kapag pinatakbo namin ang programa, ang output ay magiging ganito:

Paano simulan ang Listahan gamit ang Arrays.asList() na pamamaraan

Ang built-in na Arrays.asList() na pamamaraan ng Java ay nagko-convert ng array sa isang listahan. Ang pamamaraang ito ay kumukuha ng array bilang argumento at nagbabalik ng List object . Ang object na ibinalik ng Arrays.asList() method ay isang fixed-size na listahan, na nangangahulugang hindi kami maaaring magdagdag o mag-alis ng mga elemento mula dito. Upang magamit ang Arrays.asList() na paraan upang simulan ang isang Listahan sa Java, kailangan nating sundin ang mga sumusunod na hakbang: Una, magdeklara tayo ng hanay ng mga elemento kung saan gusto nating simulan ang listahan. Halimbawa, ipagpalagay na gusto naming simulan ang isang listahan na may tatlong elemento: "mansanas", "saging" at "orange". Dito maaari naming ipahayag ang isang array tulad nito:

String[] fruits = {"apple", "banana", "orange"};

Pagkatapos ay tinatawagan namin ang paraan ng Arrays.asList() at ipasa ang array bilang argumento. Magbabalik ito ng List object na naglalaman ng mga elemento ng array.

List<String> fruitList = Arrays.asList(fruits);

Ngayon ay maaari na nating gamitin ang fruitList object upang ma-access ang mga elemento ng listahan. Halimbawa, maaari tayong umulit sa isang listahan at i-print ang bawat elemento:

for (String fruit : fruitList) {
    System.out.println(fruit);
}

Konklusyon: Mahalagang tandaan na ang Arrays.asList() na paraan ay hindi gumagawa ng bagong List object , ngunit nagbabalik ng List object na representasyon ng orihinal na array . Nangangahulugan ito na kung babaguhin natin ang orihinal na array, ang mga pagbabago ay makikita rin sa List object . Halimbawa:

fruits[0] = "pear";
System.out.println(fruitList.get(0)); // Вывод: pear

Sa halimbawa sa itaas, binago namin ang unang elemento ng hanay ng mga prutas sa "peras". Kapag na-access namin ang unang elemento ng object ng fruitList , nakakakuha din kami ng "pear" dahil ang fruitList ay isang representasyon lamang ng array ng mga prutas .

Paano simulan ang Listahan gamit ang Stream.of() na pamamaraan

Ang Stream.of() ay isang convenience method na ibinigay ng Java 8 at mas bago sa java.util.stream package . Ito ay ginagamit upang lumikha ng isang stream ng mga elemento ng anumang uri, kabilang ang mga primitive na uri, array, at mga bagay. Ang pamamaraang ito ay tumatagal ng isa o higit pang mga argumento at nagbabalik ng stream na binubuo ng mga argumentong iyon. Syntax ng Stream.of() na pamamaraan :

Stream<T> stream = Stream.of(t1, t2, t3, ..., tn);

Narito ang T ay ang uri ng mga elemento sa stream, at ang t1 at higit pa hanggang sa tn ay ang mga elemento na dapat isama sa stream. Upang simulan ang isang Listahan sa Java gamit ang Stream.of() na pamamaraan , kailangan mong gawin ang sumusunod:

1. I-import muna ang java.util.stream package .

2. Pagkatapos ay gamitin ang constructor upang lumikha ng isang listahan ng nais na uri ng ArrayList, halimbawa:

   List<String> myList = new ArrayList<>();

3. I-initialize ang listahan gamit ang Stream.of() method , ipasa ang mga gustong elemento bilang argumento, at pagkatapos ay gamitin ang collect() method para kolektahin ang stream elements sa isang listahan, halimbawa:

   myList = Stream.of("Apple", "Banana", "Cherry", "Date")
                 .collect(Collectors.toList());

4. Maaari naming i-print ang listahan upang suriin ang mga nilalaman nito.

   System.out.println(myList);

   Konklusyon:

   [Mansanas, Saging, Cherry, Petsa]

Konklusyon

Ang pagsisimula ng isang Listahan sa Java ay isang medyo karaniwang gawain sa programming, at mayroong ilang mga paraan upang gawin ito. Sa pamamagitan ng pagsunod sa mga hakbang na inilarawan sa artikulong ito, madali tayong makakagawa at makakapagsimula ng Listahan na may mga gustong elemento gamit ang Stream.of() na pamamaraan . Ang diskarte na ito ay maikli at nababaluktot, at maaaring maging kapaki-pakinabang lalo na kapag kailangan nating simulan ang isang listahan na may maliit na bilang ng mga elemento. Maligayang coding!

7 Simpleng Trick para Pagbutihin ang Java Productivity: Mga Tip at Halimbawa

Source: Medium Narito ang isang seleksyon ng pitong praktikal na tip na, kung susundin, ay makakatulong na mapabuti ang pagiging produktibo ng isang developer ng Java. Mapapabuti mo ang pagganap ng iyong mga Java application sa pamamagitan ng pagsunod sa ilang simpleng tip.

1. Gumamit ng mga primitive na uri sa halip na mga bagay:

// Плохо: использование an object Integer
Integer count = 0;
for (int i = 0; i < 1000000; i++) {
    count++;
}

// Хорошо: использование примитива int
int count = 0;
for (int i = 0; i < 1000000; i++) {
    count++;
}

2. Iwasang lumikha ng mga hindi kinakailangang bagay:

// Плохо: использование конкатенации строк с помощью '+'
String str = "";
for (int i = 0; i < 10000; i++) {
    str += i;
}

// Хорошо: использование StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String str = sb.toString();

3. Gamitin ang tamang istraktura ng data:

// Плохо: использование List для частого поиска
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// ...
if (names.contains("Charlie")) {
    // ...
}

// Хорошо: использование HashSet для частого поиска
Set<String> names = new HashSet<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// ...
if (names.contains("Charlie")) {
    // ...
}

4. I-minimize ang mga method call:

// Плохо: вызов метода внутри цикла
for (int i = 0; i < 1000000; i++) {
    doSomething(i);
}

// Хорошо: выносим метод за пределы цикла
for (int i = 0; i < 1000000; i++) {
    // ...
}
doSomething(i);

5. Gumamit ng mga static at final modifier:

// Плохо: создание ненужных экземпляров an objectов
public class MyClass {
    private int value;
    public void setValue(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
MyClass obj = new MyClass();
obj.setValue(10);
int value = obj.getValue();

// Хорошо: использование статических и финальных модификаторов
public class MyClass {
    private static final int DEFAULT_VALUE = 0;
    private final int value;
    public MyClass(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
MyClass obj = new MyClass(10);
int value = obj.getValue();

6. Gumamit ng algorithm na naaangkop sa sitwasyon:

// Плохо: использовать линейный поиск для большой коллекции
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// ...
int target = 7;
for (int i = 0; i < nums.size(); i++) {
    if (nums.get(i) == target) {
        // ...
    }
}
// Хорошо: использование бинарного поиска для большой коллекции
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// ...
int target = 7;
int index = Collections.binarySearch(nums, target);
if (index >= 0) {
    // ...
}

7. I-optimize ang iyong mga cycle:

// Плохо: вызов метода внутри цикла
for (int i = 0; i< 1000000; i++) {
    String str = getString(i);
    // ...
}

// Хорошо: минимизация вызовов методов в цикле
for (int i = 0; i < 1000000; i++) {
    String str = "String " + i;
    // ...
}

Ito ay ilan lamang sa mga simpleng trick ng Java na maaaring mapabuti ang iyong pagiging produktibo. Tandaan na maaaring maging mahirap ang pag-optimize sa performance, at kadalasang kailangang suriin ng developer ang kanilang code upang matukoy ang mga bottleneck sa performance.