List를 언어별로 비교하기

// 불변 컬렉션
val list = listOf(1, 2, 3, 4, 5)
val set  = setOf("a", "b", "c", "b")    // 중복 제거
val map  = mapOf("one" to 1, "two" to 2)

// 가변 컬렉션
val mList = mutableListOf(1, 2, 3)
mList.add(4)
mList.removeAt(0)
mList[0] = 99

val mMap = mutableMapOf("a" to 1)
mMap["b"] = 2
mMap.remove("a")

// 읽기 안전
println(map["one"])          // 1 (Int?)
println(map.getOrDefault("three", 0))  // 0
println(map.getOrElse("three") { -1 }) // -1

// 컬렉션 + 연산
val combined = list + listOf(6, 7)     // 새 리스트 반환
val filtered = list - listOf(2, 4)     // [1, 3, 5]

// 배열
val arr = arrayOf(1, 2, 3)
val intArr = intArrayOf(1, 2, 3)       // primitive 배열
println(intArr.sum())                   // 6

import sys
import time

# 메모리 비교
list_data = [x ** 2 for x in range(1_000_000)]
gen_data = (x ** 2 for x in range(1_000_000))

print("=== 메모리 비교 ===")
print(f"리스트: {sys.getsizeof(list_data):>12,} bytes")
print(f"제너레이터: {sys.getsizeof(gen_data):>8,} bytes")

# 속도 비교: 전체 소비
def time_it(name, func):
    start = time.perf_counter()
    result = func()
    elapsed = time.perf_counter() - start
    print(f"  {name}: {elapsed:.4f}초 → {result}")

print("\n=== 합계 계산 속도 ===")
time_it("리스트 컴프", lambda: sum([x**2 for x in range(100000)]))
time_it("제너레이터", lambda: sum(x**2 for x in range(100000)))

# 언제 무엇을 사용?
print("\n=== 선택 기준 ===")
guidelines = {
    "리스트": ["인덱스 접근 필요", "여러 번 순회", "len() 필요", "슬라이싱"],
    "제너레이터": ["한 번만 순회", "대용량 데이터", "메모리 제한", "지연 평가"],
}
for type_name, cases in guidelines.items():
    print(f"  {type_name}:")
    for case in cases:
        print(f"    - {case}")

# 체이닝 성능
# 각 단계에서 중간 리스트 생성 없이 처리
result = sum(
    x for x in (i**2 for i in range(10000))
    if x % 3 == 0
)
print(f"\n체이닝 결과: {result}")

package main

import (
	"container/list"
	"fmt"
)

func main() {
	l := list.New()

	// 삽입
	l.PushBack("두 번째")
	front := l.PushFront("첫 번째")
	l.PushBack("세 번째")
	l.InsertAfter("사이에", front)

	// 순회
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}

	// 역순 순회
	fmt.Println("--- 역순 ---")
	for e := l.Back(); e != nil; e = e.Prev() {
		fmt.Println(e.Value)
	}

	// 삭제
	l.Remove(front)
	fmt.Println("길이:", l.Len())
}

import java.util.*;

public class CollectionsDemo {
    public static void main(String[] args) {
        // List — 순서 있는 중복 허용
        List<String> arrayList = new ArrayList<>();    // 조회 O(1)
        List<String> linkedList = new LinkedList<>();  // 삽입/삭제 O(1)
        List<String> immutable = List.of("a", "b", "c"); // 불변 (Java 9+)

        arrayList.addAll(List.of("banana", "apple", "cherry"));
        Collections.sort(arrayList);
        System.out.println(arrayList); // [apple, banana, cherry]

        // Map — 키-값, 키 중복 불가
        Map<String, Integer> hashMap    = new HashMap<>();   // 순서 없음
        Map<String, Integer> linkedMap  = new LinkedHashMap<>(); // 삽입 순서
        Map<String, Integer> treeMap    = new TreeMap<>();   // 키 정렬

        hashMap.put("banana", 2);
        hashMap.put("apple", 1);
        hashMap.put("cherry", 3);

        // getOrDefault, putIfAbsent, computeIfAbsent
        hashMap.getOrDefault("durian", 0);
        hashMap.putIfAbsent("apple", 99);     // apple 이미 있어 무시
        hashMap.computeIfAbsent("elderberry", k -> k.length());
        hashMap.merge("apple", 5, Integer::sum); // apple = 1+5 = 6

        // 순회
        hashMap.forEach((k, v) ->
            System.out.println(k + ": " + v));

        // Set — 중복 없음
        Set<String> hashSet  = new HashSet<>(arrayList);  // 순서 없음
        Set<String> treeSet  = new TreeSet<>(arrayList);  // 정렬
        Set<String> immSet   = Set.of("x", "y", "z");     // 불변

        // Collections 유틸리티
        System.out.println(Collections.max(arrayList));
        System.out.println(Collections.frequency(arrayList, "apple"));
        Collections.shuffle(arrayList);
        Collections.reverse(arrayList);
        Collections.unmodifiableList(arrayList);  // 불변 뷰
    }
}

<?php
[$first, $second] = ['php', 'laravel'];
echo $first . ' / ' . $second;