[Flutter/Dart] 리스트 클래스 정리

 

 

Flutter 3.24.3 다트 라이브러리를 참고해서 List Class의 모든 걸 정리하고자 한다.

Fixed-length list 와Growable list

Fixed-Length list

크기가 고정된 리스트. 리스트의 크기를 변경하려고 하면 에러남.

 

Growable list

기본적으로 사용하는 리스트. 내부 버퍼를 사용하고, 필요에 따라 늘림.

 

생성자 Constructors

List.empty

List.empty({bool growable = false})

빈 리스트 생성. 기본 growable이 false라 Fixed-Length list로 생성된다.

List<int> testList = List.empty(growable: false);
testList.add(0); //에러

testList = List.empty(growable: true);
testList.add(0);

print(testList); //[0]

List.filled

List.filled(int length, E fill, {bool growable = false})

리스트의 길이와 채울 내용을 입력하면, 내용을 채운 리스트를 생성한다.

List<int> testList = List.filled(3, 4); // [4, 4, 4]

List testList2 = List.filled(4, 'text', growable: false); // [text, text, text, text]

var testList3 = List.filled(2, MyType(contents: 4)); //[Instance of 'MyType', Instance of 'MyType']

 

List.from

List.from(Iterable elements, {bool growable = true})

Iterable로 list를 생성한다.
따로 Type을 지정하지 않으면  생성된 리스트의 타입은 dynamic 고정

다운캐스팅 가능

List<int> testList = [1, 1, 3, 3];
Set<int> testSet = {4, 5, 6};
Map<String, String> testMap = {'key1': 'val1', 'key2': 'val2'};

List<double> testList2 = List.from(testList); // List<double> [1, 1, 3, 3]

var testList3 = List.from(testSet); // List<dynamic> [4, 5, 6]

var testList4 = List.from(testMap.keys); // List<dynamic> [key1, key2]

 

List.generate

List.getnerate(int length, E generator(int index), {bool growable = true})

generator의 값들로 list를 생성한다.

List testList = List.generate(
  3,
  (index) {
    return index + 3;
  },
); //[3, 4, 5]

 

List.of

List.of(Iterable<E> elements, {bool growable = true})

Iterable로 list를 생성한다.

따로 Type을 지정하지 않으면 생성된 리스트의 타입은 넣어준 Iterable의 타입과 동일

업캐스팅 가능

List<int> testList = [1, 1, 3, 3];
Set<int> testSet = {4, 5, 6};
Map<String, String> testMap = {'key1': 'val1', 'key2': 'val2'};

List<num> testList2 = List.of(testList); // List<num> [1, 1, 3, 3]

var testList3 = List.of(testSet); // List<int> [4, 5, 6]

var testList4 = List.of(testMap.keys); // List<String> [key1, key2]

 

List.unmodifiable

List.unmodifiable(Iterable elements)

Iterable로 수정 불가능한 리스트를 만든다.

List<int> testList = [1, 1, 3, 3];

var testList2 = List.unmodifiable(testList); // List<dynamic> [1, 1, 3, 3]

testList2[0] = 2; // 에러
testList2.add(4); // 에러

 

 

속성 Properties

first

first ↔ E

리스트 첫번째 요소 반환 혹은 설정

List<int> testList = [1, 2, 3, 4];
print(testList.first); // 1
testList.first = 5; // List<int> [5, 2, 3, 4]

 

hashCode

hashCode → int

객체의 해시코드 반환

List testList = [1, 2, 3];
print(testList.hashCode); // 395850037

 

isEmpty

isEmpty → bool

리스트가 비어있으면 true

List testList = [1, 2, 3];
print(testList.isEmpty); // false
List testList2 = [];
print(testList2.isEmpty); // true

 

isNotEmpty

isNotEmpty → bool

리스트가 비어있지 않으면 true

List testList = [1, 2, 3];
print(testList.isNotEmpty); // true
List testList2 = [];
print(testList2.isNotEmpty); // false

 

iterator

iterator → Iterator<E>

리스트를 Iterator로 만든다.

List<int?> testList = [1, 2, 3];
Iterator iterator = testList.iterator;
print(iterator.current); // null (nullable 아니면 오류)
print(iterator.moveNext()); //true
print(iterator.current); //1
print(iterator.moveNext()); //true
print(iterator.current); //2
print(iterator.moveNext()); //true
print(iterator.current); //3
print(iterator.moveNext()); //false
print(iterator.current); // null (nullable 아니면 오류)

 

last

last ↔ E

리스트 마지막 요소 반환 혹은 설정

