🔗 리스트(List)를 이용한 반복문(Loop) 사용시 데이터를 다루는 방법

이번 글은 리스트 사용시 반복문 안에서 데이터를 다루는 방법에 대해서 살펴보도록 하겠다.

아마도 개발을 진행 하면서 리스트(List) 또는 어레이(Array) 타입에 대해서는 자주 사용해 봐서 무슨 형태의 타입 인지는 다들 알고 있을 것이다.

리스트(List)는 어떤 형태의 타입을 여러 개 담을 수 있도록 해주는 데이터 타입 중 하나인데, 리스트에 있는 많은 기능들 중 리스트를 사용한 반복문 사용시 어떤 문제가 있고, 어떻게 사용해야 좋을지에 대해서 경험이나 알고 있는 범위 내에서 작성해 보려고 한다.

"잘 못된 내용이 있을 수도 있으니 댓글 남겨 주시면 업데이트 하도록 하겠습니다."

Case

먼저, 리스트(List)를 사용해 반복문에서 데이터를 다룰 때에 무슨 문제가 있을까?

이 부분에 대해서는 경험을 해보신 분들도 있을 것이고, 아직 경험하지 못한 분도 있을 것이다. 물론 이런 케이스로 리스트를 다루지 않을 수도 있다.

반복문을 사용시 리스트 인덱스에 접근해서 데이터를 변경하기 위해 인덱스를 지정한 반복문을 사용한다고 가정하자.

데이터를 변경하는 부분에서는 당연히 문제가 없다. 하지만 데이터를 삭제하거나 추가하게 된다면 어떻게 될까 ?

리스트(List)의 길이를 기준으로 반복문을 실행할 때에 리스트의 삭제 또는 추가로 인하여 리스트의 인덱스를 보장할 수 없게 될 것이다.

예제를 만들어서 확인해 보자.

0-9까지 10개의 정수형(int) 타입을 담고 있는 리스트를 생성하고, 리스트의 길이 만큼 반복문을 실행하면서, 데이터를 2로 나눈 몫이 0이면 제거하도록 해보자.

여기까지는 문제가 없이 잘 실행이 된다.

void main() {
  List<int> _numbers = List.generate(10, (i) => i);
  print(_numbers);
  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  
  for (int i = 0; i < _numbers.length; i++) {
    if (_numbers[i] % 2 == 0) {
      _numbers.removeAt(i);
    }
  }
  print(_numbers);
  // [1, 3, 5, 7, 9]
}

이제 조건을 하나 더 추가해서 2로 나눈 몫이 0이 아닌 경우에는 2를 곱한 데이터로 변경하도록 해보자.

2를 곱해서 데이터를 변경해 주었지만, 결과 값을 보면 2로 곱해주지 못하고 있다.

for (int i = 0; i < _numbers.length; i++) {
	if (_numbers[i] % 2 == 0) {
    	_numbers.removeAt(i);
    } else {
    	_numbers[i] = _numbers[i] * 2;
    }
}
print(_numbers);
// [1, 3, 5, 7, 9]

왜 이런 결과가 나왔을까 ? 바로 반복문 안에서 리스트(List)의 길이를 변경 시켰기 때문에 발생하는 문제이다.

아래 그림과 같이 리스트의 길이가 줄어들면서 리스트의 순서는 변경되지 않지만, 인덱스 원소에 해당하는 순서가 변경 되어서 이러한 문제가 발생한다.

물론, 리스트 타입의 기능을 사용해서 데이터를 다룰 수도 있고, 변수를 추가해서 사용할 수도 있을 것이다.

하지만 이런식으로 불필요한 변수를 추가하는 것은 그리 좋은 방법이 아니다.

void main() {
  List<int> _numbers = List.generate(10, (i) => i);
  List<int> _newNumbers = [];
  for (int i = 0; i < _numbers.length; i++) {
    if (_numbers[i] % 2 != 0) {
      _newNumbers.add(_numbers[i] * 2);
    }
  }
  print(_newNumbers);
  // [2, 6, 10, 14, 18]
}

Immutable ? Mutable ?

