Python, Javascript, Go, Java 언어의 Data Structure 활용 방법 비교

seungkyua 24.01.16

2,561 14 1

facebook twitter kakao link

14 1

facebook twitter kakao link

DEVOTEE 요약: 서로 다른 프로그래밍 언어 (Python, Javascript, Go, Java)에서 기본적으로 사용되는 데이터 구조 및 생성, 사용, 삭제 등의 방법에는 약간의 차이가 있다. 이러한 차이점을 익혀 두면 개발 언어를 변경할 때 적응하는데 더 쉽고 빠르게 할 수 있다. 특히 리스트(Array, ArrayList, Slice 등)와 맵(Dictionary, HashMap 등)의 사용 예시가 다루어져 있어 초보 개발자에게 유용하다.

컴퓨터 언어를 공부하다 보면 각 언어의 특성에 맞는 Data Structure 와 활용법이 조금씩 다르다.

그래서 개발 언어를 바꾸면 보통 적응하는데 2~3일은 걸리는 것 같다.

그래서 각 언어의 특이한 커스텀 타입은 제외하고, 공통으로 사용되는 Data Structure 만 정리하였다.

최대한 많이 사용되고 알아야 할 내용만 추려서 작성했으니 추후 프로그램 개발할 때는 여기 내용만 잘 숙지해도 웬만한 로직은 구현가능 할 것으로 생각한다.

1. List, Array, Slice, ArrayList

우리가 흔히 말하는 Array 의 경우 Python 은 List , Javascript 는 Array , Go 는 Slice , Java 는 Array 보다 ArrayList 를 (주로) 사용한다.

Python

# List 생성
cars = ["Ford", "Volvo", "BMW"]
cars = list()                   # 인수는 크기만 숫자로 줄 수 있음

# List 길이
len(cars)

# List 에 element 존재 여부
print("Volvo" in cars)

# element 추가
cars.append("Volvo")
cars.insert(0, "Ford")

# element 삭제
cars = ["Ford", "Volvo", "BMW", "Renault"]
cars.remove("Volvo")         # return null
cars.pop(1)                  # return "BMW"
cars.pop()                   # return "Renault"
del cars[0]

# List 합치기
cars = ["Ford", "Volvo", "BMW"]
fruits = ["apple", "banana", "cherry"]
newlist = cars + fruits
cars.extend(fruits)

# List slice
cars = ["Ford", "Volvo", "BMW", "Renault"]
cars[:2]              # ['Ford', 'Volvo']
cars[1:2]             # ['Volvo']
cars[-1]              # Renault            -> 요소가 리턴
cars[:-1]             # ['Ford', 'Volvo', 'BMW']
cars[-2:-1]           # ['BMW']

# List 루프
for car in cars:
		print(car)              # 값이 출력
for i in range(len(cars)):
		print(cars[i])

# List Comprehension
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [fruit for fruit in fruits if "a" in fruit]

Javascript

// Array 생성
let cars = ["Ford", "Volvo", "BMW"];
cars = Array("Ford", "Volvo", "BMW");

// List 길이
cars.length

// List 에 element 존재 여부
cars.includes("Volvo");
cars.inclueds("Volvo", 2);     // index 2 부터 찾음

// element 추가
cars.push("Volvo")             // return 길이
cars.unshift("Ford")           // return 길이

// element 삭제
cars = ["Ford", "Volvo", "BMW", "Renault"]
cars.pop(1)                    // return "Renault"  숫자는 의미가 없음
cars.pop()                     // return "BMW"
cars.shift()                   // return "Ford"

// List 합치기
let cars = ["Ford", "Volvo", "BMW"]
let fruits = ["apple", "banana", "cherry"]
let newlist = [ ...cars, ...fruits ]
cars = cars.concat(fruits)

// List slice
cars = ["Ford", "Volvo", "BMW", "Renault"]
cars.slice(1, 3);           // ['Volvo', 'BMW']
cars.slice(-1);             // ['Renault']      -> 요소의 Array 가 리턴
cars.slice(-3, -1);         // ['Volvo', 'BMW']