List<int> testList = [1, 2, 3, 4];
print(testList.last); // 4
testList.last = 5; // List<int> [1, 2, 3, 5]

 

length

length ↔ int

리스트 길이 반환 혹은 설정.
리스트 길이가 증가할 경우 null이 들어감. nullable이 아닌 리스트면 에러.

List<int> testList = [1, 2, 3, 4];
print(testList.length); // 4
testList.length = 5; // 에러
List<dynamic> testList2 = [1, 2, 3, 4];
testList.length = 5; // List<dynamic> [1, 2, 3, 4, null]
testList.length = 2; // List<dynamic> [1, 2]

 

reversed

reversed → Iterable<E>

리스트의 순서를 뒤집어서 Iterable을 반환

List<int?> testList = [1, 2, 3];
print(testList.reversed); // ReversedListIterable<int?> (3, 2, 1)

 

runtimeType

runtimeType → Type

리스트 타입 반환

List<int?> testList = [1, 2, 3];
print(testList.runtimeType); // List<int?>
List testList2 = ['1', '2', '3'];
print(testList2.runtimeType); // List<dynamic>
var testList3 = <MyType>[MyType(contents: 3), MyType(contents: 4)];
print(testList3.runtimeType); // List<MyType>

 

single

single → E

리스트에 요소가 하나만 있는지 확인하고, 해당 요소를 반환

하나만 있지 않으면 에러

List testList = [1];
print(testList.single); // 1
List testList2 = ['1', '2', '3'];
print(testList2.single); // 에러

 

반응형

 

메서드 Methods

add

add(E value) → void

리스트 끝에 값을 추가. 리스트 길이가 1 증가함.

List testList = [1, 2, 3];
testList.add(4); // List<dynamic> [1, 2, 3, 4]

 

addAll

addAll(Iterable<E> iterable) → void

iterable의 모든 객체를 리스트에 추가.

List testList = [1, 2, 3];
testList.addAll([4, 5, 6]); // List<dynamic> [1, 2, 3, 4, 5, 6]
testList.addAll({'a', 'b'}); // List<dynamic> [1, 2, 3, 4, 5, 6, 'a', 'b']

 

any

