คอฟฟี่เบรค #217. วิธีเริ่มต้นรายการใน Java 7 เคล็ดลับง่ายๆ ในการปรับปรุงประสิทธิภาพการทำงานของ Java: เคล็ดลับและตัวอย่าง

วิธีเริ่มต้นรายการใน Java

ที่มา: FreeCodeCamp บทความนี้ครอบคลุมถึงวิธีการเริ่มต้นรายการต่างๆ ใน ​​Java พร้อมตัวอย่างที่ใช้งานได้จริง หนึ่งในโครงสร้างข้อมูลพื้นฐานในภาษา Java คือList ช่วยให้นักพัฒนาสามารถจัดเก็บและจัดการชุดองค์ประกอบได้ การเริ่มต้นรายการใน Java ถือเป็นขั้นตอนสำคัญในกระบวนการพัฒนา เนื่องจากเป็นการกำหนดสถานะเริ่มต้นของรายการและเตรียมพร้อมสำหรับการดำเนินการต่อไป มีหลายวิธีในการเริ่มต้นรายการใน Java ตัวเลือกจะขึ้นอยู่กับข้อกำหนดเฉพาะของโปรเจ็กต์:

• การใช้ตัว สร้าง ArrayList
• โดยใช้ เมธอด add( )
• ใช้ เมธอด Arrays.asList( )
• โดยใช้ วิธี Stream.of( )

ลองมาดูวิธีการเหล่านี้ให้ละเอียดยิ่งขึ้น

วิธีเริ่มต้นรายการโดยใช้ตัวสร้าง ArrayList

ใน Java คลาส ArrayListเป็นการใช้งานอินเทอร์เฟซอาร์เรย์แบบไดนามิกListซึ่งช่วยให้คุณสามารถเพิ่มและลบองค์ประกอบออกจากรายการได้ตามต้องการ คลาสArrayListมีคอนสตรัคเตอร์หลายตัวสำหรับการสร้างอินสแตนซ์ของคลาส ไวยากรณ์สำหรับสร้าง วัตถุ ArrayListโดยไม่มีความจุเริ่มต้นคือ:

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

ตัวสร้างที่ไม่มีอาร์กิวเมนต์สร้างรายการว่าง ( List ) ด้วยความจุเริ่มต้น 10 องค์ประกอบ หากรายการเกินความจุนี้ คลาสArrayListจะเพิ่มความจุโดยอัตโนมัติโดยการสร้างอาร์เรย์ใหม่ที่มีขนาดใหญ่ขึ้น และคัดลอกองค์ประกอบจากอาร์เรย์เก่าไปยังอาร์เรย์ใหม่ อีกทางหนึ่ง เราสามารถสร้าง อ็อบเจ็กต์ ArrayListด้วยความจุเริ่มต้นโดยใช้ตัวสร้างที่มีอาร์กิวเมนต์จำนวนเต็มหนึ่งตัว โดยที่ความจุคือความจุเริ่มต้นของรายการ:

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

ในการเริ่มต้นรายการด้วยค่า เราสามารถใช้ตัวสร้างที่รับคอลเลกชันเป็นอาร์กิวเมนต์ คุณสามารถส่งผ่านออบเจ็กต์คอลเลกชันใดๆ ที่ใช้อิน เทอร์ เฟซคอลเลก ชันไปยังตัวสร้างนี้ เช่นArrayListหรือLinkedList อื่น องค์ประกอบของคอลเลกชันจะถูกเพิ่มเข้าไปในArrayList ใหม่ ตามลำดับที่ปรากฏในคอลเลกชัน นี่คือตัวอย่างวิธีสร้างArrayListและเริ่มต้นด้วยค่าโดยใช้ Constructor ที่รับ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]
    }
}

ในตัวอย่างนี้ เราสร้างอาร์เรย์ของจำนวนเต็มแล้วส่งต่อไปยังเมธอดArrays.asList ()เพื่อสร้าง ออบเจ็ก ต์รายการ จากนั้นเราจะส่ง อ็อบเจ็กต์ List นี้ไปยัง ตัวสร้างArrayListเพื่อสร้างArrayList ใหม่ ที่มีองค์ประกอบเดียวกันกับอาร์เรย์ดั้งเดิม สุดท้ายนี้ เราพิมพ์ เนื้อหา ของรายการโดยใช้ เมธอด System.out.println()

วิธีเริ่มต้นรายการโดยใช้เมธอด add()