// List splice
cars = ["Ford", "Volvo", "BMW", "Renault"]
cars.splice(2, 0)                   // return [], cars 에 아무것도 추가가 안됨
cars.splice(2, 0, "Kia", "Hyundae") // return [], cars 에 직접 추가됨
cars.splice(2, 2)                   // return ['Kia', 'Hyundae'], cars ['Ford', 'Volvo', 'BMW', 'Renault']

// List 루프
for (let car in cars) {
    console.log(car);           // 0 1 2 3 4 와 같이 index 가 출력
}
for (let car of cars) {
		console.log(car);           // 값이 출력
}
cars.forEach((car, index) => {
    console.log(car, index);    // 값 인덱스 가 출력
});

// List map, filter, reduce
let numbers = [65, 44, 12, 4];
let newNumbers = numbers.map((num, idx) => num * 10);         // [650, 440, 120, 40]
newNumbers = numbers.filter((num, idx) => num > 40);          // [65, 44]
newNumbers = numbers.reduce((total, num) => total + num, 0);  // 125

Go

// slice 생성
cars := []string{"Ford", "Volvo", "BMW"}
cars = []string{}
cars = make([]string, 0, 10)   // 길이 0, 용량 10 - 길이 값을 넣으면 초기 빈값이 들어감

// slice 길이, 용량
len(cars)
cap(cars)

// slice 에 element 존재 여부
for _, v := range cars {
		if v == "Volvo" {
				return true
		}
}
return false

// element 추가
cars = append(cars, "Volvo", "Ford")

// element 삭제
cars := []string{"Ford", "Volvo", "BMW", "Renault"}
idx := 1
cars = append(cars[:idx], cars[idx+1:]...)

// slice 합치기
cars := []string{"Ford", "Volvo", "BMW"}
fruits := []string{"apple", "banana", "cherry"}
newslice := append(cars, fruits...)

// slice slicing
cars := []string{"Ford", "Volvo", "Renault"}
cars[:2]                 // ['Ford', 'Volvo']
cars[1:2]                // ['Volvo']
cars[len(cars)-1]        // Renault            -> 요소가 리턴

// slice 루프
for idx, car := range cars {
		fmt.Println(idx, car)
}
for i:=0; i<len(cars); i++ {
		fmt.Println(i, cars[i])
}

Java

// ArrayList 생성
ArrayList<String> cars = new ArrayList<String>() {
		{
				add("Ford");
        add("Volvo");
        add("BMW");
		}
};
ArrayList<String> cars = new ArrayList<String>(
		Arrays.asList("Ford", "Volvo", "BMW")
);
ArrayList<String> cars = new ArrayList<String>(
		List.of("Ford", "Volvo", "BMW")
);
ArrayList<String> cars = new ArrayList<String>();

// ArrayList 길이
cars.size()

// ArrayList 에 element 존재 여부
cars.contains("Volvo");

// element 추가
cars.add("Ford");
cars.add("Volvo");
cars.add("BMW");
cars.add(0, "Kia");

// element 삭제
cars.remove(2);

// element 변경
cars.set(1, "Hyundae");

// ArrayList 합치기
ArrayList<String> cars = new ArrayList<String>(
		List.of("Ford", "Volvo", "BMW")
);
ArrayList<String> fruits = new ArrayList<String>(
		List.of("apple", "banana", "cherry")
);
cars.addAll(fruits);

// ArrayList slicing
ArrayList<String> cars = new ArrayList<String>(
		List.of("Ford", "Volvo", "BMW", "Renault")
);
cars.subList(0, 2);                        // ['Ford', 'Volvo']
cars.subList(1, 2);                        // ['Volvo']
cars.subList(cars.size()-1, cars.size());  // [Renault]   -> ArrayList가 리턴

// ArrayList 루프
for (String car : cars) {
		System.out.println(car);
}
for (int i=0; i<cars.size(); i++) {
		System.out.println(i + " " + cars.get(i));
}

2. Dictionary, Map, Map, HashMap

key, value 로 저장하는 스토어의 경우 Python 은 Dictionary , Javascript 는 Map , Go 는 Map , Java 는 HashMap 을 사용한다.

Python

# Dictionary 생성
car = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
car = dict()

# Map 요소 갯수
len(car)

# Dictionary 에 key 존재 여부
print("brand" in car)
print("brand" in car.keys())

# Dictionary 에 value 존재 여부
print("Ford" in car.values())