위에서 새로운 변수를 추가해 리스트를 다루는 방법은 왜 좋지 못한 걸까 ?

이걸 이해하기 위해서는 프로그래밍 언어의 immutable, mutable에 대해서 짚고 넘어가야 한다.

정확한 내용에 대해서는 별도로 글을 작성할 예정이고, 간단하게만 알고 가도록 하자.

이 부분은 Dart 언어 외의 대부분이 프로그래밍 언어에 해당되는 내용이기도 한다.

immutable은 불변한 성질을 나타내고 mutable은 그 반대인 변할수 있는 성질을 뜻한다.

Flutter에 사용되는 변수 타입 중 대표적인 immutable 성질을 가지고 있는 String 타입을 살펴보도록 하자.

문자열에 처음에 "NewYork"이라고 값을 할당 하였다. 그 후에 "Seoul"로 값을 변경을 했다. 당연히 데이터가 변경이 되었다.

근데 왜 String은 immutable 성질인 불변한 타입인 걸까 ? 데이터를 변경할 수 있는데..

void main() {
  String city = "NewYork";
  city = "Seoul";
  print(city);
  // seoul
}

데이터가 변경된 것처럼 보이지만 정확하게 말하면 String은 immutable 타입이기 때문에 변한 것이 아닌 새로이 값을 선언하게 된 것이다. 즉 처음에 city와 변경된 city는 같은 메모리 공간에 존재하는 데이터가 아니고, 개별적으로 각각의 메모리 공간을 차지하고 있는 상태가 된 것이다.

예를 들어 city를 선언할 때에 할당된 메모리 주소 값이 "00000000" 이라고 하자.
city의 데이터를 변경하게 되면 기존 메모리인 "00000000" 에 저장된 데이터를 변경하지 않고 "00000001" 이라는 새로운 메모리에 데이터를 저장하고 city가 가리키는 주소 값을 변경해 주기 때문에 immutable이어도 데이터를 변경할 수 있게 되는 것이다. 한마디로 데이터가 변경되는 것이 아닌 주소 값이 복사되는 것이다.

가장 쉽게 Flutter에서 확인하는 방법은 hashCode를 출력해 확인해 보면 된다. hashCode가 다르게 출력된 것을 확인할 수 있다. 동일 메모리가 아니라는 의미다.

"HashCode는 해시 알고리즘에 의해 생성된 식별 가능한 정수형의 고유한 값이며, 애플리케이션 실행시 마다 값은 변경됨"

void main() {
  String city = "NewYork";
  print(city.hashCode);
  // 929241207
  
  city = "Seoul";
  print(city.hashCode);
  // 518004294
}

그렇다면 mutable 타입은 어떻게 다른 것일까 ?

당연히 값을 변경 하더라도 할당된 메모리의 주소 복사가 발생하지 않고, 동일 메모리의 저장된 데이터만 변경이 되는 것이다.

리스트(List)는 대표적인 mutable성질의 타입이다.

HashCode가 동일하게 출력되는 것을 확인할 수 있다.

void main() {
  List<String> platform = ["iOS", "Android", "Web", "Linux"];
  print(platform.hashCode);
  // 170602879
  
  platform[3] = "Windows";
  print(platform.hashCode);
  // 170602879
}

지금까지 리스트를 사용한 반복문을 다루는 방법을 살펴보다 말고 왜 immutable, mutable 성질에 대해서 다룬건지는 바로 위에서 다룬 케이스 때문이다.

리스트(List)를 사용해 반복문에서 리스트의 순서가 보장되지 않아 정확한 원소를 다루지 못하는 방법을 살펴볼 때에, 쉽게 사용할 수 있는 방법으로 새로운 배열을 추가하는 방법을 예시로 다뤘었다.
그 예제를 다루면서 그리 좋지 못한 방법이라고 한 이유가 바로 타입의 성질 때문이다.

리스트(List)는 mutable(변할 수 있는) 타입이어서 새로운 메모리를 할당 받지 않고도 데이터를 변경할 수 있는데, 굳이 새로운 변수를 추가해 메모리를 할당 받아 사용할 필요가 있을까 ?