วิธีการadd()ถูกใช้กันอย่างแพร่หลายใน Java เพื่อเพิ่มองค์ประกอบให้กับคอลเลกชันหรือรายการ วิธีการนี้ใช้ได้กับคอลเลกชันหลายประเภทใน Java รวมถึงList , SetและMap add()วิธีการรับหนึ่งอาร์กิวเมนต์ - องค์ประกอบที่จะเพิ่มในคอลเลกชัน เมื่อพูดถึงการเพิ่มองค์ประกอบให้กับvList เมธอด add ()มีประโยชน์อย่างยิ่ง เนื่องจากรายการใน Java เป็นการเรียงลำดับคอลเลกชันที่สามารถมีรายการซ้ำได้ สามารถใช้ เมธอดadd()เพื่อเพิ่มองค์ประกอบที่ส่วนท้ายของรายการ ทำให้เป็นวิธีที่สะดวกในการเริ่มต้นรายการด้วยค่าเริ่มต้นบางค่า นี่คือตัวอย่างวิธีการใช้เมธอดadd()เพื่อเริ่มต้นรายการใน 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);
    }
}

ในตัวอย่างนี้ อันดับแรกเราสร้างArrayListใหม่ชื่อmyList จากนั้นเราใช้ เมธอด add()เพื่อเพิ่มสตริง 3 รายการ ("apple", "banana" และ "cherry") ต่อท้ายรายการ จากนั้นเราจะพิมพ์ เนื้อหาของรายการโดยใช้ เมธอด System.out.println() เมื่อเรารันโปรแกรม ผลลัพธ์จะเป็นดังนี้:

วิธีเริ่มต้นรายการโดยใช้เมธอด Arrays.asList()

วิธีการ Arrays.asList()ในตัวของ Java จะแปลงอาร์เรย์ให้เป็นรายการ วิธีการ นี้รับอาร์เรย์เป็นอาร์กิวเมนต์และส่งกลับ วัตถุ รายการ วัตถุที่ส่งคืนโดย เมธอด Arrays.asList()เป็นรายการที่มีขนาดคงที่ ซึ่งหมายความว่าเราไม่สามารถเพิ่มหรือลบองค์ประกอบออกจากรายการได้ หากต้องการใช้เมธอด Arrays.asList()เพื่อเริ่มต้นรายการใน Java เราต้องทำตามขั้นตอนต่อไปนี้ ขั้นแรก เรามาประกาศอาร์เรย์ขององค์ประกอบที่เราต้องการเริ่มต้นรายการด้วย ตัวอย่างเช่น สมมติว่าเราต้องการเริ่มต้นรายการด้วยองค์ประกอบ 3 อย่าง ได้แก่ "apple", "banana" และ "orange" ที่นี่เราสามารถประกาศอาร์เรย์ได้ดังนี้:

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

จากนั้นเราเรียก เมธอด Arrays.asList()และส่งผ่านอาร์เรย์เป็นอาร์กิวเมนต์ สิ่งนี้จะส่งคืน วัตถุ รายการที่มีองค์ประกอบของอาร์เรย์

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

ตอนนี้เราสามารถใช้ วัตถุ FruitListเพื่อเข้าถึงองค์ประกอบของรายการได้ ตัวอย่างเช่น เราสามารถวนซ้ำรายการและพิมพ์แต่ละองค์ประกอบ:

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

บทสรุป: สิ่งสำคัญที่ควรทราบคือ เมธอด Arrays.asList()ไม่ได้สร้าง อ็อบเจ็กต์ รายการ ใหม่ แต่จะส่งคืน ออบเจ็กต์ รายการ ที่แสดงแทนอาร์เรย์ ดั้งเดิม ซึ่งหมายความว่าหากเราเปลี่ยนอาร์เรย์ดั้งเดิม การเปลี่ยนแปลงดังกล่าวก็จะปรากฏใน อ็อบเจ็กต์ Listด้วย ตัวอย่างเช่น:

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

ในตัวอย่างข้างต้น เราได้เปลี่ยนองค์ประกอบแรกของ อาร์เรย์ ผลไม้เป็น "ลูกแพร์" เมื่อเราเข้าถึงองค์ประกอบแรกของ วัตถุ FruitList เราก็ จะ ได้ "pear" ด้วยเพราะFruitListเป็นเพียงตัวแทนของ อาร์เรย์ Fruits