any(bool test(E element) → bool

bool타입 test함수에서 true가 하나라도 존재하면 true, 아니면 false.

true가 존재하는 순간 반복을 빠져나옴.

List testList = [1, 2, 3, 4, 5];
var result = testList.any((element){
  if(element > 3){
    return true;
  }
  return false;
}); // true

 

asMap

asMap() → Map<int, E>

리스트를 index와 value를 가진 Map으로 변환

List<dynamic> testList = ['a', 'b', 56];
var result = testList.asMap(); // Map<int, dynamic> {0: 'a', 1: 'b', 2: 56}

 

cast

cast<R>() → List<R>

R 인스턴스 리스트를 반환. 업캐스팅 가능. Type이 맞지 않는 요소가 있다면 에러.

List<dynamic> testList = [1, 2, 3];
var result = testList.cast<int>(); // CastList<dynamic, int> [1, 2, 3]
var result2 = testList.cast<num>().toList(); // List<num> [1, 2, 3]
List<dynamic> testList3 = [1, 2, 'a'];
var result3 = testList.cast<int>(); // 에러

 

clear

clear() → void

리스트의 모든 객체를 제거. 길이도 0이 됨.

List<int> testList = [1, 2, 3];
testList.clear(); // List<int> []

 

contains

contains(Object? element) → bool

리스트에 같은 요소가 포함되어있다면 true.

List<int> testList = [1, 2, 3];
testList.contains(1); // true
testList.contains('1'); // false

 

elementAt

elemantAt(int index) → E

인덱스 위치의 요소 반환.

List<int> testList = [1, 2, 3];
print(testList.elementAt(0)); // 1

 

every

every(bool test(E element)) → bool

bool타입 test함수에서 false가 하나라도 존재하면 false, 아니면 true.

false가 존재하는 순간 반복을 빠져나옴.

List testList = [1, 2, 3, 4, 5];
var result = testList.every((element){
  if(element < 5){
    return true;
  }
  return false;
}); // false

 

expand

expand<T>(Iterable<T> toElements(E element)) → Iterable<T>

리스트의 각 요소를 0개 이상의 요소로 확장시킴.

var numbers = [1, 3, 0, 2];
var result = numbers.expand(count);
result = numbers.expand((n) sync* {
  for (var i = 1; i <= n; i++) {
    yield n;
  }
}); // ExpandIterable<int, int> (1, 3, 3, 3, 2, 2)

 

fillRange

fillRange(int start, int end, [E? fillValue]) → void

리스트의 범위만큼 fillValue의 값을 채운다. fillValue 값이 없다면 null로 채움. nullable이 아니라면 에러.

List<String?> testList = ['a', 'b', 'c', 'd'];
testList.fillRange(1, 3); // List<String?> ['a', null, null, 'd'] 
testList.fillRange(0, 2, 'fill'); // List<String?> ['fill', 'fill', null, 'd']

 

firstWhere

firstWhere(bool test(E element), {E orElse()?}) → E

bool타입 test함수에서 true를 반환하는 첫번째 요소를 반환.

true가 없다면 에러.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.firstWhere((element) => element > 3); // <int> 4
var result2 = testList.firstWhere((element) => element > 36); // 에러
var result3 = testList.firstWhere((element) => element > 36, orElse: () => -1); // -1

 

fold

fold<T>(T initailValue, T combine(T previousValue, E element)) → T

리스트의 각 요소들을 결합해 하나의 값을 반환.

초기값을 입력하고, 결합함수를 사용해 순차적으로 결합한다.

초기값이 필요없다면 reduce 사용

List<int> testList = [1, 2, 3, 4, 5];
int initialValue = 100;
var result = testList.fold(initialValue, (previousValue, element){
  print(previousValue); // 100, 101, 103, 106, 110
  return previousValue + element;
}); // int 115

List<String> testList2 = ['1', '2', '3', '4', '5'];
String initialValue2 = '100';
var result2 = testList2.fold<String>(initialValue2, (previousValue, element){
  print(previousValue); // '100', '1001', '10012', '100123', '1001234'
  return previousValue + element;
}); // String '10012345'

 

followedBy

followedBy(Iterable<E> other) → Iterable<E>

이 리스트와 다른 Iteable에 지연 연결을 만들어 반환.
호출 시점에 값을 반영

List<int> testList = [1, 2, 3];
List<int> testList2 = [4, 5];
var result = testList.followedBy(testList2);
print(result); // EfficientLengthFollowedByIterable<int> (1, 2, 3, 4, 5)
testList.add(6);
testList2.add(7);
print(result); // EfficientLengthFollowedByIterable<int> (1, 2, 3, 6, 4, 5, 7)

 

forEach

forEach(void action(E element)) → void

리스트의 각 요소들을 순서대로 호출하여 액션함수 실행.

for문으로 변경 권장.

List<int> testList = [1, 2, 3, 4];
testList.forEach(print); // 1, 2, 3, 4
testList.forEach((element){
  print(element); // 1, 2, 3, 4
}); // 아래와 같이 변경 권장
for (var element in testList) {
  print(element); // 1, 2, 3, 4
}

 

getRange

getRange(int start, int end) → Iterable<E>

리스트의 범위를 지정하여 Iterable을 만들어서 반환.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.getRange(1, 4); // SubListIterable<int> (2, 3, 4)

 

indexOf

indexOf(E element, [int start = 0]) → int

리스트에서 첫 번째로 일치하는 요소를 찾아 인덱스를 반환.

List<int> testList = [1, 2, 3, 1, 2, 3];
var result = testList.indexOf(2); // 1
var result2 = testList.indexOf(2, 2); // 4

 

indexWhere

indexWhere(bool test(E element), [int start = 0]) → int

bool타입 test함수에서 true를 반환하는 첫번째 요소의 인덱스를 반환.

시작 인덱스 설정 가능.

true가 없다면 -1.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.indexWhere((element){
  return element % 2 == 0;
}); // 1
var result2 = testList.indexWhere((element){
  return element % 2 == 0;
}, 2); // 3
var result3 = testList.indexWhere((element){
  return element % 12 == 0;
}); // -1

 

insert

insert(int index, E element) → void

리스트의 인덱스 위치에 요소를 삽입.

List<int> testList = [1, 2, 3];
testList.insert(2, 4); // [1, 2, 4, 3]

 

 

insertAll

insertAll(int index, Iteralbe<E> iterable) → void

리스트의 인덱스 위치에 Iterable의 모든 요소를 삽입

List<int> testList = [1, 2, 3];
testList.insertAll(2, [4, 5]); // [1, 2, 4, 5, 3]

 

join

join([String separator = ""]) → String

리스트의 각 요소를 문자열로 변환하고 separator로 연결하여 문자열로 반환.

List<int> testList = [1, 2, 3, 4];

var result = testList.join(); // 1234
var result2 = testList.join("#"); // 1#2#3#4

 

lastIndexOf

lastIndexOf(E element, [int? start]) → int

리스트에서 마지막으로 일치하는 요소를 찾아 인덱스를 반환.

List<int> testList = [1, 2, 3, 1, 2, 3];
var result = testList.lastIndexOf(2); // 4
var result2 = testList.lastIndexOf(2, 3); // 1

 

lastIndexWhere

lastIndexWhere(bool test(E element), [int? start]) → int

bool타입 test함수에서 true를 반환하는 마지막 요소의 인덱스를 반환.

시작 인덱스 설정 가능.

true가 없다면 -1.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.lastIndexWhere((element){
  return element % 2 == 0;
}); // 3
var result2 = testList.lastIndexWhere((element){
  return element % 2 == 0;
}, 2); // 1
var result3 = testList.lastIndexWhere((element){
  return element % 12 == 0;
}); // -1

 

lastWhere

lastWhere(bool test(E element), {E orElse()?}) → E

bool타입 test함수에서 true를 반환하는 마지막 요소를 반환.

true가 없다면 에러.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.lastWhere((element) => element < 3); // <int> 2
var result2 = testList.lastWhere((element) => element < 0); // 에러
var result3 = testList.lastWhere((element) => element < 0, orElse: () => -1); // -1

 

map

map<T>(T toElement(E e)) → Iterable<T>

toElement 함수로 각 요소들을 변환하여 Iterable을 반환.

리스트를 위젯 리스트로 만들때도 유용함.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.map<String>((int element){
  return (element * -1).toString();
}); // MappedListIterable<int, String> ('-1', '-2', '-3', '-4', '-5')
var result2 = testList.map<Widget>((int element){
  return Text(element.toString(), style: Theme.of(context).textTheme.bodyMedium);
}).toList(); // List<TextWidget>

 

reduce

reduce(E combine(E value, E element)) → E

combine 함수를 이용해서 리스트의 요소를 순차적으로 결합하여 단일 값을 반환.

초기값이 필요하다면 fold를 사용.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.reduce((value, element){
  return value + element;
}); // 15

 

remove

remove(Object? value) → bool

리스트에서 처음으로 일치하는 요소를 제거

List<int> testList = [1, 2, 3, 1, 2];
var result = testList.remove(1); // true testList = List<int> [2, 3, 1, 2]
var result2 = testList.remove(4); // false

 

removeAt

removeAt(int index) → E

리스트에서 인덱스에 위치하는 요소를 제거하고 그 요소를 반환.

List<int> testList = [1, 2, 3, 1, 2];
var result = testList.removeAt(1); // 2 testList = List<int> [1, 3, 1, 2]
var result2 = testList.removeAt(4); // 에러

 

removeLast

removeLast() → E

리스트에서 마지막 요소를 제거하고 그 요소를 반환.

List<int> testList = [1, 2, 3, 1, 2];
var result = testList.removeLast(); // 2 testList = List<int> [1, 3, 1, 2]
var result2 = testList.removeLast(); // 1 testList = List<int> [1, 2, 3]

 

removeRange

removeRange(int start, int end) → void

리스트에서 범위만큼을 제거.

List<int> testList = [1, 2, 3, 4, 5];
testList.removeRange(1, 3); // List<int> [1, 4, 5]

 

removeWhere

removeWhere(bool test(E element)) → void

리스트에서 test함수에서 true를 반환하는 요소를 제거.

List<int> testList = [1, 2, 3, 4, 5];
testList.removeWhere((element) {
  if (element % 2 == 0) {
    return true;
  } else {
    return false;
  }
}); // List<int> [1, 3, 5]

 

replaceRange

replaceRange(int start, int end, Iterable<E> replacement)  → void

리스트 범위의 요소들을 replacement로 교체.

List<int> testList = [1, 2, 3, 4, 5];
testList.replaceRange(1, 3, [6, 7, 8]); // List<int> [1, 6, 7, 8, 4, 5]

 

retainWhere

retainWhere(bool test(E element)) → void

리스트에서 test함수에서 false를 반환하는 요소들 제거. (true를 반환하는 요소만 남김)

List<int> testList = [1, 2, 3, 4, 5];
testList.retainWhere((element) {
  if (element % 2 == 0) {
    return true;
  } else {
    return false;
  }
}); // List<int> [2, 4]

 

setAll

setAll(int index, Iterable<E> iterable) → void

iterable의 요소들로 index부터 덮어씀.

List<int> testList = [1, 2, 3, 4, 5];
testList.setAll(2, [6, 7]); // List<int> [1, 2, 6, 7, 5]
testList.setAll(2, [8, 9, 10, 11]); // 범위를 넘어가면 에러

 

setRange

setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) → void