# 특정 key 에 대한 value 값 가져오기
car["door"]                # key 가 없으며 KeyError 발생
car.get("door", 4)         # key 가 없으면 default 값인 4를 리턴

# item 추가
car["brand"] = "Ford"
car["model"] = "Mustang"
car["year"] = 1964
car["color"] = "Red"
car.update({"color": "Red"})

# item 삭제
car.pop("model")          # Mustang
car.popitem()             # ('color', 'Red')
del car["model"]

# Dictionary Loop
for k in car:
		print(k)              # key 출력
for k in car.keys():
    print(k)              # key 출력
for v in car.values():
    print(v)              # value 출력
for k, v in car.items():
    print(k, v)           # key, value 출력
for k, v in sorted(car.items()):
    print(k, v)           # key 로 정렬
tmp = sorted([(str(v), k) for k, v in car.items()], reverse=True)  # value 를 역순으로 정렬
print(tmp)

Javascript

// Map 생성
let car = new Map([
  ["brand", "Ford"],
  ["model", "Mustang"],
  ["year", 1964],
]);
car = new Map();

// Map 요소 갯수
console.log(car.size);

// Map 에 key 존재 여부
car.has("brand");

// Map 에 value 존재 여부
[...car.entries()]                 // [Array(k,v), Array(k,v), Array(k,v)] 리턴
.filter(({1:v}) => v === "Ford")   // Array(k,v) 리턴, array[1] 값을 v 에 넣는다.
.map(({1:v}) => v === "Ford")      // [true] 리턴

for (let [k, v] of car.entries()) {
    if (v === "Ford") {
        return true;
		}
}
return false;

// 특정 key 에 대한 value 값 가져오기
car.get("brand")
car.get("door")            // key 가 없으면 undefined 를 리턴

// item 추가
car.set("brand", "Ford");
car.set("model", "Mustang");
car.set("year", 1964);
car.set("color", "Red");

// item 삭제
car.delete("model")        // item 이 존재하여 삭제되면 true 리턴, 없으면 false 리턴

// Map Loop
for (let e of car) {
    console.log(e[0], e[1]);
}
for (let k of car.keys()) {
    console.log(k);       // key 출력
}
for (let [k, v] of car.entries()) {
    console.log(k, v);
}
car.forEach((v, k) => {   // 파라미터는 value, key 순으로 들어옴
    console.log(k, v);
});

Go

// Map 생성
car := map[string]string{
    "brand": "Ford",
    "model": "Mustang",
    "year": "1964",
}
car = map[string]string{}
car = make(map[string]string)

// Map 요소 갯수
fmt.Println(len(car))

// Map 에 key 존재 여부
if value, ok := car["brand"]; ok {
    fmt.Printf("[%s] value is exits.", value)
}

// Map 에 value 존재 여부
for _, value := range car {
    if (value == "Ford") {
        return true;
		}
}
return false;

// 특정 key 에 대한 value 값 가져오기
value, ok := car["brand"]      // value 가 있으면 ok 에 true 를 할당

// item 추가
car["brand"] = "Ford"
car["model"] = "Mustang"
car["year"] = "1964"
car["color"] = "Red"

// item 삭제
delete(car, "model")
fmt.Printf("cat\t%v\n", car)

// Map Loop
for k, v := range car {
    fmt.Printf("%v : %v \n", k, v)
}

Java

// HashMap 생성
HashMap<String, String> car = new HashMap<String, String>(
    Map.of(
        "brand", "Ford",
        "model", "Mustang",
        "year", "1964"
    )
);
car = new HashMap<String, String>();

// HashMap 요소 갯수
System.out.println(car.size());

// HashMap 에 key 존재 여부
car.containsKey("brand");

// HashMap 에 value 존재 여부
car.containsValues("Ford");

// 특정 key 에 대한 value 값 가져오기
car.get("brand");

// item 추가
car.put("brand", "Ford");
car.put("model", "Mustang");
car.put("year", "1964");
car.put("color", "Red");

// item 삭제
car.remove("model");

// HashMap Loop
for (String k : car.keySet()) {
    System.out.printf("%s : %s \n", k, car.get(k));
}
for (String v : car.values()) {
    System.out.printf("%s \n", v);
}