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

from types import MappingProxyType
from dataclasses import dataclass, field

# MappingProxyType: 읽기 전용 딕셔너리 뷰
original = {"a": 1, "b": 2, "c": 3}
readonly = MappingProxyType(original)
print(readonly["a"])      # 1
# readonly["a"] = 10      # TypeError!

# 원본 변경은 뷰에 반영됨
original["d"] = 4
print(readonly["d"])      # 4

# 불변 데이터클래스
@dataclass(frozen=True)
class Config:
    host: str
    port: int
    tags: tuple[str, ...] = ()  # 불변 시퀀스

    def with_port(self, new_port: int) -> "Config":
        """변경된 복사본 반환"""
        return Config(self.host, new_port, self.tags)

cfg = Config("localhost", 8080, ("web", "api"))
# cfg.port = 9090  # FrozenInstanceError

cfg2 = cfg.with_port(9090)
print(f"{cfg.port} → {cfg2.port}")  # 8080 → 9090

# 해시 가능 (딕셔너리 키로 사용 가능)
cache = {cfg: "기본 설정", cfg2: "새 설정"}
print(cache[cfg])  # 기본 설정

package main

import "fmt"

func main() {
	// 슬라이스 생성
	s1 := []int{1, 2, 3, 4, 5}
	s2 := make([]int, 5)       // len=5, cap=5, 제로값
	s3 := make([]int, 3, 10)   // len=3, cap=10

	// append — 용량 초과 시 새 배열 할당 (약 2배)
	s := []int{1, 2, 3}
	s = append(s, 4)
	s = append(s, 5, 6, 7)       // 여러 값
	s = append(s, s1...)          // 슬라이스 전개

	// 슬라이싱 [low:high:max]
	fmt.Println(s[1:4])   // [2 3 4]
	fmt.Println(s[:3])    // [1 2 3]
	fmt.Println(s[3:])    // [4 5 6 7 1 2 3 4 5]

	// copy — 독립적인 복사
	dst := make([]int, 3)
	n := copy(dst, s1)
	fmt.Println(dst, n)   // [1 2 3] 3

	// 2D 슬라이스
	matrix := make([][]int, 3)
	for i := range matrix {
		matrix[i] = make([]int, 3)
		for j := range matrix[i] { matrix[i][j] = i*3 + j }
	}

	// 슬라이스 함수들 (Go 1.21+)
	// slices.Sort, slices.Contains, slices.Index
	// import "slices"

	// 삭제 — 순서 유지
	i := 2
	s1 = append(s1[:i], s1[i+1:]...)
	fmt.Println(s1) // [1 2 4 5]

	// 삭제 — 순서 무관 (빠름)
	s2[i] = s2[len(s2)-1]
	s2 = s2[:len(s2)-1]

	fmt.Println(len(s3), cap(s3)) // 3 10
	_ = s2
}

import java.util.*;

public class ImmutableCollections {
    public static void main(String[] args) {
        // List.of — 불변 리스트
        List<String> list = List.of("A", "B", "C");
        // list.add("D"); // UnsupportedOperationException

        // Set.of — 불변 집합
        Set<Integer> set = Set.of(1, 2, 3);
        // 중복 시 IllegalArgumentException

        // Map.of — 최대 10개 엔트리
        Map<String, Integer> map = Map.of("a", 1, "b", 2);

        // Map.ofEntries — 10개 초과
        Map<String, Integer> large = Map.ofEntries(
            Map.entry("key1", 1),
            Map.entry("key2", 2),
            Map.entry("key3", 3)
        );

        // 기존 컬렉션을 불변으로 복사
        List<String> mutable = new ArrayList<>(List.of("X", "Y"));
        List<String> immutable = List.copyOf(mutable);
        mutable.add("Z"); // 원본은 변경 가능
        System.out.println(mutable);    // [X, Y, Z]
        System.out.println(immutable);  // [X, Y] (영향 없음)

        // Collections.unmodifiable* vs List.of
        // unmodifiable: 래퍼 (원본 변경 반영)
        // List.of/copyOf: 독립 복사본
    }
}

<?php
$langs = ['php', 'python', 'go'];
print_r($langs);

// 배열 생성과 순회
const values = [3, 1, 4, 15];
console.log([...values].sort((a, b) => a - b));

// 배열 생성과 순회
const values: number[] = [3, 1, 4, 15];
console.log([...values].sort((a, b) => a - b));

// 배열 생성과 순회
using System;

var count = 15;
Console.WriteLine(count > 5 ? "big" : "small");

// 배열 생성과 순회
#include <iostream>

int main() {
    int count = 15;
    std::cout << (count > 5 ? "big" : "small") << "\n";
}

// 배열 생성과 순회
fn main() {
    let count = 15;
    let label = if count > 5 { "big" } else { "small" };
    println!("{}", label);
}