List<int> testList = [1, 2, 3, 4, 5];
testList.setRange(1, 3, [6, 7, 8, 9]); // [1, 6, 7, 4, 5]
int skipCount = 2;
testList.setRange(1, 3, [6, 7, 8, 9], skipCount); // [1, 8, 9, 4, 5]

 

shuffle

shuffle([Random? random]) → void

리스트의 순서를 무작위로 섞습니다.

List<int> testList = [1, 2, 3, 4, 5];
testList.shuffle(); // [1, 5, 3, 2, 4]

 

singleWhere

singleWhere(bool test(E element), {E orElse()?}) → E

test함수에서 true를 반환하는 단 하나의 요소를 반환.

만족하는 요소가 없거나 여럿이면 에러.

만족하는 요소가 없는것은 orElse로 처리 가능.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.singleWhere((element) => element == 3); // <int> 3
var result2 = testList.singleWhere((element) => element > 3, orElse: () => -1); // StateError
var result3 = testList.singleWhere((element) => element > 20, orElse: () => -1); // -1

 

skip

skip(int count) → Iterable<E>

count만큼의 요소를 빼고 새로운 Iterable을 만들어서 반환.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.skip(2); // SubListIterable<int> (3, 4, 5)

 

skipWhile

skipWhile(bool test(E value)) → Iterable<E>

