collection 订阅
Collection 层次结构 中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。 展开全文
Collection 层次结构 中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。
信息
释义 
Collection 表示一组对象
相    关
接口通常用来传递 collection
中文名
COLLECTION
属    性
层次结构 中的根接口
COLLECTION基本信息
JDK不提供此接口的任何直接实现:它提供更具体的子接口(如 Set 和 List)实现。此接口通常用来传递 collection,并在需要最大普遍性的地方操作这些 collection。包 (bag) 或多集合 (multiset)(可能包含重复元素的无序 collection)应该直接实现此接口。所有通用的 Collection 实现类(通常通过它的一个子接口间接实现 Collection)应该提供两个“标准”构造方法:一个是 void(无参数)构造方法,用于创建空 collection;另一个是带有 Collection 类型单参数的构造方法,用于创建一个具有与其参数相同元素新的 collection。实际上,后者允许用户复制任何 collection,以生成所需实现类型的一个等效 collection。尽管无法强制执行此约定(因为接口不能包含构造方法),但是 Java 平台库中所有通用的 Collection 实现都遵从它。此接口中包含的“破坏性”方法,是指可修改其所操作的 collection 的那些方法,如果此 collection 不支持该操作,则指定这些方法抛出 UnsupportedOperationException。如果是这样,那么在调用对该 collection 无效时,这些方法可能,但并不一定抛出 UnsupportedOperationException。例如,如果要添加的 collection 为空且不可修改,则对该 collection 调用 addAll(Collection) 方法时,可能但并不一定抛出异常。一些 collection 实现对它们可能包含的元素有所限制。例如,某些实现禁止 null 元素,而某些实现则对元素的类型有限制。试图添加不合格的元素将抛出一个未经检查的异常,通常是 NullPointerException 或 ClassCastException。试图查询是否存在不合格的元素可能抛出一个异常,或者只是简单地返回 false;某些实现将表现出前一种行为,而某些实现则表现后一种。较为常见的是,试图对某个不合格的元素执行操作且该操作的完成不会导致将不合格的元素插入 collection 中,将可能抛出一个异常,也可能操作成功,这取决于实现本身。这样的异常在此接口的规范中标记为“可选”。由每个 collection 来确定其自身的同步策略。在没有实现的强烈保证的情况下,调用由另一进程正在更改的 collection 的方法可能会出现不确定行为;这包括直接调用,将 collection 传递给可能执行调用的方法,以及使用现有迭代器检查 collection。Collections Framework 接口中的很多方法是根据 equals 方法定义的。例如,contains(Object o) 方法的规范声明:“当且仅当此 collection 包含至少一个满足 (o==null e==null :o.equals(e)) 的元素 e 时,返回 true。”不 应将此规范理解为它暗指调用具有非空参数 o 的 Collection.contains 方法会导致为任意的 e 元素调用 o.equals(e) 方法。可随意对各种实现执行优化,只要避免调用 equals 即可,例如,通过首先比较两个元素的哈希码。(Object.hashCode() 规范保证哈希码不相等的两个对象不会相等)。较为常见的是,各种 Collections Framework 接口的实现可随意利用底层 Object 方法的指定行为,而不管实现程序认为它是否合适。
收起全文
精华内容
下载资源
问答
  • collection
    千次阅读
    2021-02-26 09:08:17

    在使用Java的时候,我们都会遇到使用集合(Collection)的时候,但是Java API提供了多种集合的实现。

    总的说来,Java API中所用的集合类,都是实现了Collection接口,他的一个类继承结构如下:

    Collection

    Collection

    Collection

    Collection

    Collection

    Collection

    Vector

    :

    基于Array的List,其实就是封装了Array所不具备的一些功能方便我们使用,它不可能不受Array的限制。性能也就不可能超越Array。所

    以,在可能的情况下,我们要多运用Array。另外很重要的一点就是Vector        :sychronized”的,这个也是Vector和

    ArrayList的唯一的区别。

    ArrayList:同Vector一样是一个基于Array上的链表,但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些,但是当运行到多线程环境中时,可需要自己在管理线程的同步问题。

    LinkedList:LinkedList不同于前面两种List,它不是基于Array的,所以不受Array性能的限制。它每一个节点(Node)都包含两方面的内容:1.节点本身的数据(data);2.下一个节点的信息(nextNode)。所以当对LinkedList做添加,删除动作的时候就不用像基于Array的List一样,必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。

    List总结:

    1. 所有的List中只能容纳单个不同类型的对象组成的表,而不是Key-Value键值对。例如:[ tom,1,c ];

    2. 所有的List中可以有相同的元素,例如Vector中可以有 [ tom,koo,too,koo ];

    3. 所有的List中可以有null元素,例如[ tom,null,1 ];

    4.

    基于Array的List(Vector,ArrayList)适合查询,而LinkedList(链表)适合添加,删除操作。

    HashSet:虽然Set同List都实现了Collection接口,但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的,这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。看看HashSet的add(Object obj)方法的实现就可以一目了然了。

    public

    boolean add(Object obj)

    {

    return map.put(obj, PRESENT) == null;

    }

    这个也是为什么在Set中不能像在List中一样有重复的项的根本原因,因为HashMap的key是不能有重复的。

    LinkedHashSet:HashSet的一个子类,一个链表。

    TreeSet:SortedSet的子类,它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。

    Set总结:

    1. Set实现的基础是Map(HashMap);

    2. Set中的元素是不能重复的,如果使用add(Object

    obj)方法添加已经存在的对象,则会覆盖前面的对象

    为什么要使用集合类 ?

    当你事先不知道要存放数据的个数,或者你需要一种比数组下标存取机制更灵活的方法时,你就需要用到集合类。

    理解集合类

    集合类存放于java.util包中。

    集合类存放的都是对象的引用,而非对象本身,出于表达上的便利,我们称集合中的对象就是指集合中对象的引用(reference)。

    集合类型主要有3种:set(集)、list(列表)和map(映射)。

    (1)集

    集(set)是最简单的一种集合,它的对象不按特定方式排序,只是简单的把对象加入集合中,就像往口袋里放东西。

    对集中成员的访问和操作是通过集中对象的引用进行的,所以集中不能有重复对象。

    集也有多种变体,可以实现排序等功能,如TreeSet,它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。它实现的是SortedSet接口,也就是加入了对象比较的方法。通过对集中的对象迭代,我们可以得到一个升序的对象集合。

    (2)列表

    列表的主要特征是其对象以线性方式存储,没有特定顺序,只有一个开头和一个结尾,当然,它与根本没有顺序的集是不同的。列表在数据结构中分别表现为:数组和向量、链表、堆栈、队列。

    关于实现列表的集合类,是我们日常工作中经常用到的,将在后边的笔记详细介绍。

    (3)映射

    映射与集或列表有明显区别,映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字(Key)对象,关键字决定了对象在映射中的存储位置,检索对象时必须提供相应的关键字,就像在字典中查单词一样。关键字应该是唯一的。关键字本身并不能决定对象的存储位置,它需要对过一种散列(hashing)技术来处理,产生一个被称作散列码(hash

    code)的整数值,

    散列码通常用作一个偏置量,该偏置量是相对于分配给映射的内存区域起始位置的,由此确定关键字/对象对的存储位置。理想情况下,散列处理应该产生给定范围内均匀分布的值,而且每个关键字应得到不同的散列码。

    集合类简介

    java.util中共有13个类可用于管理集合对象,它们支持集、列表或映射等集合,以下是这些类的简单介绍

    集:

    HashSet:

    使用HashMap的一个集的实现。虽然集定义成无序,但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的.

    TreeSet:

    在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.

    列表:

    Vector:

    实现一个类似数组一样的表,自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类!!当两个或多个线程同时访问时也是性能良好的。

    Stsck:

    这个类从Vector派生而来,并且增加了方法实现栈!一种后进先出的存储结构。

    LinkedList:

    实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。

    ArrayList:

    实现一个数组,它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步。

    映射:

    HashTable:

    实现一个映象,所有的键必须非空。为了能高效的工作,定义键的类必须实现hashcode()方法和equal()方法。这个类是前面java实现的一个继承,并且通常能在实现映象的其他类中更好的使用。

    HashMap:

    实现一个映象,允许存储空对象,而且允许键是空(由于键必须是唯一的,当然只能有一个)。

    WeakHashMap:

    实现这样一个映象:通常如果一个键对一个对象而言不再被引用,键/对象对将被舍弃。这与HashMap形成对照,映象中的键维持键/对象对的生命周期,尽管使用映象的程序不再有对键的引用,并且因此不能检索对象。

    TreeMap:

    实现这样一个映象,对象是按键升序排列的。

    Set和List都是由公共接口Collection扩展而来,所以它们都可以使用一个类型为Collection的变量来引用。这就意味着任何列

    表或集构成的集合都可以用这种方式引用,只有映射类除外(但也不是完全排除在外,因为可以从映射获得一个列表。)所以说,把一个列表或集传递给方法的标准

    途径是使用Collection类型的参数。

    Vector 还是ArrayList,哪一个更好,为什么?

    要回答这个问题不能一概而论,有时候使用Vector比较好;有时是ArrayList,有时候这两个都不是最好的选择。你别指望能够获得一个简单肯定答案,因为这要看你用它们干什么。下面有4个要考虑的因素:

    (1)API

    (2)同步处理

    (3)数据增长性

    (4)使用模式

    下面针对这4个方面进行一一探讨

    API

    在由Ken Arnold等编著的《Java Programming Language》(Addison-Wesley, June

    2000)一书中有这样的描述,Vector类似于ArrayList.。所有从API的角度来看这两个类非常相似。但他们之间也还是有一些主要的区别

    的。

    同步性

    Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的,因此ArrayList中的

    对象并不是线程安全的。因为同步的要求会影响执行的效率,所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择,这样可以避免由于

    同步带来的不必要的性能开销。

    数据增长

    从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候,如果元素

    的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度,Vector缺省情况下自动增长原来一倍的数组长度,ArrayList是原来的50%,

    所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势,因为你可以通过设置集

    合的初始化大小来避免不必要的资源开销。

    使用模式

    在ArrayList和Vector中,从一个指定的位置(通过索引)查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的,这个时间

    我们用O(1)表示。但是,如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长:O(n-i),其中n代表集合中元素的个数,i代表元素增加

    或移除元素的索引位置。为什么会这样呢?以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢?

    这意味着,你只是查找特定位置的元素或只在集合的末端增加、移除元素,那么使用Vector或ArrayList都可以。如果是其他操作,你最好选择其他的集合操作类。

    如,LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的—O(1),但它在索引一个元素的使用却比较慢-O(i),其中i是

    索引的位置.使用ArrayList也很容易,因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创

    建对象,所以你要明白它也会带来额外的开销。

    最后,在《Practical Java》一书中Peter

    Haggar建议使用一个简单的数组(Array)来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组

    (Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

    更多相关内容
  • #jQuery Collection Plugin 这是一个使用 Symfony2 表单集合的简单插件。 有关在应用程序中设置表单收集的更多信息,请阅读。用法这个插件的主要目标是易于使用。 最低使用示例是: $(".collection").collection(); ...
  • googleCollection

    2021-03-28 12:43:35
    googleCollection com.google.common.collect
  • collection:PHP 集合

    2021-06-05 09:29:05
    #Collection (PHPExtra\Type\Collection) ##用法集合通过实现以下接口解决了一些问题: \Countable 、 \ArrayAccess 、 \Iterator和\SortableInterface 。 这使您能够count()集合,在其上使用foreach ,像数组$a[1...
  • mybatis 一对多collection的使用 在mybatis如何进行一对多的多表查询呢?这里用一个简单的例子说明
  • 集合-json collection-json 是一个用 Python 编写的小型库,用于处理 Collection+JSON 文档。安装安装 collection-json 最简单的方法是运行$ pip install collection-json其他安装方式请参考。例子解析一个 ...
  • get_collection_names mongodb get_collection_names与mongoose.connection 安装 npm install-保存get_collection_names 用法 var get_collection_names = require('get_collection_names'); var host = "127.0.0.1...
  • ## Laravel学习笔记汇总——Collection方法详解 本文参考:https:// laravel.com/docs/8.x/collections // 返回整个底层的数组 collect([1, 2, 3])->all(); // [1, 2, 3] // 返回平均数 $average = collect([1...

    ## Laravel学习笔记汇总——Collection方法详解

    本文参考:https:// laravel.com/docs/8.x/collections

    // 返回整个底层的数组
    collect([1, 2, 3])->all(); 
    // [1, 2, 3]

    // 返回平均数
    $average = collect([1, 1, 2, 4])->avg(); # 也可以用全拼average
    // 2

    // 对某个字段值作平均,如果某项中不存在该字段值,则不计入
    $average = collect([
        ['foo' => 10],
        ['foo' => 10],
        ['foo' => 20],
        ['foo' => 40]
    ])->avg('foo');
    // 20


    // 将原Collection拆分成一定大小的几部分
    $collection = collect([1, 2, 3, 4, 5, 6, 7]);
    $chunks = $collection->chunk(4);
    $chunks->all();
    // [[1, 2, 3, 4], [5, 6, 7]]


    // chunkWhile 的神奇用法,使用一个函数作为chunk的条件
    $collection = collect(str_split('AABBCCCD'));
    $chunks = $collection->chunkWhile(function ($value, $key, $chunk) {
        return $value === $chunk->last();
    });
    $chunks->all();
    // [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]


    // collapse用于让数组的Collection铺平为元素
    $collection = collect([
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
    ]);
    $collapsed = $collection->collapse();
    $collapsed->all();
    // [1, 2, 3, 4, 5, 6, 7, 8, 9]


    // combine将一个数组作为键,第二个数组作为值,生成关联数组
    $collection = collect(['name', 'age']);
    $combined = $collection->combine(['George', 29]);
    $combined->all();
    // ['name' => 'George', 'age' => 29]

    // concat将多个部分合成一个数组
    $collection = collect(['John Doe']);
    $concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
    $concatenated->all();
    // ['John Doe', 'Jane Doe', 'Johnny Doe']

    // contains将检测数组中是否存在某个值
    $collection = collect(['name' => 'Desk', 'price' => 100]);
    $collection->contains('Desk');// true
    $collection->contains('New York');// false

    // 如果参数是回调函数则判断是否存在满足函数返回true的值
    $collection = collect([1, 2, 3, 4, 5]);
    $collection->contains(function ($value, $key) {
        return $value > 5;
    });
    // false

    // 如果参数是key/value对,则判断是否存在数组中存在该键值对
    $collection = collect([
        ['product' => 'Desk', 'price' => 200],
        ['product' => 'Chair', 'price' => 100],
    ]);
    $collection->contains('product', 'Bookcase');
    // false

    // contain判断是否等值时用的是不严格比较法,如果要使用严格比较判断,需要改用containStrict

    // count可以返回数组的个数
    $collection = collect([1, 2, 3, 4]);
    $collection->count();
    // 4

    // countBy可以返回数组中每种值出现的次数
    $collection = collect([1, 2, 2, 2, 3]);
    $counted = $collection->countBy();
    $counted->all();
    // [1 => 1, 2 => 3, 3 => 1]

    // countBy也可以用回调函数作为参数,此时统计回调函数返回值的个数情况
    $collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']);
    $counted = $collection->countBy(function ($email) {
        return substr(strrchr($email, "@"), 1);
    });
    $counted->all();
    // ['gmail.com' => 2, 'yahoo.com' => 1]


    // crossJoin返回笛卡尔积;当参数个数为2个时,返回三个数组的笛卡尔积
    $collection = collect([1, 2]);
    $matrix = $collection->crossJoin(['a', 'b']);
    $matrix->all();
    /*
        [
            [1, 'a'],
            [1, 'b'],
            [2, 'a'],
            [2, 'b'],
        ]
    */


    // diff得到A数组不在B数组中的元素
    $collection = collect([1, 2, 3, 4, 5]);
    $diff = $collection->diff([2, 4, 6, 8]);
    $diff->all();
    // [1, 3, 5]


    // diffAssoc是diff的关联数组版本,比较的是键值对,值不同也算不在B中
    $collection = collect([
        'color' => 'orange',
        'type' => 'fruit',
        'remain' => 6,
    ]);

    $diff = $collection->diffAssoc([
        'color' => 'yellow',
        'type' => 'fruit',
        'remain' => 3,
        'used' => 6,
    ]);

    $diff->all();

    // ['color' => 'orange', 'remain' => 6]

    // diffKeys只看A中的键在不在B中,如果不在就放到结果中
    $collection = collect([
        'one' => 10,
        'two' => 20,
        'three' => 30,
        'four' => 40,
        'five' => 50,
    ]);

    $diff = $collection->diffKeys([
        'two' => 2,
        'four' => 4,
        'six' => 6,
        'eight' => 8,
    ]);

    $diff->all();

    // ['one' => 10, 'three' => 30, 'five' => 50]

    // duplicates返回数组中重复的元素位置及元素值
    $collection = collect(['a', 'b', 'a', 'c', 'b']);
    $collection->duplicates();
    // [2 => 'a', 4 => 'b']


    // 对关联数组可以指定key,判断是否是重复值
    $employees = collect([
        ['email' => 'abigail@example.com', 'position' => 'Developer'],
        ['email' => 'james@example.com', 'position' => 'Designer'],
        ['email' => 'victoria@example.com', 'position' => 'Developer'],
    ]);
    $employees->duplicates('position');
    // [2 => 'Developer']

    // duplicatesStrict是duplicates的严格比较版,使用方法相同


    // each对每一个元素进行迭代,如想中断,则返回false
    $collection->each(function ($item, $key) {
        if (/* condition */) {
            return false;
        }
    });


    // every对所有元素进行判断,都满足参数中的回调函数时整体返回true,否则为false。当数组为空时,总返回true。
    $result = collect([1, 2, 3, 4])->every(function ($value, $key) {
        return $value > 2;
    });
    echo $result; // false


    // except将排除指定的键(字段),only则只要某个键
    $collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
    $filtered = $collection->except(['price', 'discount']);
    $filtered->all();
    // ['product_id' => 1]


    // filter将按回调函数返回值情况,过滤出一批元素;与reject功能相对
    $collection = collect([1, 2, 3, 4]);
    $filtered = $collection->filter(function ($value, $key) {
        return $value > 2;
    });
    $filtered->all();
    // [3, 4]


    // 如果filter不带回调函数,则原数组中相当于false的值将被过滤掉
    $collection = collect([1, 2, 3, null, false, '', 0, []]);
    $collection->filter()->all();
    // [1, 2, 3]


    // first返回数组的第一个元素;如果里面带回调函数参数,则返回第一个能让函数返回true的元素
    collect([1, 2, 3, 4])->first(); // 1
    collect([1, 2, 3, 4])->first(function ($value, $key) {
        return $value > 2;
    });
    // 3


    // 使用last得到最后一行记录,也可以使用回调函数作为参数
    collect([1, 2, 3, 4])->last(); // 4

    // firstWhere 会对数组中元素的键值作限制
    $collection = collect([
        ['name' => 'Regena', 'age' => null],
        ['name' => 'Linda', 'age' => 14],
        ['name' => 'Diego', 'age' => 23],
        ['name' => 'Linda', 'age' => 84],
    ]);
    $collection->firstWhere('name', 'Linda');
    // ['name' => 'Linda', 'age' => 14]
    // 使用比较运算符也可以
    $collection->firstWhere('age', '>=', 18);
    // ['name' => 'Diego', 'age' => 23]

    // flapMap 遍历元素并将每一元素值用回调函数处理,返回一个新的一维数组
    $collection = collect([
        ['name' => 'Sally'],
        ['school' => 'Arkansas'],
        ['age' => 28]
    ]);
    $flattened = $collection->flatMap(function ($values) {
        return array_map('strtoupper', $values);
    });
    $flattened->all();
    // ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];

    // flatten把多维数组压缩成一维
    $collection = collect([
        'name' => 'taylor',
        'languages' => [
            'php', 'javascript'
        ]
    ]);
    $flattened = $collection->flatten();
    $flattened->all();
    // ['taylor', 'php', 'javascript'];


    // flatten对高维数组也可以带上参数如1,指只压缩掉第一维
    $collection = collect([
        'Apple' => [
            [
                'name' => 'iPhone 6S',
                'brand' => 'Apple'
            ],
        ],
        'Samsung' => [
            [
                'name' => 'Galaxy S7',
                'brand' => 'Samsung'
            ],
        ],
    ]);
    $products = $collection->flatten(1);
    $products->values()->all();
    /*
        [
            ['name' => 'iPhone 6S', 'brand' => 'Apple'],
            ['name' => 'Galaxy S7', 'brand' => 'Samsung'],
        ]
    */


    // flip可以将关联数组的键值对调
    $collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
    $flipped = $collection->flip();
    $flipped->all();
    // ['taylor' => 'name', 'laravel' => 'framework']

    // forget将相应的键去除,直接在原Collection上修改
    $collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
    $collection->forget('name');
    $collection->all();
    // ['framework' => 'laravel']

    // forPage将数组分页,并得到某一页的数据
    $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
    $chunk = $collection->forPage(2, 3); // 每3个元素为一页,取第2页的元素
    $chunk->all();
    // [4, 5, 6]


    // get返回指定键的值
    $collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
    $value = $collection->get('name');
    // taylor

    // get可以有第二个参数,表示该键不存在时,使用默认值
    $collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
    $value = $collection->get('age', 34);
    // 34


    // 使用groupBy可以对数组分组
    $collection = collect([
        ['account_id' => 'account-x10', 'product' => 'Chair'],
        ['account_id' => 'account-x10', 'product' => 'Bookcase'],
        ['account_id' => 'account-x11', 'product' => 'Desk'],
    ]);
    $grouped = $collection->groupBy('account_id'); # 该参数也可以是一个回调函数,还可以增加第二个参数作为共同的分组标准
    $grouped->all();
    /*
        [
            'account-x10' => [
                ['account_id' => 'account-x10', 'product' => 'Chair'],
                ['account_id' => 'account-x10', 'product' => 'Bookcase'],
            ],
            'account-x11' => [
                ['account_id' => 'account-x11', 'product' => 'Desk'],
            ],
        ]
    */

    // has用于判断数组中是否有给定的键
    $collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
    $collection->has('product');// true
    $collection->has(['product', 'amount']);// true
    $collection->has(['amount', 'price']);// false

    // implode用于将数组连接成字符串
    collect([1, 2, 3, 4, 5])->implode('-');
    // '1-2-3-4-5'

    // 如果数组里面的元素是数组或对象,则需要提供一个键名
    $collection = collect([
        ['account_id' => 1, 'product' => 'Desk'],
        ['account_id' => 2, 'product' => 'Chair'],
    ]);
    $collection->implode('product', ', ');
    // Desk, Chair

    // intersect求两数组的交集
    $collection = collect(['Desk', 'Sofa', 'Chair']);
    $intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
    $intersect->all();
    // [0 => 'Desk', 2 => 'Chair']


    // intersectByKeys得到两关联数组中键名存在交集的部分
    $collection = collect([
        'serial' => 'UX301', 'type' => 'screen', 'year' => 2009,
    ]);
    $intersect = $collection->intersectByKeys([
        'reference' => 'UX404', 'type' => 'tab', 'year' => 2011,
    ]);
    $intersect->all();
    // ['type' => 'screen', 'year' => 2009]


    // isEmpty判断一个Collection中的数组是否为空
    collect([])->isEmpty(); // true
    // isNotEmpty判断一个Collection中的数组是否不为空
    collect([])->isNotEmpty(); // false


    // join连接数组元素,第二个可选参数可以指定最后两个元素中间的连接符
    collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'
    collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'
    collect(['a', 'b'])->join(', ', ' and '); // 'a and b'
    collect(['a'])->join(', ', ' and '); // 'a'
    collect([])->join(', ', ' and '); // ''


    // keyBy将collection中的关联数组元素,按指定的key创建新的数组,key相同的只用最后一条记录
    $collection = collect([
        ['product_id' => 'prod-100', 'name' => 'Desk'],
        ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]);
    $keyed = $collection->keyBy('product_id');
    $keyed->all();
    /*
        [
            'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
            'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
        ]
    */


    // keys返回所有元素的key
    $collection = collect([
        'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]);
    $keys = $collection->keys();
    $keys->all();
    // ['prod-100', 'prod-200']


    // map可以对所有元素进行映射操作,返回一个新的collection
    $collection = collect([1, 2, 3, 4, 5]);
    $multiplied = $collection->map(function ($item, $key) {
        return $item * 2;
    });
    $multiplied->all();
    // [2, 4, 6, 8, 10]


    // mapInto将集合的元素映射作为类的构造函数参数,得到新的类实例
    // 将类和回调函数作为映射参数都是一种以数据为中心的思路
    class Currency
    {
        function __construct(string $code)
        {
            $this->code = $code;
        }
    }

    $collection = collect(['USD', 'EUR', 'GBP']);
    $currencies = $collection->mapInto(Currency::class);
    $currencies->all();
    // [Currency('USD'), Currency('EUR'), Currency('GBP')]

    // mapSpread可以将数组型的数据项作为元素传入回调函数,作进一步计算处理
    $collection = collect([[0, 1, 2], [3, 4, 5], [6, 7, 8]]);
    $sequence = $collection->mapSpread(function ($first, $second, $third) {
        return $first+$second+$third;
    });
    $sequence->all();
    // [3,12,21]

    // mapToGroup得到回调函数中规定键值对的数据,如有重复会将所有同一键的内容放到数组中
    $collection = collect([
        [
            'name' => 'John Doe',
            'department' => 'Sales',
        ],
        [
            'name' => 'Jane Doe',
            'department' => 'Sales',
        ],
        [
            'name' => 'Johnny Doe',
            'department' => 'Marketing',
        ]
    ]);
    $grouped = $collection->mapToGroups(function ($item, $key) {
        return [$item['department'] => $item['name']];
    });
    $grouped->all();
    /*
        [
            'Sales' => ['John Doe', 'Jane Doe'],
            'Marketing' => ['Johnny Doe'],
        ]
    */

    // mapWithKeys得到回调函数中规定键值对的数据,如有重复只保留最后一条记录
    $collection = collect([
        [
            'name' => 'John',
            'department' => 'Sales',
            'email' => 'john@example.com',
        ],
        [
            'name' => 'Jane',
            'department' => 'Marketing',
            'email' => 'jane@example.com',
        ]
    ]);
    $keyed = $collection->mapWithKeys(function ($item) {
        return [$item['email'] => $item['name']];
    });
    $keyed->all();
    /*
        [
            'john@example.com' => 'John',
            'jane@example.com' => 'Jane',
        ]
    */


    // max返回数组中的最大值,可以带一个参数表示指定哪一个字段
    // median, min, mode等与之相同
    $max = collect([
        ['foo' => 10],
        ['foo' => 20]
    ])->max('foo'); // 20
    $max = collect([1, 2, 3, 4, 5])->max(); // 5


    // merge会直接合并两个普通数组
    $collection = collect(['Desk', 'Chair']);
    $merged = $collection->merge(['Bookcase', 'Door']);
    $merged->all();
    // ['Desk', 'Chair', 'Bookcase', 'Door']

    // merge合并两个关联数组,如果提供的新数组中有键与原数组重复,值取新数组中的
    $collection = collect(['product_id' => 1, 'price' => 100]);
    $merged = $collection->merge(['price' => 200, 'discount' => false]);
    $merged->all();
    // ['product_id' => 1, 'price' => 200, 'discount' => false]


    // mergeRecursive会将两个关联数组中相同键的值合并为一个普通数组
    $collection = collect(['product_id' => 1, 'price' => 100]);
    $merged = $collection->mergeRecursive([
        'product_id' => 2,
        'price' => 200,
        'discount' => false
    ]);
    $merged->all();
    // ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false]


    // nth从第0个元素起,每n个元素放入结果中
    $collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
    $collection->nth(4);
    // ['a', 'e']
    // 第2个参数可以指定从哪一索引位开始
    $collection->nth(4, 1);
    // ['b', 'f']


    // pad让数组用第二个参数填充到n个元素
    $collection = collect(['A', 'B', 'C']);
    $filtered = $collection->pad(5, 0);
    $filtered->all();
    // ['A', 'B', 'C', 0, 0]
    // 如果n为负数,则表示在左边填充
    $filtered = $collection->pad(-5, 0);
    $filtered->all();
    // [0, 0, 'A', 'B', 'C']


    // partition将原数组分为通过和未通过回调函数测试的两大部分
    $collection = collect([1, 2, 3, 4, 5, 6]);
    [$underThree, $equalOrAboveThree] = $collection->partition(function ($i) {
        return $i < 3;
    });
    $underThree->all();
    // [1, 2]
    $equalOrAboveThree->all();
    // [3, 4, 5, 6]

    // pipe
    $collection = collect([
        ['name' => 'News', 'view' => 100 ],
        ['name' => 'Sports', 'view' => 800 ],
        ['name' => 'Travel', 'view' => 600 ],
        ['name' => 'Culture', 'view' => 300 ],
        ['name' => 'Science', 'view' => 1000 ],
    ]);
    $piped = $collection->pipe(function ($collection) {
        return [
        'sum' => $collection->sum('view'),
        'max' => $collection->max('view'),
        'min' => $collection->min('view'),
        // 按是否包含t分为两组
        'partition' => $collection->partition(function($item){
            return stristr($item['name'], 't');
        }),
        ];
    });

    // pipeInto将数据导入一个类实例
    class ResourceCollection
    {
        public $collection;

        public function __construct(Collection $collection)
        {
            $this->collection = $collection;
        }
    }

    $collection = collect([1, 2, 3]);
    $resource = $collection->pipeInto(ResourceCollection::class);
    $resource->collection->all();
    // [1, 2, 3]

    // pluck获取一个字段的所有值
    $collection = collect([
        ['product_id' => 'prod-100', 'name' => 'Desk'],
        ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]);
    $plucked = $collection->pluck('name');
    $plucked->all();
    // ['Desk', 'Chair']


    // pluck如果有第二个参数,则表示返回以第二个参数为键,第一个参数为值的关联数组
    $plucked = $collection->pluck('name', 'product_id');
    $plucked->all();
    // ['prod-100' => 'Desk', 'prod-200' => 'Chair']

    // pop删除collection中最后一个元素,并返回它;直接修改原数据
    $collection = collect([1, 2, 3, 4, 5]);
    $collection->pop();// 5
    $collection->all();
    // [1, 2, 3, 4]

    // prepend在collection的前面添加一个元素;直接修改原数据
    $collection = collect([1, 2, 3, 4, 5]);
    $collection->prepend(0);
    $collection->all();
    // [0, 1, 2, 3, 4, 5]


    // 如果指定了第二个参数,则将以第二个参数为index/key
    $collection = collect(['one' => 1, 'two' => 2]);
    $collection->prepend(0, 'zero');
    $collection->all();
    // ['zero' => 0, 'one' => 1, 'two' => 2]


    // pull删除指定key的数据,并返回它
    $collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);
    $collection->pull('name');// 'Desk'
    $collection->all();
    // ['product_id' => 'prod-100']


    // push
    $collection = collect([1, 2, 3, 4]);
    $collection->push(5);
    $collection->all();
    // [1, 2, 3, 4, 5]

    // put增加一个键值对应
    $collection = collect(['product_id' => 1, 'name' => 'Desk']);
    $collection->put('price', 100);
    $collection->all();
    // ['product_id' => 1, 'name' => 'Desk', 'price' => 100]

    // random返回随机元素
    $collection = collect([1, 2, 3, 4, 5]);
    $collection->random();
    $random = $collection->random(3); // 取出3个随机元素
    $random->all();


    // reduce将数组压缩为一个值,将上一次的计算结果作为$carry引入
    $collection = collect([1, 2, 3]);
    $total = $collection->reduce(function ($carry, $item) {
        return $carry + $item;
    });
    // 6
    $collection->reduce(function ($carry, $item) {
        return $carry + $item;
    }, 4);// 提供第一轮遍历时$carry的默认值,否则为null
    // 10

    // 如果是关联数组
    $collection = collect([
        'usd' => 1400,
        'gbp' => 1200,
        'eur' => 1000,
    ]);
    $ratio = [
        'usd' => 1,
        'gbp' => 1.37,
        'eur' => 1.22,
    ];
    $collection->reduce(function ($carry, $value, $key) use ($ratio) {
        return $carry + ($value * $ratio[$key]);
    });
    // 4264


    // reject与filter相反,从数组中去除满足回调函数测试的元素
    $collection = collect([1, 2, 3, 4]);
    $filtered = $collection->reject(function ($value, $key) {
        return $value > 2;
    });
    $filtered->all();
    // [1, 2]

    // replace将原数组中的项修改为提供的匹配项,数字索引也会替换
    $collection = collect(['Taylor', 'Abigail', 'James']);
    $replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']);
    $re = $replaced->all();
    // ['Taylor', 'Victoria', 'James', 'Finn']
    // 如果是merge,将返回['Taylor', 'Abigail', 'James', 'Victoria', 'Finn']


    // replaceRecursive可以替换原元素中更深层的键值
    $collection = collect([
        'Taylor',
        'Abigail',
        [
            'James',
            'Victoria',
            'Finn'
        ]
    ]);

    $replaced = $collection->replaceRecursive([
        'Charlie',
        2 => [1 => 'King']
    ]);
    $replaced->all();
    // ['Charlie', 'Abigail', ['James', 'King', 'Finn']]

    // reverse将原数组倒序排列,保留原索引
    $collection = collect(['a', 'b', 'c', 'd', 'e']);
    $reversed = $collection->reverse();
    $reversed->all();
    /*
        [
            4 => 'e',
            3 => 'd',
            2 => 'c',
            1 => 'b',
            0 => 'a',
        ]
    */

    // search搜索指定的元素,找到返回其第一次出现的索引,未找到则返回false
    $collection = collect([2, 4, 6, 8]);
    $collection->search(4); // 1
    // 如果增加$strict=true的参数,则会进行严格匹配
    collect([2, 4, 6, 8])->search('4', $strict = true); // false
    // 也可以用回调函数作为参数,则表示搜索第一次满足回调函数测试的元素
    collect([2, 4, 6, 8])->search(function ($item, $key) {
        return $item > 5;
    });
    // 2


    // shift跟pop相对,删除并返回第一个元素
    $collection = collect([1, 2, 3, 4, 5]);
    $collection->shift(); // 1
    $collection->all(); // [2, 3, 4, 5]

    // shuffle随机打乱所有元素,返回一个新collection
    $collection = collect([1, 2, 3, 4, 5]);
    $shuffled = $collection->shuffle();
    $shuffled->all();
    // [3, 2, 5, 1, 4] - (generated randomly)

    // sliding每几个元素为一组,$step表示往前的步进数,默认为1
    $collection = collect([1, 2, 3, 4, 5]);
    $chunks = $collection->sliding(3, $step= 2);
    $re = $chunks->toArray();
    // [[1, 2, 3], [3, 4, 5]]
    $chunks = $collection->sliding(2);
    $chunks->toArray();
    // [[1, 2], [2, 3], [3, 4], [4, 5]]

    // skip跳过前面的几个元素,返回一个新collection
    $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
    $collection = $collection->skip(4);
    $collection->all();
    // [5, 6, 7, 8, 9, 10]

    // skipUntil跳过前面若干元素,直到碰到某一元素为止
    $collection = collect([1, 2, 3, 4]);
    $subset = $collection->skipUntil(3);
    $subset->all();
    // [3, 4]
    // 第二参数也可以是一个回调函数
    $subset = $collection->skipUntil(function ($item) {
        return $item >= 3;
    });
    $subset->all();
    // [3, 4]

    // skipWhile跟skipUntil的逻辑相反,符合条件时都skip,直到碰到不符合条件的为止
    $collection = collect([1, 2, 3, 4]);
    $subset = $collection->skipWhile(function ($item) {
        return $item <= 3;
    });
    $subset->all();
    // [4]


    // slice从某一索引处切分原数组
    $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
    $slice = $collection->slice(4);
    $slice->all();
    // [5, 6, 7, 8, 9, 10]
    // 第二个参数可以限制返回数组的长度
    $slice = $collection->slice(4, 2);
    $slice->all();
    // [5, 6]

    // sole测试数组中是否存在唯一的某一元素
    collect([1, 2, 3, 4])->sole(function ($value, $key) {
        return $value === 2;
    });
    // 2
    // 也可以对关联数组进行测试
    $collection = collect([
        ['product' => 'Desk', 'price' => 200],
        ['product' => 'Chair', 'price' => 100],
    ]);
    $collection->sole('product', 'Chair');
    // ['product' => 'Chair', 'price' => 100]

    // sort得到排序后保留原key的数组
    // sortDesc与sort用法类似,得到的结果是相反的
    $collection = collect([5, 3, 1, 2, 4]);
    $sorted = $collection->sort();
    $sorted->values()->all();
    // [1, 2, 3, 4, 5]

    // sortBy可让关联数组按某指定键进行排序
    // sortByDesc与sortBy用法类似,得到的结果是相反的
    $collection = collect([
        ['name' => 'Desk', 'price' => 200],
        ['name' => 'Chair', 'price' => 100],
        ['name' => 'Bookcase', 'price' => 150],
    ]);
    $sorted = $collection->sortBy('price');
    $sorted->values()->all();
    /*
        [
            ['name' => 'Chair', 'price' => 100],
            ['name' => 'Bookcase', 'price' => 150],
            ['name' => 'Desk', 'price' => 200],
        ]
    */

    // sortBy可以接收第二个参数,指定排序的依据
    // 详见https://www.php.net/manual/en/function.sort.php
    $collection = collect([
        ['title' => 'Item 1'],
        ['title' => 'Item 12'],
        ['title' => 'Item 3'],
    ]);
    $sorted = $collection->sortBy('title', SORT_NATURAL);
    $sorted->values()->all();
    /*
        [
            ['title' => 'Item 1'],
            ['title' => 'Item 3'],
            ['title' => 'Item 12'],
        ]
    */


    // 还可以用回调函数自定义排序依据,如下面例子根据colors中元素个数排序
    $collection = collect([
        ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
        ['name' => 'Chair', 'colors' => ['Black']],
        ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
    ]);
    $sorted = $collection->sortBy(function ($product, $key) {
        return count($product['colors']);
    });
    $sorted->values()->all();
    /*
        [
            ['name' => 'Chair', 'colors' => ['Black']],
            ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
            ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
        ]
    */


    // sortKeys将数组按key进行排序, sortKeysDesc结果相反
    $collection = collect([
        'id' => 22345,
        'first' => 'John',
        'last' => 'Doe',
    ]);
    $sorted = $collection->sortKeys();
    $sorted->all();
    /*
        [
            'first' => 'John',
            'id' => 22345,
            'last' => 'Doe',
        ]
    */


    // splice返回从指定索引位置开始的一段数组,原数据将只剩下前部分
    $collection = collect([1, 2, 3, 4, 5]);
    $chunk = $collection->splice(2);
    $chunk->all();
    // [3, 4, 5]
    $collection->all();
    // [1, 2]

    // 如果splice有第二个参数,则会限制长度
    $chunk = $collection->splice(2, 1);
    $chunk->all();
    // [3]
    $collection->all();
    // [1, 2, 4, 5]

    // 如果splice有第三个参数,则会把第三个参数放回原数组被切除的位置
    $chunk = $collection->splice(2, 1, [10, 11]);
    $chunk->all();
    // [3]
    $collection->all();
    // [1, 2, 10, 11, 4, 5]

    // split将原数组切分成几个部分
    $collection = collect([1, 2, 3, 4, 5]);
    $groups = $collection->split(3);
    $groups->all();
    // [[1, 2], [3, 4], [5]]

    // splitIn在把原数组切分成几部分时,尽量除最后一项前的元素填满
    $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
    $groups = $collection->splitIn(3);
    $groups->all();
    // [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]

    // sum求数组元素之和
    collect([1, 2, 3, 4, 5])->sum();
    // 15

    // sum可以指定某字段键进行求和
    $collection = collect([
        ['name' => 'JavaScript: The Good Parts', 'pages' => 176],
        ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
    ]);

    $collection->sum('pages');
    // 1272


    // sum可以传自定义的回调函数
    $collection = collect([
        ['name' => 'Chair', 'colors' => ['Black']],
        ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
        ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
    ]);
    $collection->sum(function ($product) {
        return count($product['colors']);
    });
    // 6


    // take相当于limit,与skip相对
    $collection = collect([0, 1, 2, 3, 4, 5]);
    $chunk = $collection->take(3);
    $chunk->all();
    // [0, 1, 2]

    // 如果参数为负数,则表示从末尾开始取
    $collection = collect([0, 1, 2, 3, 4, 5]);
    $chunk = $collection->take(-2);
    $chunk->all();
    // [4, 5]

    // takeUntil用法与skipUntil类似
    // takeWhile用法与skipWhile类似


    // tap可以在一个回调函数闭包中处理collection副本而不影响原数据,不中断链式操作
    collect([2, 4, 3, 1, 5])
        ->sort()
        ->tap(function ($collection) {
            Log::debug('Values after sorting', $collection->values()->all());
        })
        ->shift();
    // 1


    // times以第一个数字为次数,返回一个经回调函数处理的数组
    $collection = Collection::times(10, function ($number) {
        return $number * 9;
    });
    $collection->all();
    // [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]

    // toArray转为数组
    $collection = collect(['name' => 'Desk', 'price' => 200]);
    $collection->toArray();
    /*
        [
            ['name' => 'Desk', 'price' => 200],
        ]
    */

    // toJson转为JSON字符串
    $collection = collect(['name' => 'Desk', 'price' => 200]);
    $collection->toJson();
    // '{"name":"Desk", "price":200}'

    // transform跟map类似,但是会直接改变原collection
    $collection = collect([1, 2, 3, 4, 5]);
    $collection->transform(function ($item, $key) {
        return $item * 2;
    });
    $collection->all();
    // [2, 4, 6, 8, 10]

    // union计算并集,如果一个键在原数组中已经存在,则保留原键值
    $collection = collect([1 => ['a'], 2 => ['b']]);
    $union = $collection->union([3 => ['c'], 1 => ['d']]);
    $union->all();
    // [1 => ['a'], 2 => ['b'], 3 => ['c']]

    // unique返回所有独一无二不重复的元素,返回带key的结果;有重复值时取第一个,普通数组、关联数组类似
    // uniqueStrict是unique的严格版本
    $collection = collect([1, 1, 2, 2, 3, 4, 2]);
    $unique = $collection->unique();
    $unique->values()->all();
    // [1, 2, 3, 4]

    // unless与when相对,表示条件不成立时才执行回调函数
    $collection = collect([1, 2, 3]);
    $collection->unless(true, function ($collection) {
        return $collection->push(4);
    });
    $collection->unless(false, function ($collection) {
        return $collection->push(5);
    });
    $collection->all();
    // [1, 2, 3, 5]

    // unlessEmpty相当于whenNotEmpty
    // unlessNotEmpty相当于whenEmpty


    // unwrap得到collection中的数组
    Collection::unwrap(collect('John Doe'));
    // ['John Doe']

    Collection::unwrap(['John Doe']);
    // ['John Doe']

    Collection::unwrap('John Doe');
    // 'John Doe'

    // values返回一个新的collection,key将重置为连续整数,去掉原有关联数组的key
    $collection = collect([
        'key1'=>10,
        10 => ['product' => 'Desk', 'price' => 200],
        11 => ['product' => 'Desk', 'price' => 200],
    ]);

    $values = $collection->values();
    $re = $values->all();
    /*
        [
            0 => 10,
            1 => ['product' => 'Desk', 'price' => 200],
            2 => ['product' => 'Desk', 'price' => 200],
        ]
    */

    // when跟unless相对,表示条件满足时执行回调函数
    $collection = collect([1, 2, 3]);
    $collection->when(true, function ($collection) {
        return $collection->push(4);
    });
    $collection->when(false, function ($collection) {
        return $collection->push(5);
    });
    $collection->all();
    // [1, 2, 3, 4]

    // whenEmpty用法与when类似,当collection为空时执行
    // whenNotEmpty用法与when类似,当collection为非空时执行


    // where过滤出符合条件的元素
    // whereStrict是where的严格版本
    $collection = collect([
        ['product' => 'Desk', 'price' => 200],
        ['product' => 'Chair', 'price' => 100],
        ['product' => 'Bookcase', 'price' => 150],
        ['product' => 'Door', 'price' => 100],
    ]);
    $filtered = $collection->where('price', 100);
    $filtered->all();
    /*
        [
            ['product' => 'Chair', 'price' => 100],
            ['product' => 'Door', 'price' => 100],
        ]
    */


    // whereBetween过滤出符合在一定区间条件的元素
    // whereNotBetween是相反的语句
    $collection = collect([
        ['product' => 'Desk', 'price' => 200],
        ['product' => 'Chair', 'price' => 80],
        ['product' => 'Bookcase', 'price' => 150],
        ['product' => 'Pencil', 'price' => 30],
        ['product' => 'Door', 'price' => 100],
    ]);
    $filtered = $collection->whereBetween('price', [100, 200]);
    $filtered->all();
    /*
        [
            ['product' => 'Desk', 'price' => 200],
            ['product' => 'Bookcase', 'price' => 150],
            ['product' => 'Door', 'price' => 100],
        ]
    */

    // whereIn过滤中某一键值在指定数组中的元素
    // whereInStrict是whereIn的严格版本
    // whereNotIn
    // whereNotInStrict
    $collection = collect([
        ['product' => 'Desk', 'price' => 200],
        ['product' => 'Chair', 'price' => 100],
        ['product' => 'Bookcase', 'price' => 150],
        ['product' => 'Door', 'price' => 100],
    ]);
    $filtered = $collection->whereIn('price', [150, 200]);
    $filtered->all();
    /*
        [
            ['product' => 'Desk', 'price' => 200],
            ['product' => 'Bookcase', 'price' => 150],
        ]
    */

    // whereInstanceOf过滤是某一类实例的元素
    use App\Models\User;
    use App\Models\Post;

    $collection = collect([
        new User,
        new User,
        new Post,
    ]);
    $filtered = $collection->whereInstanceOf(User::class);
    $filtered->all();
    // [App\Models\User, App\Models\User]

    // whereNull返回相应键值为null的项
    // whereNotNull与之相反
    $collection = collect([
        ['name' => 'Desk'],
        ['name' => null],
        ['name' => 'Bookcase'],
    ]);
    $filtered = $collection->whereNull('name');
    $filtered->all();
    /*
        [
            ['name' => null],
        ]
    */


    // wrap将参数中的内容打包成数组
    use Illuminate\Support\Collection;

    $collection = Collection::wrap('John Doe');
    $collection->all();
    // ['John Doe']

    $collection = Collection::wrap(['John Doe']);
    $collection->all();
    // ['John Doe']

    $collection = Collection::wrap(collect('John Doe'));
    $collection->all();
    // ['John Doe']

    // zip将两个数组的元素对应构成新的数组
    $collection = collect(['Chair', 'Desk']);
    $zipped = $collection->zip([100, 200]);
    $zipped->all();
    // [['Chair', 100], ['Desk', 200]]


     

    展开全文
  • Particle Collection SKJ Bullet v1.5Particle Collection SKJ Bullet v1.5Particle Collection SKJ Bullet v1.5Particle Collection SKJ Bullet v1.5Particle Collection SKJ Bullet v1.5
  • Collection接口

    千次阅读 多人点赞 2022-04-11 11:36:15
    Collection接口

    目录

    Collection接口

    Collection接口实现类的特点

    Collection接口常用方法,以实现子类ArrayList来演示

    使用Iterator(迭代器)遍历元素

    增强for循环


    Collection接口

    Collection接口实现类的特点

    • Collection接口的实现子类可以存放多个元素,每个元素可以是Object

    • 有些Collection接口的实现类,可以存放重复的元素,有些不可以

    • 有些Collection接口的实现类,是有序的(List),有些不是有序的(Set)

    • Collection接口没有直接的实现子类,是通过它的子接口Set 和 List来实现的

    Collection接口常用方法,以实现子类ArrayList来演示

    • add():添加单个元素 
    public class Test02 {
        public static void main(String[] args) {
            Collection collection = new ArrayList();
            collection.add("jack");
            //实际上是List.add(new Integer(10))
            collection.add(10);
            collection.add(true);
            System.out.println(collection);
        }
    }

    watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP54y_6L-b5YyW54mI,size_16,color_FFFFFF,t_70,g_se,x_16

    • remove():删除指定元素

    • contains():查找元素是否存在

    • size():获取元素个数

    • get(int index):获取指定index位置上的元素

    • isEmpty():判断是否为空

    • clear():清空

    • addAll():添加多个元素

    • containsAll():查找多个元素是否都存在

    • removeAll():删除多个元素

    使用Iterator(迭代器)遍历元素

    • Iterator对象称为迭代器,主要用于遍历 Collection 集合中的元素

    • 所有实现了 Collection 接口的集合类都有一个 iterator() 方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器

    • Iterator 仅用于遍历集合,Iterator 本身并不存放对象

    • 快捷键生成 while 循环:itit

    • 显示所有快捷键的快捷键:ctrl+j

    迭代器的执行原理

    Iterator iterator = coll.iterator(); //得到一个集合迭代器

    // hasNext() :判断是否还有下一个元素

    while(Iterator.hasNext()) {

    //next():(1) 指针下移 (2) 将下移以后集合位置上的元素返回

    System.out.println(Iterator.next());

    }

    提示:在调用 iterator.next() 方法之前必须调用 iterator.hasNext() 进行检测。若不调用,且下一条记录无效,直接调用iterator.next()会抛出NoSuchElementException异常

    watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP54y_6L-b5YyW54mI,size_12,color_FFFFFF,t_70,g_se,x_16



    System.out.println(col);

    输出 col 集合时调用的是 Collection 的实现类 AbstractCollection 重写Object类的 toString() 方法

    System.out.println(obj);

    输出 obj 时调用的是Book 类中的 toString() 方法

    public class Demo03 {
        public static void main(String[] args) {
            Collection col = new ArrayList();
    
            col.add(new Book("三国演义","罗贯中",10.1));
            col.add(new Book("小李飞刀","古龙",5.1));
            col.add(new Book("三国演义","罗贯中",34.6));
    
            System.out.println(col);
    
            Iterator iterator = col.iterator();
            while (iterator.hasNext()) {
                Object obj = iterator.next();
                System.out.println(obj);
            }
        }
    }
    class Book{
        private String name;
        private String author;
        private double price;
    
        public Book(String name, String author, double price) {
            this.name = name;
            this.author = author;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Book{" +
                    "name='" + name + '\'' +
                    ", author='" + author + '\'' +
                    ", price=" + price +
                    '}';
        }
    }

    watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP54y_6L-b5YyW54mI,size_20,color_FFFFFF,t_70,g_se,x_16

    增强for循环

    • 增强for循环,可以代替 iterator 迭代器,特点:增强for循环就是简化版的iterator,底层仍然是迭代器,本质一样。**只能用来遍历集合或数组**。

    • 快捷键:集合或数组.for

    • 基本语法

    for(元素类型 元素名:集合名或数组名) {
    	访问元素
    }


    public class Demo04 {
        public static void main(String[] args) {
            Collection col = new ArrayList();
    
            col.add(new Book("三国演义","罗贯中",10.1));
            col.add(new Book("小李飞刀","古龙",5.1));
            col.add(new Book("三国演义","罗贯中",34.6));
    
            for (Object book:col) {
                System.out.println(book);
            }
            
        }
    }

    watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP54y_6L-b5YyW54mI,size_19,color_FFFFFF,t_70,g_se,x_16

    展开全文
  • mybatis使用collection嵌套查询

    千次阅读 2022-05-06 17:31:14
    只能先执行一条sql,然后根据返回的结果,再做一次sql关联查询,这个时候,使用mybatis的collection就可以实现。 如果第一次查询返回的是一个list集合,那么,后续的查询就是一个for循环。所以不使用collection的...

        在开发中,可能会遇到一对多的关系,这个时候,一条sql语句就难以胜任这个任务了。只能先执行一条sql,然后根据返回的结果,再做一次sql关联查询,这个时候,使用mybatis的collection就可以实现。

        如果第一次查询返回的是一个list集合,那么,后续的查询就是一个for循环。所以不使用collection的做法,在java语言中,就要分两次查询。一般而言,我们的列表查询都是分页查询,所以集合数据不会太大,第二次for循环查询效率还好。

        下面介绍mybatis使用collection嵌套查询解决这个问题。这里为了简单,以员工与部门的关系来做这个实验,其实员工与部门的关系还应该使用一个中间表来关联,这里只用两张表。

        表结构与数据如下所示:

        数据:

     

        这里采用maven构建springboot+mybatis-plus+mysql工程。

    <dependency>
          <groupId>com.baomidou</groupId>
          <artifactId>mybatis-plus-boot-starter</artifactId>
          <version>3.2.0</version>
        </dependency>
        
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
        </dependency>
        
        <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
        </dependency>

        定义的实体:

        员工信息:

    package com.xxx.springboot.mybatis.domain;
    
    import java.util.List;
    
    import com.baomidou.mybatisplus.annotation.TableName;
    
    import lombok.Data;
    
    @Data
    @TableName("xx_emp")
    public class Employee {
    	private Integer id ;
    	private String name ;
    	private int age ;
    	
    	private List<Department> depts ;
    }

        部门信息 

    package com.xxx.springboot.mybatis.domain;
    
    import com.baomidou.mybatisplus.annotation.TableName;
    
    import lombok.Data;
    
    @Data
    @TableName("xx_dept")
    public class Department {
    	
    	private Integer id ;
    	
    	private String name ;
    	
    	private Integer userId ;
    
    }
    

        Mapper接口

    package com.xxx.springboot.mybatis.mapper;
    
    import org.apache.ibatis.annotations.Mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.xxx.springboot.mybatis.domain.Department;
    import com.xxx.springboot.mybatis.domain.Employee;
    @Mapper
    public interface EmpMapper extends BaseMapper<Employee>{
    	Employee queryByName(String name);
    	Department queryByUserId(Integer userId);
    }

        EmpMapper.xml配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.xxx.springboot.mybatis.mapper.EmpMapper">
      <resultMap id="empMap" type="com.xxx.springboot.mybatis.domain.Employee" >
        <id column="id" property="id" />
        <result column="name" property="name" />
        <result column="age" property="age" />
        <collection property="depts" javaType="java.util.ArrayList" ofType="com.xxx.springboot.mybatis.domain.Department"
        select="com.xxx.springboot.mybatis.mapper.EmpMapper.queryByUserId" column="{userId=id}"></collection>
      </resultMap>
      <resultMap id="deptMap" type="com.xxx.springboot.mybatis.domain.Department">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="user_id" property="userId"/>
      </resultMap>
      <select id="queryByName" resultMap="empMap">
         SELECT
         *
         FROM xx_emp
         WHERE name  = #{name}
      </select>
      <select id="queryByUserId" resultMap="deptMap">
        SELECT
        *
        FROM xx_dept
        WHERE user_id = #{userId}
      </select>
    </mapper>

        测试类:

    package com.xxx.springboot;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    import com.xxx.springboot.mybatis.domain.Employee;
    import com.xxx.springboot.mybatis.mapper.EmpMapper;
    @RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class MyBatisTest {
    	
    	@Autowired
    	private EmpMapper empMapper;
    	
    
    	@Test
    	public void testEmpQuery() {
    		Employee emp = empMapper.queryByName("aa");
    		System.out.println(emp);
    	}
    }
    

        运行单元测试,打印信息如下:

     

        这个程序,在第一次根据名称查询员工信息之后,返回id=1,name=aa,age=18,接着,根据id=1 查询了部门表,其实这里的id=1,作为参数传入部门表中,就成了user_id对应的参数,然后就查询出了两个部门记录id=1,id=3,最后打印的员工信息里面,depts就是一个集合。

        使用这个嵌套查询,需要注意的是collection有如下属性:

    •     property 实体中对应的属性,这里是depts。
    •     javaType 实体属性的类型,这里是一个集合,所以使用java.util.ArrayList表示。
    •     ofType 集合范型中的类型,这里是部门信息,对应java类Department
    •     select  嵌套子查询的ID
    •     column 这里最关键,也比较难理解,默认一个参数,可以直接写column = "id",最后根据参数类型匹配。这里其实是传入子查询中的参数,也就是子查询的关联属性user_id对应的参数值,在collection这里就是主sql中查询出来的列值,如果这里id有了别名,比如emp_id,这里就应该写column = "emp_id"。还有一种写法,通过大括号来表示,这种写法可以传入多个参数(多个参数用逗号隔开)。对于本示例而言,正确的写法就是column={userId=id},userId对应  queryByUserId查询语句中 SELECT * FROM xx_dept WHERE user_id = #{userId}  参数userId。id就是主sql查询出来的列id值,就是xx_emp对应的id列值。

        我个人在使用collection的时候,大概明白这种嵌套查询的作用,但是就是不明白,怎么传递参数,后来看过一些例子,原来主要点就在column属性这里。

    展开全文
  • Apache Flume, Distributed Log Collection for Hadoop,2015 第二版,Packt Publishing
  • The Garbage Collection Handbook The Art of Automatic Memory Management, Jones, Hosking, Moss, 2012
  • mybatis中collection嵌套使用

    千次阅读 2019-11-04 09:12:48
    mybatis中collection嵌套使用 @author 无忧少年 @createTime 2019/10/25 1. 问题 刚完成的项目,突然又改了需求,在为了不大改动原先代码的原则下,得使用mybatis的resultMap中的collection再嵌套一层collection...
  • Collection接口常用操作【数据结构】

    多人点赞 热门讨论 2021-09-19 11:56:41
    Collection 接口概念: collection 即单列集合 用来存储管理一组对象 objects,这些对象一般被称为元素 elements,统一定义了一套单列集合的接口 Collection 常用操作: 1.创建 Collection对象: import java.util....
  • mybatis 中 foreach collection 的用法

    千次阅读 2021-12-19 00:32:57
    foreach元素的属性主要有 item,index,collection,open,separator,close。属性说明item表示集合中每一个元素进行迭代时的别名,index指 定...
  • 添加到 Meteor.Collection.prototype 的实用程序集合 用法 Collection.Utils.isDate(obj) Collection.Utils.isNumeric(name, value) Collection.Utils.isValidDate(obj) Collection.Utils.validateParams(params) ...
  • 今天先来介绍Java集合中的老大类Collection接口,说说Collection、Iterable和Iterator三个接口之间的关系,为什么要封装一个Collection接口?我们今天来讨论讨论 目录 为什么定义出一个Collection接口? Iterable...
  • 总结collection

    万次阅读 2021-10-22 10:53:04
    1.collection collect为存储数据的集合类的顶级接口。所以不能实例化,只能实现collection,长度可变,集合为引用类型。 list和set是collection的实现类 2.list list有序,可以重复,可以为空,实现类有ArrayList、...
  • JDK1.8源码学习--util包(Collection)

    千次阅读 2022-01-12 11:58:13
    前言 月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂) 央是一片海洋,海乃百川,代表着一块海绵(吸纳...一.Collection的作用: 直接看源码注释(我的翻译可能不太准,如果道友们有更棒的理解,可以留言或者私信) ...
  • ResultMap中association和collection的区别

    千次阅读 2020-10-20 19:56:55
    mybatis mapper配置文件结果集映射resultMap中collection属性(一对多关系结果集映射)和association属性(多对一关系结果集映射)理解: collection的使用有两种resultMap和select,必须手动指定一种 association的使用...
  • python--模块之collection

    千次阅读 2020-12-24 19:09:19
    collection模块:在内置数据类型(dict、list、set、tuple)的基础上,collections模块还提供了几个额外的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等。1:namedtuple生成可以使用名字来访问元素...
  • MyBatis中的collection两种常用使用方法 码云MybatisDemo: 用来学习springboot整合mybatis (gitee.com) collection主要是应对表关系是一对多的情况 查询的时候,用到联表去查询 接下来的小案例包括:市,学校,医院...
  • Collection集合常用API Collection集合的遍历方式 方式一:迭代器 方式二:foreach/增强for循环 方式三:lambda表达式 Collection集合存储自定义类型的对象 List系列集合 List集合特点、特有API List集合的遍历方式...
  • Java中的collection集合类型总结

    千次阅读 2021-01-17 08:00:37
    // Collection的API abstract boolean add(E object) abstract boolean addAll(Collection collection) abstract void clear() abstract boolean contains(Object object) abstract boolean containsAll(Collection...
  • Java基础系列30-单列 Collection集合

    万次阅读 2021-08-31 11:19:58
    集合的概述1.1 为什么会出现集合类1.2 集合类体系结构图二.Collection集合2.1 Collection集合入门2.2 Collection集合的成员方法2.3 Collection集合的遍历2.4 集合使用步骤图解三. List集合3.1 List集合特点3.2 List...
  • Collection 接口详解

    千次阅读 2021-04-27 14:50:34
    Collection是所有单列集合的父接口 多了不说先上图大家看一下集合的上下属关系 在Collection中定义了单列集合(List和Set)通用的一些方法,这些方法可用于操作所有的单列集合。方法如下: public boolean add(E e) ...
  • ResultMap collection多层嵌套使用

    千次阅读 热门讨论 2019-12-04 23:46:37
    ResultMap collection多层嵌套使用 ResultMap介绍 在Mybatis使用中,ResultMap是最复杂的一种结构,也是功能最强大的结构之一。通过ResultMap能够将复杂的1对多的结果集映射到一个实体当中去,可以借助Mybatis来将...
  • Java集合中Collection和Map

    千次阅读 2020-12-05 20:15:13
    两种:collection和map,其中collection分为set和List。 Collection ├List ├LinkedList ├ArrayList ├Vector ├Stack ├-Set ├HashSet ├LinkedSet └ TreeSet Map  ├Hashtable  ├Ha
  • mybatis的collection的使用

    千次阅读 2022-04-06 16:13:29
    mybatis的collection的使用 方法: 1:主查询返回的map: 2:子查询返回对象的map 3:主查询sql语句 4:子查询语句 5:使用主查询返回的结果作为子查询的条件字段去子查询查询 6:接收数据对象,主对象中包含子...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 861,230
精华内容 344,492
关键字:

collection

友情链接: abei.rar