물론, 몇 번 그렇게 사용하는 것 가지고 크래시가 발생하거나 메모리릭이 즉시 발생하지는 않는다. 하지만 메모리 사용량이 늘어나면 상당한 부담이 오는 것도 사실이기 떄문에 불필요한 메모리 누수가 될 만한 방법을 사용하지 않는 것이 좋다고 생각한다.

메모리 영역을 새롭게 받게 되고, 기존에 할당 받은 메모리 영역이 사용되지 않으면 GC(Garbage Collector)에 의해 반납되어 가용 상태의 영역으로 관리되기는 하지만 GC는 시스템에 의해 자동으로 처리 되어지고, 시점이 일정하지 않아 빈번히 발생할 경우 메모리 사용량이 올라가게 된다.

짧게 다루려고 했지만, 이 부분은 간단하게 끝나지 않아 내용이 길어졌다.

자세한 내용은 별도로 다뤄보기로 하고, 이제 반복문에서 리스트(List)를 어떻게 사용하면 좋을지에 대해서 계속해서 알아보자.

List

Case를 살펴본 내용 중 리스트의 길이가 변경 되었을 때에 문제가 있었다.

어떻게 다루면 좋을까 ?

방법은 사실 간단하다.
반복문의 인덱스를 0으로 시작해 증가시키지 않고 리스트의 길이로 시작해 감소시켜 나가면서 역순으로 데이터를 삭제해 가면 전체 원소에 접근할 수 있게 된다.

리스트안에 0~9까지 숫자 10개를 생성해주자.

반복문의 시작이 i=0이 아닌 i = length - 1 로 해주면 된다.

-1은 왜 해줘야 할까 ? 리스트의 인덱스는 1이 아닌 0부터 시작하기 때문에 -1을 해주면 된다.

이제 리스트의 길이가 10-1인 9부터 시작하기 때문에 종료 되는 시점도 0까지 실행될 수 있도록 -1보다 큰 경우에만 실행되도록 해주면 된다.

마지막으로 i++가 아니라 감소를 해야하기 때문에 i--로 감소를 시켜주자.

void main() {
  List<int> numbers = List.generate(10, (i) => i);
  for (int i = numbers.length - 1; -1 < i; i--) {
    print(i);
  }
}

이제 동일한 조건을 역순으로 인덱스에 접근하는 방법으로 작성한 반복문 안에 넣어서 실행해보자.

정상적으로 결과가 출력이 되었다.

void main() {
  List<int> numbers = List.generate(10, (i) => i);
  for (int i = numbers.length - 1; -1 < i; i--) {
    if (numbers[i] % 2 == 0) {
      numbers.removeAt(i);
    } else {
      numbers[i] = numbers[i] * 2;
    }
  }
  print(numbers);
  // [2, 6, 10, 14, 18]
}

리스트(List)를 사용해 반복문에서 데이터를 제거해야 할 때에는 반드시 리스트의 길이가 변경이 된다는 것을 주의해서 사용해야 한다.

이번에는 리스트(List)의 길이가 감소 하는게 아닌 증가 할 경우 어떤 일이 벌어지는지 살펴보도록 하자.

리스트의 길이가 증가하게 되면, 반복문의 실행 횟수가 늘어나기 때문에 절대 구성하면 안되는 로직 중 하나이다.

반복문은 실행시 반복 횟수가 정해져 있어야 하는데, 리스트의 길이가 늘어남에 따라 반복 횟수가 계속 증가하게 될 수도 있고 최악의 경우 무한 루프에 빠질 수도 있어서 이 점은 반드시 주의하셔야 한다.

그렇기 때문에 리스트의 길이가 증가하는 경우 고정 길이 조건을 넣어주어야 한다.

void main() {
  List<int> numbers = List.generate(10, (i) => i);
  for (int i = 0; i < 10; i++) {
    if (numbers[i] % 2 == 0) {
      numbers.add(numbers[i] * 10);
    }
  }
  print(numbers);
  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 20, 40, 60, 80]
}

사실 리스트(List)를 사용해 반복문의 데이터를 변경하는 작업은 문제가 되지 않지만, 반복문 특성상 반복 횟수가 리스트의 길이에 의존되기 때문에, 반복문 내에서 리스트의 길이를 변경해야 할 로직 자체를 만들지 않아야 한다.