test함수를 만족하는 곳까지 요소들을 제외하고 Iterable을 만들어서 반환.

처음으로 false가 나오는 곳 전까지 제외함.

List<int> testList = [1, 2, 3, 2, 1];
var result = testList.skipWhile((value) => value < 3); // SkipWhileIterable<int> (3, 2, 1)

 

sort

sort([int compare(E a, E b)?]) → void

compare함수를 사용하여 리스트를 정렬.

List<int> testList = [1, 4, 3, 2, 5];
testList.sort(); // [1, 2, 3, 4, 5]
List testList2 = ['one', 'two', 'three', 'four', 'five'];
testList2.sort(); // [five, four, one, three, two]
testList2.sort((a, b) => a.length.compareTo(b.length)); //[one, two, five, four, three]

 

sublist

sublist(int start, [int? end]) → List<E>

start와 end 사이의 요소들로 만든 새로운 리스트 반환.

List<int> testList = [1, 2, 3, 4, 5];
var testList2 = testList.sublist(1); // [2, 3, 4, 5]
var testList3 = testList.sublist(1, 4); // [2, 3, 4]

 

take

take(int count) → Iterable<E>

count 만큼의 요소들로 지연 연결된 Iterable을 만들어서 반환.

List<int> testList = [1, 2, 3, 4, 5];
var testList2 = testList.take(3); 
var testList3 = testList.take(10); 
testList.insert(2, 6);
print(testList2); // SubListIterable<int> (1, 2, 6)
print(testList3); // SubListIterable<int> (1, 2, 6, 3, 4, 5)

 

takeWhile

takeWhile(bool test(E value)) → Iterable<E>

test함수에서 false를 반환 할 때까지의 모든 요소를 Iterable로 만들어서 반환.

List<int> testList = [1, 2, 3, 4, 5];
var testList2 = testList.takeWhile((value) => value != 3);
testList.insert(0, 6);
print(testList2); // TakeWhileIterable<int> (6, 1, 2)

 

toList

toList({bool growalbe = true}) → List<E>

Iterable을 리스트로 만들어서 반환.

 

toSet

toSet() → Set<E>

Iterable을 집합으로 만들어서 반환.

 

toString

toString() → String

객체를 문자열로 만들어서 반환.

List<int> testList = [1, 2, 3, 1, 2];
var result = testList.toSet(); // _HashSet<int> {1, 2, 3}
var result2 = result.toList(); // List<int> [1, 2, 3]
var result3 = result2.toString(); // String '[1, 2, 3]'

 

where

where(bool test(E element)) → Iterable<E>

test함수를 만족하는 모든 요소로 지연 Iterable을 만들어서 반환.

List<int> testList = [1, 2, 3, 4, 5];
var result = testList.where((element) => element.isEven);
testList.add(6);
print(result);// WhereIterable<int> (2, 4, 6)

 

whereType

whereType<T>() → Iterable<T>

리스트에서 특정 타입의 요소만으로 지연 Iterable을 만들어서 반환.

List testList = [1, 2, 3, 4, 5, 'a', 'b', 'c'];
var result = testList.whereType<int>();
testList.add(6);
print(result);// WhereTypeIterable<int> (1, 2, 3, 4, 5, 6)

 

 

참고 링크

https://api.flutter.dev/flutter/dart-core/List-class.html

List class - dart:core library - Dart API