วิธีเริ่มต้นรายการโดยใช้วิธี Stream.of()

Stream.of()เป็นวิธีอำนวยความสะดวกที่มีให้โดย Java 8 และใหม่กว่าในแพ็คเกจjava.util.stream มันถูกใช้เพื่อสร้างกระแสขององค์ประกอบทุกประเภท รวมถึงประเภทดั้งเดิม อาร์เรย์ และอ็อบเจ็กต์ วิธีการนี้รับหนึ่งหรือหลายข้อโต้แย้งและส่งกลับกระแสที่ประกอบด้วยข้อโต้แย้งเหล่านั้น ไวยากรณ์ ของวิธีการ Stream.of() :

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

โดยที่Tคือประเภทขององค์ประกอบในสตรีม และt1และเพิ่มเติมไปจนถึงtnคือองค์ประกอบที่ควรรวมไว้ในสตรีม ในการเริ่มต้นรายการใน Java โดยใช้ เมธอด Stream.of()คุณต้องทำสิ่งต่อไปนี้:

1. ขั้นแรกให้นำเข้าแพ็คเกจjava.util.stream

2. จากนั้นใช้ Constructor เพื่อสร้างรายการประเภท ArrayList ที่ต้องการ เช่น:

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

3. เริ่มต้นรายการโดยใช้ เมธอด Stream.of()โดยส่งองค์ประกอบที่ต้องการเป็นอาร์กิวเมนต์ จากนั้นใช้ เมธอด collect()เพื่อรวบรวมองค์ประกอบสตรีมลงในรายการ เช่น:

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

4. จากนั้นเราสามารถพิมพ์รายการเพื่อตรวจสอบเนื้อหาได้

   System.out.println(myList);

   บทสรุป:

   [แอปเปิ้ล, กล้วย, เชอร์รี่, อินทผลัม]

บทสรุป

การเริ่มต้นรายการใน Java เป็นงานการเขียนโปรแกรมที่ค่อนข้างธรรมดา และมีหลายวิธีในการดำเนินการดังกล่าว ด้วยการทำตามขั้นตอนที่อธิบายไว้ในบทความนี้ เราสามารถสร้างและเริ่มต้นรายการด้วยองค์ประกอบที่ต้องการได้อย่างง่ายดายโดยใช้เมธอดStream.of() วิธีการนี้กระชับและยืดหยุ่น และอาจมีประโยชน์อย่างยิ่งเมื่อเราต้องการเริ่มต้นรายการด้วยองค์ประกอบจำนวนเล็กน้อย ขอให้มีความสุขในการเขียนโค้ด!

7 เคล็ดลับง่ายๆ ในการปรับปรุงประสิทธิภาพการทำงานของ Java: เคล็ดลับและตัวอย่าง

ที่มา: ปานกลาง นี่คือเคล็ดลับที่เป็นประโยชน์ 7 ข้อที่หากปฏิบัติตามจะช่วยปรับปรุงประสิทธิภาพของนักพัฒนา Java คุณสามารถปรับปรุงประสิทธิภาพของแอปพลิเคชัน Java ของคุณได้โดยการทำตามคำแนะนำง่ายๆ เหล่านี้

1. ใช้ประเภทดั้งเดิมแทนวัตถุ:

// Плохо: использование 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. หลีกเลี่ยงการสร้างวัตถุที่ไม่จำเป็น:

// Плохо: использование конкатенации строк с помощью '+'
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. ใช้โครงสร้างข้อมูลที่ถูกต้อง:

// Плохо: использование 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. ลดการเรียกเมธอด:

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

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

5. ใช้ตัวแก้ไขแบบคงที่และขั้นสุดท้าย:

// Плохо: создание ненужных экземпляров 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. ใช้อัลกอริทึมที่เหมาะสมกับสถานการณ์:

// Плохо: использовать линейный поиск для большой коллекции
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. เพิ่มประสิทธิภาพรอบการทำงานของคุณ:

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

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

นี่เป็นเพียงเคล็ดลับง่ายๆ ของ Java ที่สามารถปรับปรุงประสิทธิภาพการทำงานของคุณได้ โปรดทราบว่าการเพิ่มประสิทธิภาพการทำงานอาจเป็นเรื่องที่ท้าทาย และนักพัฒนามักจะต้องวิเคราะห์โค้ดของตนเพื่อระบุจุดคอขวดของประสิทธิภาพ