blocks|key|1192352|text|延迟加载(在本例中是延迟连接)意味着某些资源在必要之前不进行评估。相反，急切加载(或急切连接)意味着对资源进行完全评估。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1192353|因此，延迟连接意味着已知的连接被执行，但是它的最终评估被推迟到需要的时候。此外，急切连接意味着整个级联过程是完全完成的。|1192354|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Lazy loading (in this case lazy concatenation) means that some resources are not evaluated before they are necessary. By contrast, eager loading (or eager concatenation) means that the resource is fully evaluated.
So, lazy concatenation means that the concatenation is known to be executed, but its final evaluation is postponed until it is needed. Also, eager concatenation means that the whole concatenation process is fully done.

blocks|key|456575|text|list1.addAll(list2)增长并变异list1以包含list2的元素。如果list2有m个元素，那么list1.addAll(list2)的内存消耗将通过增长O(m)来实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|456576|如果您有：|456577|list1++++++++++++++++++list2
%2B---%2B---%2B---%2B---%2B++++++%2B---%2B---%2B
%7C+o+%7C+o+%7C+o+%7C+o+%7C++++++%7C+o+%7C+o+%7C
%2B-%7C-%2B-%7C-%2B-%7C-%2B-%7C-%2B++++++%2B-%7C-%2B-%7C-%2B
++%7C+++%7C+++%7C+++%7C++++++++++%7C+++%7C
++v+++v+++v+++v++++++++++v+++v
++A+++B+++C+++D++++++++++E+++F|code-block|syntax|javascript|456578|然后list1.addAll(list2)将产生：|456579|list1+++++++++++++++++++++++list2
%2B---%2B---%2B---%2B---%2B---%2B---%2B+++%2B---%2B---%2B
%7C+o+%7C+o+%7C+o+%7C+o+%7C+o+%7C+o+%7C+++%7C+o+%7C+o+%7C
%2B-%7C-%2B-%7C-%2B-%7C-%2B-%7C-%2B-%7C-%2B-%7C-%2B+++%2B-%7C-%2B-%7C-%2B
++%7C+++%7C+++%7C+++%7C+++%7C+++%7C+++++++%7C+++%7C
++v+++v+++v+++v++++\+++\______%7C__+%7C
++A+++B+++C+++D+++++\+++______/++\%7C
+++++++++++++++++++++\+/++++++++++%7C
++++++++++++++++++++++%7C+++++++++++v
++++++++++++++++++++++v+++++++++++F
++++++++++++++++++++++E|456580|请注意，更改list2后不会影响list1的内容。|456581|list1.followedBy(list2)返回一个Iterable+(而不是List)。当您遍历该Iterable时，您将在list1上迭代，然后在list2上迭代。list1.followedBy(list2)不改变list1，也不应该分配新的List。list1.followedBy(list2)的内存消耗将增长O(1)，因为没有增长或创建List。|456582|在这种情况下，变异list2之后将影响followedBy返回的Iterable。|456583|void+main()+{
++var+list1+=+[1,+2,+3];
++var+list2+=+[4,+5,+6];
++
++var+list1Copy+=+[...list1];
++list1Copy.addAll(list2);
++
++print(list1Copy);+//+Prints:+[1,+2,+3,+4,+5,+6]
+++
++var+concatenated+=+list1.followedBy(list2);
++print(concatenated.toList());+//+Prints:+[1,+2,+3,+4,+5,+6]

++list2.add(7);
++print(list1Copy);+//+Prints:+[1,+2,+3,+4,+5,+6]
++print(concatenated.toList());+//+Prints:+[1,+2,+3,+4,+5,+6,+7]
}|456584|entityMap^0|0|J|O|5|W|5|17|5|1K|J|0|0|0|2|J|0|0|6|5|G|5|0|0|N|R|8|14|4|1F|8|1S|5|24|5|2D|N|33|5|3H|4|3M|N|4V|4|0|9|5|J|A|W|8|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|29|8|@$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]|$9|2E|A|2F|B|C]]|D|@]|E|$]]|$1|W|3|X|5|J|7|2G|8|@]|D|@]|E|$K|L]]|$1|Y|3|-4|5|6|7|2H|8|@]|D|@]|E|$]]]|Z|$]]

<code>list1.addAll(list2)</code> grows and mutates <code>list1</code> to include the elements of <code>list2</code>. If <code>list2</code> has m elements, then memory consumption from <code>list1.addAll(list2)</code> will by grow O(m).
More visually, if you have:
<pre><code>list1 list2
+---+---+---+---+ +---+---+
| o | o | o | o | | o | o |
+-|-+-|-+-|-+-|-+ +-|-+-|-+
 | | | | | |
 v v v v v v
 A B C D E F
</code></pre>
then <code>list1.addAll(list2)</code> will produce:
<pre><code>list1 list2
+---+---+---+---+---+---+ +---+---+
| o | o | o | o | o | o | | o | o |
+-|-+-|-+-|-+-|-+-|-+-|-+ +-|-+-|-+
 | | | | | | | |
 v v v v \ \______|__ |
 A B C D \ ______/ \|
 \ / |
 | v
 v F
 E
</code></pre>
Note that mutating <code>list2</code> afterward will not affect the contents of <code>list1</code>.
<code>list1.followedBy(list2)</code> returns an <code>Iterable</code> (not a <code>List</code>). When you iterate over the that <code>Iterable</code>, you will iterate over <code>list1</code> and then iterate over <code>list2</code>. <code>list1.followedBy(list2)</code> does not not mutate <code>list1</code> and should not allocate a new <code>List</code>. Memory consumption from <code>list1.followedBy(list2)</code> will grow by O(1) since no <code>List</code>s are grown nor created.
In this case, mutating <code>list2</code> afterward will affect the <code>Iterable</code> returned by <code>followedBy</code>:
<pre class="lang-dart prettyprint-override"><code>void main() {
 var list1 = [1, 2, 3];
 var list2 = [4, 5, 6];
 
 var list1Copy = [...list1];
 list1Copy.addAll(list2);
 
 print(list1Copy); // Prints: [1, 2, 3, 4, 5, 6]
 
 var concatenated = list1.followedBy(list2);
 print(concatenated.toList()); // Prints: [1, 2, 3, 4, 5, 6]

 list2.add(7);
 print(list1Copy); // Prints: [1, 2, 3, 4, 5, 6]
 print(concatenated.toList()); // Prints: [1, 2, 3, 4, 5, 6, 7]
}
</code></pre>

I need to concatenate two lists in Dart and saw that there are at least two different methods to do so. One is <code>list1.addAll(list2)</code> and the other is <code>list1.followedBy(list2)</code>.
I wonder what's the difference? The documentation refers to the latter as &quot;lazy concatenation&quot;. Does it mean that under the hood the elements are copied in the first case, but only referenced in the latter? Or is there something more?

What's the difference between addAll() vs followedBy() in Dart lists?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要在Dart中连接两个列表，并看到至少有两种不同的方法可以这样做。一个是list1.addAll(list2)，另一个是list1.followedBy(list2)。我想知道有什么区别？文档将后者称为“延迟连接”。这是否意味着在第一种情况下复制元素，而只在后一种情况中引用元素？还是还有别的什么？

问在Dart列表中，addAll()和followedBy()有什么区别？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Dart列表中，addAll()和followedBy()有什么区别？EN