void forEach(void f(E element))

main() {var languages = <String>['Dart', 'Kotlin', 'Java', 'Javascript', 'Go', 'Python', 'Swift'];languages.forEach((language) => print('The language is $language'));//由于只有一个表达式，所以可以直接使用箭头函数。languages.forEach((language){if(language == 'Dart' || language == 'Kotlin') {print('My favorite language is $language');} });
}

void forEach(void f(E element)) {//可以看到在forEach内部实际上就是利用for-in迭代，每迭代一次就执行一次f函数，//并把当前element回调出去for (E element in this) f(element);}

Iterable<T> map<T>(T f(E e))

main() {var languages = <String>['Dart', 'Kotlin', 'Java', 'Javascript', 'Go', 'Python', 'Swift'];print(languages.map((language) => 'develop language is ${language}').join('---'));
}

@pragma("vm:entry-point")
class _GrowableList<T> extends ListBase<T> {//_GrowableList<T>是继承了ListBase<T>...
}abstract class ListBase<E> extends Object with ListMixin<E> {//ListBase mixin with ListMixin<E>...
}

abstract class ListMixin<E> implements List<E> {...//可以看到这里是直接返回一个MappedListIterable，它是一个惰性IterableIterable<T> map<T>(T f(E element)) => MappedListIterable<E, T>(this, f);...
}

class MappedListIterable<S, T> extends ListIterable<T> {final Iterable<S> _source;//_source存储了所携带的原集合final _Transformation<S, T> _f;//_f函数存储了map函数传入的闭包，MappedListIterable(this._source, this._f);int get length => _source.length;//注意: 只有elementAt函数执行的时候，才会触发执行_f方法，然后通过_source的elementAt函数取得原集合中的元素，//最后针对_source中的每个元素执行_f函数处理。T elementAt(int index) => _f(_source.elementAt(index));
}

languages.map((language) => 'develop language is ${language}').toList();//toList()方法调用才会真正去执行map中的闭包。languages.map((language) => 'develop language is ${language}').toSet();//toSet()方法调用才会真正去执行map中的闭包。languages.map((language) => 'develop language is ${language}').join('---');//join()方法调用才会真正去执行map中的闭包。List<E> toList({bool growable = true}) {List<E> result;if (growable) {result = <E>[]..length = length;} else {result = List<E>(length);}for (int i = 0; i < length; i++) {result[i] = this[i];//注意: 这里的this[i]实际上是运算符重载了[]，最终就是调用了elementAt函数，这里才会真正的触发map中的闭包，}return result;}

bool any(bool test(E element))

main() {bool isDartExisted = languages.any((language) => language == 'Dart');
}

bool any(bool test(E element)) {int length = this.length;//获取到原集合的length//遍历原集合，只要找到符合test函数的条件，就返回truefor (int i = 0; i < length; i++) {if (test(this[i])) return true;if (length != this.length) {throw ConcurrentModificationError(this);}}//遍历完集合后，未找到符合条件的集合就返回falsereturn false;}

bool every(bool test(E element))

main() {bool isDartAll = languages.every((language) => language == 'Dart');
}

bool every(bool test(E element)) {//利用for-in遍历集合，只要找到不符合test函数的条件，就返回false.for (E element in this) {if (!test(element)) return false;}
//遍历完集合后，找到所有元素符合条件就返回true    return true;}

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

main() {List<int> numbers = [0, 3, 1, 2, 7, 12, 2, 4];print(numbers.where((num) => num > 6));//输出: (7,12)//注意: 这里是print的内容实际上输出的是Iterable的toString方法返回的内容。
}

//可以看到这里是直接返回一个WhereIterable对象，而不是返回过滤后元素集合，所以它返回的Iterable也是惰性的。
Iterable<E> where(bool test(E element)) => WhereIterable<E>(this, test);

class WhereIterable<E> extends Iterable<E> {final Iterable<E> _iterable;//传入的原集合final _ElementPredicate<E> _f;//传入的where函数中闭包参数WhereIterable(this._iterable, this._f);//注意: 这里WhereIterable的迭代借助了iterator，这里是直接创建一个WhereIterator，并传入元集合_iterable中的iterator以及过滤操作函数。Iterator<E> get iterator => new WhereIterator<E>(_iterable.iterator, _f);// Specialization of [Iterable.map] to non-EfficientLengthIterable.Iterable<T> map<T>(T f(E element)) => new MappedIterable<E, T>._(this, f);
}

class WhereIterator<E> extends Iterator<E> {final Iterator<E> _iterator;//存储集合中的iterator对象final _ElementPredicate<E> _f;//存储where函数传入闭包函数WhereIterator(this._iterator, this._f);//重写moveNext函数bool moveNext() {//遍历原集合的_iteratorwhile (_iterator.moveNext()) {//注意: 这里会执行_f函数，如果满足条件就会返回true, 不符合条件的直接略过，迭代下一个元素；//那么外部迭代时候，就可以通过current获得当前元素，这样就实现了在原集合基础上过滤拿到符合条件的元素。if (_f(_iterator.current)) {return true;}}//迭代完_iterator所有元素后返回false,以此来终止外部迭代。return false;}//重写current的属性方法E get current => _iterator.current;
}

print(numbers.where((num) => num > 6));//输出: (7,12)，最后会调用Iterable的toString方法返回的内容。//看下Iterable的toString方法实现
String toString() => IterableBase.iterableToShortString(this, '(', ')');//这就是为啥输出样式是 (7,12)
//继续查看IterableBase.iterableToShortStringstatic String iterableToShortString(Iterable iterable,[String leftDelimiter = '(', String rightDelimiter = ')']) {if (_isToStringVisiting(iterable)) {if (leftDelimiter == "(" && rightDelimiter == ")") {// Avoid creating a new string in the "common" case.return "(...)";}return "$leftDelimiter...$rightDelimiter";}List<String> parts = <String>[];_toStringVisiting.add(iterable);try {_iterablePartsToStrings(iterable, parts);//注意:这里实际上就是通过将iterable转化成List，内部就是通过迭代iterator,以此会触发WhereIterator中的_f函数。} finally {assert(identical(_toStringVisiting.last, iterable));_toStringVisiting.removeLast();}return (StringBuffer(leftDelimiter)..writeAll(parts, ", ")..write(rightDelimiter)).toString();}/// Convert elements of [iterable] to strings and store them in [parts]. 这个函数代码实现比较多，这里给出部分代码
void _iterablePartsToStrings(Iterable iterable, List<String> parts) {...int length = 0;int count = 0;Iterator it = iterable.iterator;// Initial run of elements, at least headCount, and then continue until// passing at most lengthLimit characters.//可以看到这是外部迭代whilewhile (length < lengthLimit || count < headCount) {if (!it.moveNext()) return;//这里实际上调用了WhereIterator中的moveNext函数，经过_f函数处理的moveNext()String next = "${it.current}";//获取current.parts.add(next);length += next.length + overhead;count++;}...
}

E firstWhere(bool test(E element), {E orElse()})
E lastWhere(bool test(E element), {E orElse()})
E singleWhere(bool test(E element), {E orElse()})

main() {var numbers = <int>[0, 3, 1, 2, 7, 12, 2, 4];//注意: 如果没有找到，执行orElse代码块，可返回一个指定的默认值-1print(numbers.firstWhere((num) => num == 5, orElse: () => -1)); //注意: 如果没有找到，执行orElse代码块，可返回一个指定的默认值-1print(numbers.lastWhere((num) => num == 2, orElse: () => -1)); //注意: 如果没有找到，执行orElse代码块，可返回一个指定的默认值，前提是集合中只有一个符合条件的元素, 否则就会抛出异常print(numbers.singleWhere((num) => num == 4, orElse: () => -1));
}

//firstWhereE firstWhere(bool test(E element), {E orElse()}) {for (E element in this) {//直接遍历原集合，只要找到第一个符合条件的元素就直接返回，终止函数if (test(element)) return element;}if (orElse != null) return orElse();//遍历完集合后，都没找到符合条件的元素并且外部传入了orElse就会触发orElse函数//否则找不到元素，直接抛出异常。所以这里需要注意下，如果不想抛出异常，可能你需要处理下orElse函数。throw IterableElementError.noElement();}//lastWhereE lastWhere(bool test(E element), {E orElse()}) {E result;//定义result来记录每次符合条件的元素bool foundMatching = false;//定义一个标志位是否找到符合匹配的。for (E element in this) {if (test(element)) {//每次找到符合条件的元素，都会重置result，所以result记录了最新的符合条件元素，那么遍历到最后，它也就是最后一个符合条件的元素result = element;foundMatching = true;//找到后重置标记位}}if (foundMatching) return result;//如果标记位为true直接返回result即可if (orElse != null) return orElse();//处理orElse函数//同样，找不到元素，直接抛出异常。可能你需要处理下orElse函数。throw IterableElementError.noElement();}//singleWhereE singleWhere(bool test(E element), {E orElse()}) {E result;bool foundMatching = false;for (E element in this) {if (test(element)) {if (foundMatching) {//主要注意这里，只要foundMatching为true,说明已经找到一个符合条件的元素，如果触发这条逻辑分支，说明不止一个元素符合条件就直接抛出IterableElementError.tooMany()异常throw IterableElementError.tooMany();}result = element;foundMatching = true;}}if (foundMatching) return result;if (orElse != null) return orElse();//同样，找不到元素，直接抛出异常。可能你需要处理下orElse函数。throw IterableElementError.noElement();}

String join([String separator = ""])

main() {var numbers = <int>[0, 3, 1, 2, 7, 12, 2, 4];print(numbers.join('-'));//输出: 0-3-1-2-7-12-2-4
}

//接收separator可选参数，默认值为""String join([String separator = ""]) {Iterator<E> iterator = this.iterator;if (!iterator.moveNext()) return "";//创建StringBufferStringBuffer buffer = StringBuffer();//如果分隔符为空或空字符串if (separator == null || separator == "") {//do-while遍历iterator,然后直接拼接元素do {buffer.write("${iterator.current}");} while (iterator.moveNext());} else {//如果分隔符不为空//先加入第一个元素buffer.write("${iterator.current}");//然后while遍历iteratorwhile (iterator.moveNext()) {buffer.write(separator);//先拼接分隔符buffer.write("${iterator.current}");//再拼接元素}}return buffer.toString();//最后返回最终的字符串。}

Iterable<E> take(int count)

main() {List<int> numbers = [0, 3, 1, 2, 7, 12, 2, 4];print(numbers.take(5));//输出(0, 3, 1, 2, 7)
}

Iterable<E> take(int count) {return TakeIterable<E>(this, count);}

class TakeIterable<E> extends Iterable<E> {final Iterable<E> _iterable;//存储原集合final int _takeCount;//take countfactory TakeIterable(Iterable<E> iterable, int takeCount) {ArgumentError.checkNotNull(takeCount, "takeCount");RangeError.checkNotNegative(takeCount, "takeCount");if (iterable is EfficientLengthIterable) {//如果原集合是EfficientLengthIterable，就返回创建EfficientLengthTakeIterablereturn new EfficientLengthTakeIterable<E>(iterable, takeCount);}//否则就返回TakeIterablereturn new TakeIterable<E>._(iterable, takeCount);}TakeIterable._(this._iterable, this._takeCount);//注意: 这里是返回了TakeIterator，并传入原集合的iterator以及_takeCountIterator<E> get iterator {return new TakeIterator<E>(_iterable.iterator, _takeCount);}
}

class TakeIterator<E> extends Iterator<E> {final Iterator<E> _iterator;//存储原集合中的iteratorint _remaining;//存储需要截取的前几个元素的数量TakeIterator(this._iterator, this._remaining) {assert(_remaining >= 0);}bool moveNext() {_remaining--;//通过_remaining作为游标控制迭代次数if (_remaining >= 0) {//如果_remaining大于等于0就会继续执行moveNext方法return _iterator.moveNext();}_remaining = -1;return false;//如果_remaining小于0就返回false,终止外部循环}E get current {if (_remaining < 0) return null;return _iterator.current;}
}

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

main() {List<int> numbers = [3, 1, 2, 7, 12, 2, 4];print(numbers.takeWhile((number) => number > 2).toList());//输出: [3] 遇到1的时候就不满足大于2条件就终止筛选。
}

Iterable<E> takeWhile(bool test(E element)) {return TakeWhileIterable<E>(this, test);//可以看到它仅仅返回的是TakeWhileIterable，而不是筛选后符合条件的集合，所以它是惰性。}

class TakeWhileIterable<E> extends Iterable<E> {final Iterable<E> _iterable;final _ElementPredicate<E> _f;TakeWhileIterable(this._iterable, this._f);Iterator<E> get iterator {//重写iterator，创建一个TakeWhileIterator对象并返回。return new TakeWhileIterator<E>(_iterable.iterator, _f);}
}//TakeWhileIterator
class TakeWhileIterator<E> extends Iterator<E> {final Iterator<E> _iterator;final _ElementPredicate<E> _f;bool _isFinished = false;TakeWhileIterator(this._iterator, this._f);bool moveNext() {if (_isFinished) return false;//原集合_iterator遍历结束或者原集合中的当前元素current不满足_f条件，就返回false以此终止外部的迭代。//进一步说明了只有moveNext调用，才会触发_f的执行，此时惰性的Iterable才得以执行。if (!_iterator.moveNext() || !_f(_iterator.current)) {_isFinished = true;//迭代结束重置_isFinished为truereturn false;}return true;}E get current {if (_isFinished) return null;//如果迭代结束，还取current就直接返回null了return _iterator.current;}
}

Iterable<E> skip(int count)

main() {List<int> numbers = [3, 1, 2, 7, 12, 2, 4];print(numbers.skip(2).toList());//输出: [2, 7, 12, 2, 4] 跳过前两个元素3,1 直接从第3个元素开始
}

Iterable<E> skip(int count) => SubListIterable<E>(this, count, null);//返回的是一个SubListIterable惰性Iterable，传入原集合和需要跳过的count大小

class SubListIterable<E> extends ListIterable<E> {final Iterable<E> _iterable; // Has efficient length and elementAt.final int _start;//这是传入的需要skip的countfinal int _endOrLength;//这里传入为null...int get _endIndex {int length = _iterable.length;//获取原集合长度if (_endOrLength == null || _endOrLength > length) return length;//_endIndex为原集合长度return _endOrLength;}int get _startIndex {//主要看下_startIndex的实现int length = _iterable.length;//获取原集合长度if (_start > length) return length;//如果skip的count超过集合自身长度，_startIndex为原集合长度return _start;//否则返回skip的count}E elementAt(int index) {int realIndex = _startIndex + index;//相当于把原集合中每个元素原来index,整体向后推了_startIndex,最后获取真实映射的realIndexif (index < 0 || realIndex >= _endIndex) {//如果realIndex越界就会抛出异常throw new RangeError.index(index, this, "index");}return _iterable.elementAt(realIndex);//否则就取对应realIndex在原集合中的元素。}...
}

Iterable<E> skipWhile(bool test(E element))

main() {List<int> numbers = [3, 1, 2, 7, 12, 2, 4];print(numbers.skipWhile((number) => number < 4).toList());//输出: [7, 12, 2, 4]//因为3、1、2都是满足小于4的条件，所以直接skip跳过，直到遇到7不符合条件停止筛选，剩下的就是[7, 12, 2, 4]
}

Iterable<E> skipWhile(bool test(E element)) {return SkipWhileIterable<E>(this, test);//可以看到它仅仅返回的是SkipWhileIterable，而不是筛选后符合条件的集合，所以它是惰性的。}

class SkipWhileIterable<E> extends Iterable<E> {final Iterable<E> _iterable;final _ElementPredicate<E> _f;SkipWhileIterable(this._iterable, this._f);//重写iterator，创建一个SkipWhileIterator对象并返回。Iterator<E> get iterator {return new SkipWhileIterator<E>(_iterable.iterator, _f);}
}//SkipWhileIterator
class SkipWhileIterator<E> extends Iterator<E> {final Iterator<E> _iterator;//存储原集合的iteratorfinal _ElementPredicate<E> _f;//存储skipWhile中筛选闭包函数bool _hasSkipped = false;//判断是否已经跳过元素的标识，默认为falseSkipWhileIterator(this._iterator, this._f);//重写moveNext函数bool moveNext() {if (!_hasSkipped) {//如果是最开始第一次没有跳过任何元素_hasSkipped = true;//然后重置标识为true,表示已经进行了第一次跳过元素的操作while (_iterator.moveNext()) {//迭代原集合中的iteratorif (!_f(_iterator.current)) return true;//只要找到符合条件的元素，就略过迭代下一个元素，不符合条件就直接返回true终止当前moveNext函数，而此时外部迭代循环正式从当前元素开始迭代，}}return _iterator.moveNext();//那么遇到第一个不符合条件元素之后所有元素就会通过_iterator.moveNext()正常返回}E get current => _iterator.current;
}

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

main() {var languages = <String>['Kotlin', 'Java', 'Dart', 'Go', 'Python'];print(languages.followedBy(['Swift', 'Rust', 'Ruby', 'C++', 'C#']).toList());//输出: [Kotlin, Java, Dart, Go, Python, Swift, Rust, Ruby, C++, C#]
}

Iterable<E> followedBy(Iterable<E> other) =>FollowedByIterable<E>.firstEfficient(this, other);//这里实际上还是返回一个惰性的FollowedByIterable对象，这里使用命名构造器firstEfficient创建对象

factory FollowedByIterable.firstEfficient(EfficientLengthIterable<E> first, Iterable<E> second) {if (second is EfficientLengthIterable<E>) {//List肯定是一个EfficientLengthIterable，所以会创建一个EfficientLengthFollowedByIterable，传入的参数first是当前集合，second是需要在后面拼接的集合return new EfficientLengthFollowedByIterable<E>(first, second);}return new FollowedByIterable<E>(first, second);}

class EfficientLengthFollowedByIterable<E> extends FollowedByIterable<E>implements EfficientLengthIterable<E> {EfficientLengthFollowedByIterable(EfficientLengthIterable<E> first, EfficientLengthIterable<E> second): super(first, second);... E elementAt(int index) {//elementAt在迭代过程会调用int firstLength = _first.length;//取原集合的长度if (index < firstLength) return _first.elementAt(index);//如果index小于原集合长度就从原集合中获取元素return _second.elementAt(index - firstLength);//否则就通过index - firstLength 计算新的下标从拼接的集合中获取元素。}...
}

Iterable<T> expand<T>(Iterable<T> f(E element))

main() {var pair = [[1, 2],[3, 4]];print('flatten list: ${pair.expand((pair) => pair).toList()}');//输出: flatten list: [1, 2, 3, 4]var inputs = [1, 2, 3];print('duplicated list: ${inputs.expand((number) => [number, number, number]).toList()}');//输出: duplicated list: [1, 1, 1, 2, 2, 2, 3, 3, 3]
}

Iterable<T> expand<T>(Iterable<T> f(E element)) =>ExpandIterable<E, T>(this, f);//可以看到这里并没有直接返回扩展的集合，而是创建一个惰性的ExpandIterable对象返回，

typedef Iterable<T> _ExpandFunction<S, T>(S sourceElement);class ExpandIterable<S, T> extends Iterable<T> {final Iterable<S> _iterable;final _ExpandFunction<S, T> _f;ExpandIterable(this._iterable, this._f);Iterator<T> get iterator => new ExpandIterator<S, T>(_iterable.iterator, _f);//注意: 这里iterator是一个ExpandIterator对象，传入的是原集合的iterator和expand函数中闭包函数参数_f
}//ExpandIterator的实现
class ExpandIterator<S, T> implements Iterator<T> {final Iterator<S> _iterator;final _ExpandFunction<S, T> _f;//创建一个空的Iterator对象_currentExpansionIterator<T> _currentExpansion = const EmptyIterator();T _current;ExpandIterator(this._iterator, this._f);T get current => _current;//重写current//重写moveNext函数，只要当迭代的时候，moveNext执行才会触发闭包函数_f执行。bool moveNext() {//如果_currentExpansion返回false终止外部迭代循环if (_currentExpansion == null) return false;//开始_currentExpansion是一个空的Iterator对象，所以moveNext()为falsewhile (!_currentExpansion.moveNext()) {_current = null;//迭代原集合中的_iteratorif (_iterator.moveNext()) {//如果_f抛出异常，先重置_currentExpansion为null, 遇到 if (_currentExpansion == null) return false;就会终止外部迭代_currentExpansion = null;_currentExpansion = _f(_iterator.current).iterator;//执行_f函数} else {return false;}}_current = _currentExpansion.current;return true;}
}

E reduce(E combine(E previousValue, E element))
T fold<T>(T initialValue, T combine(T previousValue, E element))

main() {List<int> numbers = [3, 1, 2, 7, 12, 2, 4];print(numbers.reduce((prev, curr) => prev + curr)); //累加print(numbers.fold(2, (prev, curr) => (prev as int) + curr)); //累加print(numbers.reduce((prev, curr) => prev + curr) / numbers.length); //求平均数print(numbers.fold(2, (prev, curr) => (prev as int) + curr) / numbers.length); //求平均数print(numbers.reduce((prev, curr) => prev * curr)); //累乘print(numbers.fold(2, (prev, curr) => (prev as int) * curr)); //累乘var strList = <String>['a', 'b', 'c'];print(strList.reduce((prev, curr) => '$prev*$curr')); //拼接字符串print(strList.fold('e', (prev, curr) => '$prev*$curr')); //拼接字符串
}

E reduce(E combine(E previousValue, E element)) {int length = this.length;if (length == 0) throw IterableElementError.noElement();E value = this[0];//初始值默认取第一个for (int i = 1; i < length; i++) {//从第二个开始遍历value = combine(value, this[i]);//combine回调value值和当前元素值，然后把combine的结果归纳到value上，依次处理。if (length != this.length) {throw ConcurrentModificationError(this);//注意: 在操作过程中不允许删除和添加元素否则就会出现ConcurrentModificationError}}return value;}T fold<T>(T initialValue, T combine(T previousValue, E element)) {var value = initialValue;//和reduce唯一区别在于这里value初始值是外部指定的int length = this.length;for (int i = 0; i < length; i++) {value = combine(value, this[i]);if (length != this.length) {throw ConcurrentModificationError(this);}}return value;}

E elementAt(int index)

main() {print(numbers.elementAt(3));//elementAt一般不会直接使用，更多是使用[]，运算符重载的方式间接使用。
}

E elementAt(int index) {ArgumentError.checkNotNull(index, "index");RangeError.checkNotNegative(index, "index");int elementIndex = 0;//for-in遍历原集合，找到对应elementIndex元素并返回for (E element in this) {if (index == elementIndex) return element;elementIndex++;}//找不到抛出RangeErrorthrow RangeError.index(index, this, "index", null, elementIndex);}