Unmodifiable

리스트(List)를 사용해 데이터를 변경해야 할 때에도 주의해야 할 점이 있다.

바로 위에서 살펴본 immutable 성질로 생성된 리스트(List)를 사용할 때이다.

Flutter에서 Code Generator를 사용한 특정 패키지에서 데이터 클래스를 생성하게 되면 리스트(List)의 성질이 immutable(불변)로 생성되는 경우가 있어 메모리의 주소 복사를 통해 데이터 값을 변경시키게 된다.

리스트(List)를 immutable(불변) 성질의 타입으로 생성해 보도록 하자.

이제 numbers 리스트는 변할 수 없는 성질이 되었다.

void main() {
  List<int> numbers = UnmodifiableListView(<int>[0, 1, 2, 3, 4, 5]);
}

진짜 변할 수 없는지 인덱스를 사용해 데이터를 변경해 보도록 하자.

void main() {
  List<int> numbers = UnmodifiableListView(<int>[0, 1, 2, 3, 4, 5]);
  numbers[2] = 20;
  print(numbers);
}

위의 코드를 실행 해보면 아래 에러가 출력이 되는 것을 확인할 수 있다.

"Unhandled exception:
Unsupported operation: Cannot modify an unmodifiable list"

그렇다면 immutable(불변) 성질의 리스트는 어떻게 데이터를 수정해야 할까 ?

List.from을 사용해 numbers에 새로운 영역의 메모리를 할당 받도록 해주면 된다.

void main() {
  List<int> numbers = UnmodifiableListView(<int>[0, 1, 2, 3, 4, 5]);
  numbers = List.from(numbers)
     ..removeAt(2)
     ..insert(2, 20);
  print(numbers);
  // [0, 1, 20, 3, 4, 5]
}

HashCode를 출력해 보면 값이 다르게 된 것을 알 수있다. 즉 새로운 메모리 영역을 할당 받아 numbers의 주소 복사가 발생한 것이다.

이렇게 되면 처음 할당된 431824049 메모리 공간은 GC의 대상이 되고 시스템에 의해 자동적으로 가용 대상으로 변경이 되게 된다.

그리고 새로운 652108807 공간에 메모리를 할당 받아 데이터를 새롭게 생성하는 것이다.

이렇게 되면 일정 시간 동안은 2개의 메모리 공간을 차지하게 되는 상황이 발생하는 것이다.

void main() {
  List<int> numbers = UnmodifiableListView(<int>[0, 1, 2, 3, 4, 5]);
  print(numbers.hashCode);
  // 431824049

  numbers = List.from(numbers)
    ..removeAt(2)
    ..insert(2, 20);
  print(numbers.hashCode);
  // 652108807
}

어쩔 수 없이 immutable(불변) 성질의 리스트를 다뤄야 하는 경우 리스트의 데이터를 변경하기 위해 이러한 방법을 사용해야 한다.

그렇다면 왜 굳이 불편하게 immutable(불변) 성질을 사용할까 ? 이 부분에 대해서는 다른 글에서 자세히 다뤄보도록 하겠다.

본인이 개발 하면서 생성한 리스트 타입이 immutable인지, mutable인지를 확인해 보면서 다뤄보면 좋은 프로그래밍을 만들 수 있을 것이다.

마무리

글의 주된 내용은 리스트를 사용한 반복문 실행시 데이터를 다루는 방법에 대해 글을 작성해 보려고 했지만, 연결된 내용이 다소 있기도 하고 실제로 애플리케이션을 개발 할 때에는 나오지 않을 케이스인 경우가 더 많다보니, immutable, mutable 등의 성질에 대해서 다룬 내용이 더 많아진 것 같다.

다음 번에는 immutable, mutable에 관련된 내용을 추가로 자세히 다뤄 볼 예정이다. 사실 이 글에서 다룬 내용은 10%도 안될 것이다.

그리고 추가로 리스트(List)에 대해서도 자세히 다뤄보도록 하겠다.

궁금하신 부분 댓글 남겨주세요 !