精华内容
下载资源
问答
  • 元素(成员):组成集合的每个事物。 图 1 集合的组成及性质 集合由0个或多个元素构成,元素分为两种:基本元素和集合 (不能是这个集合自身)。所有元素都是集合的集合叫做集族。 集合的基:有限集A的元素个...

    集合:把一些确定的,可以区分的事物汇集到一起组成的一个整体。

    元素(成员):组成集合的每个事物。

     


    1 集合的组成及性质

    集合由0个或多个元素构成,元素分为两种:基本元素集合 (不能是这个集合自身)。所有元素都是集合的集合叫做集族。

    集合的:有限集A的元素个数称为有限集A的基,记为|A|。

     

    集合的特点通过集合中元素的性质体现,集合中元素的性质如下:

    1. 元素的确定性。给定了一个集合,确定了集合的构造,即这个集合由哪些元素组成,并且对任意一个元素都能 判定它是否是这个集合的元素。
    2. 元素的互异性。集合中的元素必须是彼此不相同的。如果一个元素在集合中多次出现应该认为是一个元素。
    3. 元素的无序性。集合中的元素不规定顺序。元素相同但次序不同的集合应该视为同一个集合。
    4.  元素的任意性。集合的元素可以是任何类型的事物。

     

    参考文献:

    [1] 俞瑞钊, 陈亮主编. 集合初步. 杭州: 浙江大学出版社, 2007.12.

    转载于:https://www.cnblogs.com/6DAN_HUST/archive/2009/09/14/1566076.html

    展开全文
  • 集合

    千次阅读 2015-08-25 19:05:13
    一、集合类概述  java.util包中提供了一些集合类,这些集合类又被称为容器。数组也是一种容器,但集合类与数组的不同之处在于数组的长度是固定的,而集合的长度是可变的;数组用来存放基本类型的数据,集合用来...
    一、集合类概述
        java.util包中提供了一些集合类,这些集合类又被称为容器。数组也是一种容器,但集合类与数组的不同之处在于数组的长度是固定的,而集合的长度是可变的;数组用来存放基本类型的数据,集合用来存放对象的引用。常用的集合有List集合、Set集合和Map集合,其中List与Set继承了Collections接口。各接口还提供了不同的实现类。
        这些类的继承关系如下:
    Java.lang.Object
    |——Collection
    |——List:元素是有序的,元素可以重复,因为该集合体系有索引。
          |——ArrayList:底层的数据结构使用的是数组数据结构,查询快增删慢,线程不同步。
          |——LinkedList:底层的数据数据结构是链表数据结构,查询慢增删快。
          |——Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
    |——Set:元素是无序的(存入和取出的顺序不一定一致),元素不可以重复
          |——HashSet:底层数据结构是哈希表。HashSet通过元素的两个方法,hashCode和equals来保证 元素的 唯一性。如果元素的hasnCode相同,才会判断 equals是否为true。如果元素的hashCode值不同,不会 调用equals。 注意:对于判断元素是否存在以及删除等操作,依赖的方 法是元素的hashCode和equals方法。ArrayList依赖的方 法只有equals。
         |——TreeSet:以对Set集合中的元素进行排序。排序时,当主要条件 相同,一定要比较次要条件。底层 数据结构是二叉树,保 证元素唯一性的依据是compareTo方法return 0。
    |——Map
    |——HashMap
    |——TreeMap
    二、Collection接口
        Collection接口是层次结构中的根接口。构成Collection的单位称为元素。Collection接口通常不能直接使用,但该接口提供了添加元素、删除元素、管理数据的方法。由于List接口与Set接口都继承了Collection接口,因此这些方法对List集合与Set集合是通用的。常用方法如下:
    add(E e):将指定的对象添加到集合中;
    remove(Object o):将指定的对象从该集合中删除;
    isEmpty():返回boolean值,用于判断当前集合是否为空;
    iterator():返回在此Collectionn的元素上进行迭代的迭代器,用于遍历集合中的对象;
        注意: 1.add方法的参数类型是Object,以便于接受任意类型对象。
              2.集合中存储的都是对象的引用(地址)。
    三、迭代器
        获取集合中的元素用迭代器
    ArrayList al=new ArrayList();
    al.add("java01");
    al.add("java02");
    Iterator it=al.iterator();
        Iterator 是一个接口,接口型引用指向自己的子类对象,而这个子类对象是由集合中的iterator()方法获取的。it.hasNext()方法用来判断集合中是否仍有元素。it.next()方法可以获取集合中的下一个元素。迭代器其实就是集合的取出元素的方式。
        由于每一种容器的数据结构不同,所以将取出方式iterator()方法定义在集合的内部。又因为都有判断和取出两个动作,所以将这些共性内容抽取为Iterator接口。
        迭代器中不能使用集合的方法进行操作,只能用迭代器自身的方法进行操作。但Iterator只能进行判断取出删除的操作。如果想进行其他操作,如添加修改,就需要使用其子接口:ListIterator。 该接口只能通过List集合的listIterator方法获取。
    四、List集合
         List集合特有的迭代器:ListIterator是Iterator的子接口。在迭代时,不可以通过集合对象的方法操作集合中的元素。
    1.List接口
        List接口继承了Collection接口,因此包含Collection中的所有方法,此外List接口还定义了以下两个非常重要的方法:
    get(int index):或得指定索引位置的元素。
    set(int index,Object obj):将集合中指定索引位置的对象修改为指定的对象。
    2.List接口的实现类
        List接口的常用实现类有ArrayList与LinkedList:
        ArrayList类实现了可变的数组,允许保存所有元素,包括null,并可以根据索引位置对集合进行快速的随机访问;缺点是向指定的索引位置插入对象或删除对象的速度较慢。
        ArrayList判断对象是否相同,用的是equals方法,用对象的equals方法和另一个对象比较。自己定义的类继承基类的equals方法,而基类的方法比较的是地址值!因此应该重写equals方法!
        List集合判断元素是否相同依据的是元素的Equals方法!
        字符串中有自己的equals方法!
        LinkedList类采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象,需要向集合中插入删除对象时,使用LinkedList类实现的List集合的效率较高;但对于随机访问集合中的对象,使用LinkedList类实现List集合的效率低。
        LinkedList的特有方法:
    addFirst();
    addLast();
    添加元素。
    getFirst();
    getLast();
    获取元素,但不删除元素。
    removeFirst();
    removeLast();
    获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException。
        在JDK1.6出现了替代方法。
    offerFirst();
    offerLast();
    peekFirst();
    peekLast();
    获取元素,但不删除元素。如果集合中没有元素,返回null;
    pollFirst();
    pollLast();
    获取元素,并删除元素。如果集合中没有元素,返回null;
    五、Set集合
         Set集合的功能和Collection的功能是一致的。
        Set集合中的对象不按特定的方式排序,只是简单的把对象加入集合中,但Set集合中不能包含重复对象。Set集合由Set接口和Set接口的实现类组成。Set接口继承了Collection接口,因此包含Collection接口中的所有方法。
        Set接口常用的两个实现类有HashSet类与TreeSet类。
        HashSet通过元素的两个方法,hashCode和equals来保证元素的唯一性。如果元素的hasnCode相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
        TreeSet类不仅实现了Set接口,还实现了java.util.SortedSet接口。因此,TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序,也可以按照指定比较器递增排序,即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。
       Comparable接口强制让实现它的类具备比较性方法为compareTo(T O)。
        TreeSet:可以对Set集合中的元素进行排序。排序时,当主要条件相同,一定要比较次要条件。底层数据结构是二叉树,保证元素唯一性的依据是compareTo方法return 0。
        往TreeSet里存储的元素必须具有比较性!
        TreeSet排序的第一种方式:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也称为元素的自然顺序,或者叫做默认顺序。
        TreeSet排序的第二种方式:当元素自身不具备比较性时,或者具备的比较性不是所需要的,这时就需要让集合自身具备比较性。在集合初始化时就有了比较方式。定义一个类,实现Comparator接口,覆盖compare方法。
        定义比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
        当两种排序方式都存在时,以比较器为主。
    六、泛型
    泛型:  JDK1.5版本以后出现的新特性,用于解决安全问题,是一个类型安全机制。
        好处:
    1.将运行时期出现的问题转ClassCastException,移到了编译时期,方便于程序员解决问题,让运行时期问题减少,安全。
    2.避免了强制转换的麻烦。
        泛型格式:通过<>来定义要操作的引用数据类型。
        在使用Java提供的对象时,什么时候写泛型: 通常在集合框架中很常见,只要见到<>就要定义泛型。
        其实<>就是用来接受类型的, 当使用集合时,将集合中要存储的数据类型作为参数传递到<>即可。
    泛型类:
        当类中要操作的引用数据类型不确定的时候,早期定义Object来完成宽展,现在定义泛型来完成扩展。
    泛型方法:
        泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象要明确要操作的具体的类型后,所有要操作的类型就一定固定了。 为了让不同的方法可以操作不同类型,而且类型还不确定,那么可以将泛型定义在方法上。
    静态方法泛型:
        特殊之处:静态方法不可以访问类上定义的泛型,如果静态方法操作的引用数据类型不确定,可以将泛型定义在方法上。
        泛型定义方法时,要放在返回类型前面。
        泛型限定:用于泛型扩展。
     ?:通配符,也可以理解为占位符。
    <? extends E>:可以接受E类型或者E类型的子类型。上限
    <? super E>:可以接受E类型或者E类型的父类型。下限
    七、Map
    Map集合:该集合存储键值对,一对一对往里存,而且要保证键的唯一性。
    1.添加
    put(K key V value)
    添加元素:如果添加元素时有相同的键,那么后添加的值会覆盖并返回原有键对应值。
    putAll(Map<?extends K,?extends V>m)
    2.删除
    clear()
    remove(Object key)
    3.判断
    containsKey(Object key)
    containsKey(Object value)
    isEmpty()
    4.获取
    get(Object key)
    可以通过get方法的返回值来判断一个键是否存在。通过返回null判断。
    size()
    values()
    获取map集合中所有的值
    entrySet()
    keySet()

    Map
    |——Hashtable:底层是哈希表数据结构,不可以存入null键和null值。该集合                是线程同步的。JDK1.0,效率低。
    |——HashMap:底层是哈希表数据结构,允许使用null键和null值,该集合是不              同步的。JDK1.2,效率高
    |——TressMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的               键进行排序。

    和Set很像,其实Set底层就是使用了Map集合。
    Map 集合的两种取出方式:
        1.Set<k> keySet:将map中所有的键存入到Set集合,因为Set集合具备迭代器,所以可以通过迭代方式取出所有的键,然后用get方法获取每一个键对应的值。
        Map集合的取出原理:将map集合转成set集合,再通过迭代器取出。
        2.Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中。而这个关系的数据类型就是Map.Entry。
        Map.Entry 其实Entry也是一个接口,它是Map接口中的一个(静态)内部接口。
        当数据之间存在着映射关系时,就要先想到map集合。
    Map扩展知识:
        map集合被使用是因为具备映射关系。
    八、其他
    1. Collections集合框架的工具类

    Collections.sort(list);
    Collections.sort(list,new 比较器);

    Collections.max(list);
    Collections.max(list,new 比较器);

    int index=Collections.binarySearch(list,"aaa",new 比较器);
    没有查找到返回(-插入点-1)

    Collections.fill(list,"pp");
    将list集合中的所有元素全部替换成指定元素"pp";

    Collections.replaceAll(list,"aaa","pp");
    将list集合中所有的"aaa"替换成"pp";

    Collections.reverse(list);
    翻转list集合中的元素;

    Collections.reverseOrder();
    返回的是一个比较器;
    Collections.reverseOrder(new 比较器);
    将已有的比较器逆转;

    Collections.SynList(list);
    返回指定列表的同步列表
    让非同步的集合变成同步集合

    Collections.swap(list,1,2);
    将集合中角标为1和2的两个元素交换位置

    Collections.shuffle(list);
    将集合中所有元素重新随机排放

    2.Arrays:用于操作数组的工具类。里面都是静态方法。
        List<String> list=Arrays.asList(arr): 将数组变成list集合
        把数组变成list集合的好处:可以使用集合的思想和方法来操作数组中的元素。
        注意:将数组变成集合,不可以使用集合中的增删方法,因为数组的长度是固定的。如果增删,会抛出异常。
        如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素;如果数组中的元素都是基本数据类型,那么会将该数组,作为集合中的元素存在。
        集合转成数组: Collection接口中的toArray方法。
    ArrayList<String> al=new ArrayList<String>();
    al.add("abc1");
    al.add("abc2");
    al.add("abc3");
    String[] arr=al.toArray(new String[al.size()]);
         指定类型的数组到底要定义多长: 当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组,长度为集合的size。当指定类型的数字长度大于了集合的size,就不会新创建数组,而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
        将集合变数组是 为了限定对元素的操作。
        
    3.高级for循环(foreach语句)
    格式:
    for(数据类型 变量名:被遍历的集合(Collection)或者数组)
    {
    }

    对集合进行遍历:只能获取元素,但不能对集合进行操作。
    迭代器除了遍历,还可以进行remove集合中元素的动作。
    如果是使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。

    传统for循环和高级for循环的区别:
    高级for循环有一个局限性,必须有被遍历的目标。
    建议在遍历数组的时候还是使用传统for循环,因为传统for循环可以定义角标。

    4.可变参数:int...arr
    其实就是上一种数组参数的简写形式。不用每次都手动的建立数组对象,只要将要操作的元素作为参数传递即可。隐式的将这些参数封装成了数组。
    方法的可变参数在使用时,可变参数一定要定义在参数列表最后面。

    5.静态导入
    import static java.lang.System.*;导入了System类中所有静态成员。
    import static java.util.*;导入的是Arrays这个类中的所有静态成员。
    导入后面不跟静态时,导入的都是类。
    导入后面跟静态的时候,导入的是某一个类中所有的静态成员。
    StaticImport 静态导入:
    当类名重名时,需要指定具体的包名。
    当方法重名时,需要指定具备所属的对象或者类
    展开全文
  • 因为iteratorstatus对象并不是ognl的根对象是以接见须要加上 #接见如下例子: ”{’dd’,""bb’,""cc’}” status=”st”> ”#st.odd”> ”#st.index”/> </s:if> </s:iterator> iterator...
    直接把list用request传到jsp页面 
    
    <s:iterator var="u" value="#request.users">
    <tr>
    <td><s:property value="#u.uid"/></td>
    <td>¥{u.uname}</td>
    <td><s:property value="#u.upass"/></td>
    <td><a οnclick="return isDel()" href="<s:url action="Del"><s:param name="user.uid" value="#u.uid"/></s:url>">删除</a></td>
    <td><a href="<s:url action="To"><s:param name="user.uid" value="#u.uid"/></s:url>">编辑</a></td>
    </tr>
    </s:iterator>

    <s:iterator />可以遍历 数据栈里面的任何数组,凑集等等

    在应用这个标签的时辰有三个属性值得我们存眷
    1. value属性:可选的属性,value属性是指一个被迭代的凑集,应用ognl表达式指定,若是为空的话默认就是ValueStack栈顶的凑集.
    2.id属性:可选属性, 是指凑集元素的id
    3.status属性:可选属性,该属性在迭代时会产生一个IteratorStatus对象,该对象可以断定当前元素的地位,包含了以部属性办法:

    int getCount(); 迭代元素个数
    int getIndex(); 迭代元素当前索引
    boolean getFirst(); 是否为第一个
    boolean getEven(); 是否为偶
    boolean getLast(); 是否最后一个
    bolean getOdd(); 是否为奇

    因为iteratorstatus对象并不是ognl的根对象是以接见须要加上 #接见如下例子:
    <s:iterator value=”{’dd’,""bb’,""cc’}” status=”st”>
    <s:if test=”#st.odd”>
    <s:property value=”#st.index”/>
    </s:if>
    </s:iterator>

    iterator也可以迭代map对象,map对象中有几对key-value 就迭代几次,分别应用
    <s:property value=”key”/>
    <s:property value=”value”/>

    iterator也可以迭代简单的数组凑集
    <s:iterator value="collection1" status="status">
    <s:property value="collection1[#status.index][0]"/>
    <s:property value="collection1[#status.index][1]"/>
    </s:iterator>
    申明:[#status.index][?]" ,指导遍历数组指定的脚标元素,
    若是你不知道数组的长度呢?
    //以下是遍历数组每一个元素
    <s:iterator value="total" status="stuts">
    <s:iterator value="total[#stuts.index]" >
    <s:property/><br>
    </s:iterator>
    </s:iterator>
    //直接应用<s:property/>也可以打印出每一个数组内容

    ***********iterator的value******************
    1.若是须要引用valueStack中的值,须要应用如许的情势。
    <s:iterator value="#userList" /> //userList在action项目组被保存在Request中,所以应用#加属性名来引用值。

    2.若是凑集的值是经由过程action的办法,假设我们的action中有一个getListMenu办法,返回一个List凑集。
    我们可以应用如下的情势来引用这个凑集,并用s:iterator来输出。
    <s:iterator value="listMenu" />

    3.iterator的value应用定义好的体式格式,如:
    <s:iterator value="{1,2,3,4}" /> //如许跌代输出的值就是1.2.3.4这四个值。

    **************iterator的各个对象属性输出********************************
    iterator中输出具体值,若是,在上方我们的list中的对象,有两个属性,都是String类型,一个是name,一个是url
    1. <s:property value="name" /> //如许我们将可以输出跌代对象的name属性值。

    2. 若是我们应用<s:url />来将跳转过后的url进行处理惩罚,该如何来做?
    <s:url value="%{url}"/> //%{}ognl的表达式,如许的值可以或许将url的值进行<s:url/>的处理惩罚.实际上就是转为绝对路径。如许,我们就可以对于一些因跳转换产生的路径题目.原因:因为<s:iteratotr />今后,当前的对象应当就在ValueStack顶部了,如许当时的url实际上就是对象的url属性了

    C:应用ognl输出对应的值。
    <s:textfield name="loginName" value="%{#request.loginNames}"/>
    应用此表达式,会生成一个文本框,并且,若是request.attribute中有loginNames属性,将会做为些文本框的默认值。
    若是只应用#request.loginNames在struts2的标签内部,是不会显示任何值的,注不测面加上的%{}附号,才会被正常的应用。

    若是如EL说话一样直接输出文件,如在一个<a></a>之间的innerHTML文本为#request.loginNames的值,我们只要应用:<s:property value="#request.loginNames" />使可以正常应用!

    重视:

    1.¥{}是EL说话的 %{}如许的情势是ognl表达式说话的,在struts2的标签内部,应用%{}如许的情势,在标签外部可以应用¥{}EL说话的体式格式。若是在struts2的标签内部应用¥{}如许的体式格式,会呈现以下的错误提示:

    According to TLD or attribute directive in tag file, attribute value does not accept any expressions

    2. 很多时辰,我们应用struts2的一些标签,属性是须要接管凑集的,若是凑集是保存在 request,session,或者是值栈(非根对象的栈顶),可以应用#变量名的体式格式,若是获取的值是在Action中经由过程特定的办法来获取,就须要应用如 value="userList"如许的体式格式,只是去掉了前面的#。

    以下几个简单的例子:
    <s:iterator/> 标签有3个属性:
    value:被迭代的凑集
    id :指定凑集里面的元素的id
    status 迭代元素的索引

    1:jsp页面定义元素写法 数组或list

    1. <s:iterator value="{""1"",""2"",""3"",""4"",""5""}" id=""number"">
    2. <s:property value=""number""/>A
    3. </s:iterator>

    打印成果为: 1A2A3A4A5A

    2:索引的用法
    若是指定了status,每次的迭代数据都有IteratorStatus的实例,它有以下几个办法
    int getCount()返回当前迭代了几个元素
    int getIndex()返回当前元素索引
    boolean isEven()当然的索引是否偶数
    boolean isFirst()当前是否第一个元素
    boolean isLast()
    boolean isOdd()当前元素索引是否奇数

    <s:iterator value="{""a"",""b"",""c""}" id=""char"" status=""st"">
    <s:if test="#st.Even">
    如今的索引是奇数为:<s:property value=""#st.index""/>
    </s:if>
    当前元素值:<s:property value=""char""/>
    </s:iterator>

    3:遍历map
    value可以直接定义为:

    1. value="#{"1":"a","2":"b"}"

    每个元素以都逗号隔开。元素之间的key和value 冒号隔开
    value也可所以数据栈里面的java.util.Map对象
    遍历写法如下:

    <s:iterator value="map" id="id" status="st">
    key : <s:property value=""key""/>
    value:<s:property vlaue=""value""/>
    </s:iterator>

    当然key 和value 都可以使java 的 Object

    3:遍历数据栈.简单的List类,
    List<Attr>
    class Attr{String attrName;String getAttrName(){return "123";}}

    1. <s:iterator value="label" id="id">
    2. <s:property value="#id.attrName" />
    3. </s:iterator>

    当然value 还可以写成 value="%{label}" label可以有.操纵
    label的属性List 可以写成value="%{label.list}" 相当于:getLabel().getList();

    4:遍历2个list;
    List<AttrName> attrN {color,size,style}
    List<AttrValue> attrV {red,20,gay}
    这2个list的元素是一一对应的,一个attrN对应一个attrV

    <s:iterator value="%{attrN }" id="id" status="status">
    index is : <s:property value=""status.index""/>
    attrName is : <s:property value=""id""/> or <s:property value=""%{id}""/>
    attrName is : <s:property value=""%{attrV[#status.index]}""/>
    </s:iterator>
    展开全文
  • Python 集合

    万次阅读 多人点赞 2017-05-23 19:09:31
    集合是基本的数学概念,它是集合论的研究对象,指具有某种特定性质的事物的总体,(在最原始的集合论─朴素集合论─中的定义,集合就是“一堆东西”。)集合里的事物(“东西”),叫作元素。若然 x 是集合 A 的...

    简述

    数学上有一个基础概念 -集合,上高一的时候学过。集合的作用大吗?高考必考,你说呢?

    关于集合,维基百科这样描述:

    集合是基本的数学概念,它是集合论的研究对象,指具有某种特定性质的事物的总体,(在最原始的集合论─朴素集合论─中的定义,集合就是“一堆东西”。)集合里的事物(“东西”),叫作元素。若然 x 是集合 A 的元素,记作 x ∈ A。

    在 Python 中,集合分为两类:

    • set:可变集合
    • frozenset:不可变集合

    set 可以原地修改,或者说是可变的,也可以说是 unhashable(不可哈希)的。

    frozenset,顾名思义,是一个被“冻结”的集合,不能原地修改,是 hashable(可哈希)的。

    | 版权声明:一去、二三里,未经博主允许不得转载。

    集合

    在 Python 中,集合由内置的 set 类型定义。

    要创建集合,需要将所有项(元素)放在花括号({})内,以逗号(,)分隔。

    >>> s = {'P', 'y', 't', 'h', 'o', 'n'}
    >>> type(s)
    <class 'set'>

    集合可以有任意数量的元素,它们可以是不同的类型(例如:数字、元组、字符串等)。但是,集合不能有可变元素(例如:列表、集合或字典)。

    >>> s = {1, 2, 3}  # 整形的集合
    >>> 
    >>> s = {1.0, 'Python', (1, 2, 3)}  # 混合类型的集合
    >>> 
    >>> s = set(['P', 'y'])  # 从列表创建
    >>>
    >>> s = {1, 2, [3, 4]}  # 不能有可变元素
    ...
    TypeError: unhashable type: 'list'

    创建空集合比较特殊。在 Python 中,空花括号({})用于创建空字典。要创建一个没有任何元素的集合,使用 set() 函数(不要包含任何参数)。

    >>> d = {}  # 空字典
    >>> type(d)
    <class 'dict'>
    >>> 
    >>> s = set()  # 空集合
    >>> type(s)
    <class 'set'>

    集合的特性

    子曰:“温故而知新,可以为师矣。”
    –《论语》

    回顾数学相关知识,集合有以下特性:

    • 无序性:一个集合中,每个元素的地位都是相同的,元素之间是无序的。
      集合上可以定义序关系,定义了序关系后,元素之间就可以按照序关系排序。但就集合本身的特性而言,元素之间没有必然的序。
    • 互异性:一个集合中,任何两个元素都认为是不相同的,即每个元素只能出现一次。
      有时需要对同一元素出现多次的情形进行刻画,可以使用多重集,其中的元素允许出现多次。
    • 确定性:给定一个集合,任给一个元素,该元素或者属于或者不属于该集合,二者必居其一,不允许有模棱两可的情况出现。

    当然,Python 中的集合也具备这些特性:

    # 无序性
    >>> s = set('Python')
    >>> s
    {'y', 'n', 'h', 'o', 'P', 't'}
    >>>
    >>> s[0]  # 不支持索引
    ...
    TypeError: 'set' object does not support indexing
    
    # 互异性
    >>> s = set('Hello')
    >>> s
    {'e', 'H', 'l', 'o'}
    
    # 确定性
    >>> 'l' in s
    True
    >>> 
    >>> 'P' not in s
    True

    注意: 由于集合是无序的,所以索引没有任何意义。也就是说,无法使用索引或切片访问或更改集合元素。

    集合运算

    集合之间也可进行数学集合运算(例如:并集、交集等),可用相应的操作符或方法来实现。

    考虑 A、B 两个集合,进行以下操作。

    >>> A = set('abcd')
    >>> B = set('cdef')

    子集

    子集,为某个集合中一部分的集合,故亦称部分集合。

    使用操作符 < 执行子集操作,同样地,也可使用方法 issubset() 完成。

    >>> C = set('ab')
    >>> 
    >>> C < A
    True
    >>> 
    >>> C < B
    False
    >>> 
    >>> C.issubset(A)
    True

    并集

    一组集合的并集是这些集合的所有元素构成的集合,而不包含其他元素。

    使用操作符 | 执行并集操作,同样地,也可使用方法 union() 完成。

    >>> A | B
    {'e', 'f', 'd', 'c', 'b', 'a'}
    >>> 
    >>> A.union(B)
    {'e', 'f', 'd', 'c', 'b', 'a'}

    交集

    两个集合 A 和 B 的交集是含有所有既属于 A 又属于 B 的元素,而没有其他元素的集合。

    使用 & 操作符执行交集操作,同样地,也可使用方法 intersection() 完成。

    >>> A & B
    {'d', 'c'}
    >>> 
    >>> A.intersection(B)
    {'d', 'c'}

    差集

    A 与 B 的差集是所有属于 A 且不属于 B 的元素构成的集合

    使用操作符 - 执行差集操作,同样地,也可使用方法 difference() 完成。

    >>> A - B
    {'b', 'a'}
    >>> 
    >>> A.difference(B)
    {'b', 'a'}

    对称差

    两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合。

    使用 ^ 操作符执行差集操作,同样地,也可使用方法 symmetric_difference() 完成。

    >>> A ^ B
    {'b', 'e', 'f', 'a'}
    >>> 
    >>> A.symmetric_difference(B)
    {'b', 'e', 'f', 'a'}

    更改集合

    虽然集合不能有可变元素,但是集合本身是可变的。也就是说,可以添加或删除其中的元素。

    可以使用 add() 方法添加单个元素,使用 update() 方法添加多个元素,update() 可以使用元组、列表、字符串或其他集合作为参数。

    >>> s = {'P', 'y'}
    >>> 
    >>> s.add('t')  # 添加一个元素
    >>> s
    {'P', 'y', 't'}
    >>> 
    >>> s.update(['h', 'o', 'n'])  # 添加多个元素
    >>> s
    {'y', 'o', 'n', 't', 'P', 'h'}
    >>> 
    >>> s.update(['H', 'e'], {'l', 'l', 'o'})  # 添加列表和集合
    >>> s
    {'H', 'y', 'e', 'o', 'n', 't', 'l', 'P', 'h'}

    在所有情况下,元素都不会重复。

    从集合中删除元素

    可以使用 discard() 和 remove() 方法删除集合中特定的元素。

    两者之间唯一的区别在于:如果集合中不存在指定的元素,使用 discard() 保持不变;但在这种情况下,remove() 会引发 KeyError。

    >>> s = {'P', 'y', 't', 'h', 'o', 'n'}
    >>> 
    >>> s.discard('t')  # 去掉一个存在的元素
    >>> s
    {'y', 'o', 'n', 'P', 'h'}
    >>> 
    >>> s.remove('h')  # 删除一个存在的元素
    >>> s
    {'y', 'o', 'n', 'P'}
    >>> 
    >>> s.discard('w')  # 去掉一个不存在的元素(正常)
    >>> s
    {'y', 'o', 'n', 'P'}
    >>> 
    >>> s.remove('w')  # 删除一个不存在的元素(引发错误)
    ...
    KeyError: 'w'

    类似地,可以使用 pop() 方法删除和返回一个项目。

    还可以使用 clear() 删除集合中的所有元素。

    >>> s = set('Python')
    >>> 
    >>> s.pop()  # 随机返回一个元素
    'y'
    >>> 
    >>> s.clear()  # 清空集合
    >>> s
    set()

    注意: 集合是无序的,所以无法确定哪个元素将被 pop,完全随机。

    集合的方法

    老规矩,利用 dir() 来查看方法列表:

    >>> dir(set)
    ['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

    可以看到,有以下方法可用:

    方法描述
    add()将元素添加到集合中
    clear()删除集合中的所有元素
    copy()返回集合的浅拷贝
    difference()将两个或多个集合的差集作为一个新集合返回
    difference_update()从这个集合中删除另一个集合的所有元素
    discard()删除集合中的一个元素(如果元素不存在,则不执行任何操作)
    intersection()将两个集合的交集作为一个新集合返回
    intersection_update()用自己和另一个的交集来更新这个集合
    isdisjoint()如果两个集合有一个空交集,返回 True
    issubset()如果另一个集合包含这个集合,返回 True
    issuperset()如果这个集合包含另一个集合,返回 True
    pop()删除并返回任意的集合元素(如果集合为空,会引发 KeyError)
    remove()删除集合中的一个元素(如果元素不存在,会引发 KeyError)
    symmetric_difference()将两个集合的对称差作为一个新集合返回
    symmetric_difference_update()用自己和另一个的对称差来更新这个集合
    union()将集合的并集作为一个新集合返回
    update()用自己和另一个的并集来更新这个集合

    其中一些方法在上述示例中已经被使用过了,如果有方法不会用,可利用 help() 函数,查看用途及详细说明。

    集合与内置函数

    下述内置函数通常作用于集合,来执行不同的任务。

    函数描述
    all()如果集合中的所有元素都是 True(或者集合为空),则返回 True。
    any()如果集合中的所有元素都是 True,则返回 True;如果集合为空,则返回 False。
    enumerate()返回一个枚举对象,其中包含了集合中所有元素的索引和值(配对)。
    len()返回集合的长度(元素个数)
    max()返回集合中的最大项
    min()返回集合中的最小项
    sorted()从集合中的元素返回新的排序列表(不排序集合本身)
    sum()返回集合的所有元素之和

    不可变集合

    frozenset 是一个具有集合特征的新类,但是一旦分配,它里面的元素就不能更改。这一点和元组非常类似:元组是不可变的列表,frozenset 是不可变的集合。

    集合是 unhashable 的,因此不能用作字典的 key;而 frozensets 是 hashable 的,可以用作字典的 key。

    可以使用函数 frozenset() 创建 frozenset。

    >>> s = frozenset('Python')
    >>> type(s)
    <class 'frozenset'>

    frozenset 也提供了一些列方法,和 set 中的类似。

    >>> dir(frozenset)
    ['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']

    由于 frozenset 是不可变的,所以没有添加或删除元素的方法。

    展开全文
  • Scala集合

    千次阅读 2020-08-26 23:44:46
    2)对于几乎所有的集合类,Scala都同时提供了可变和可变的版本,分别位于以下两个包 可变集合:scala.collection.immutable 可变集合:scala.collection.mutable 3)Scala可变集合,就是指该集合对象可...
  • 集合 —— 集合集合运算

    千次阅读 2019-08-08 12:13:55
    集合中元素的数目称为集合的基数,集合 A 的基数记作:card(A),当其为有限大时,集合 A 称为有限集,反之则为无限集,简单来说,含有有限个元素的集合叫做有限集,含无限个元素的集合叫做无限集。 一个集合具有三...
  • 以下对应的集合,求存在于所有集合要求同时存在于所有集合中)最小元素集合 X1场景对应集合(A、B、C) X2场景对应集合(B、C) X3场景对应集合(D) X4场景对应集合(A、F) X5场景对应集合(B、E...
  • 集合框架

    千次阅读 2016-12-10 18:59:54
    集合框架 1. 集合框架概述 1.1 引入集合框架 1.2 Java 集合框架包含的内容 2. LIST 接口 2.1 ArrayList 集合类 2.2 LinkedList 集合类 3. MAP 接口 4. 迭代器 I TERATOR 5 泛型集合
  • 可变集合

    万次阅读 2017-03-30 07:13:55
    副作用会让代码的易懂性和正确性打折扣。用于转变全局或静态变量的方法就有副作用。用于转变其部分参数的方法也有副作用。... 若要回答这些问题,可以让实例可变,这样就不会有副作用了。 通常,
  • ios集合

    千次阅读 2012-11-02 10:19:05
    Foundation framework中用于收集cocoa对象(NSObject对象)的三种集合分别是: ...以上三种集合类是可变的(一旦初始化后,就不能改变) 以下是对应的三种可变集合类(这三种可变集合类是对应上面三种集合
  • [Java集合篇] Collection 单列集合和 Map 双列集合的区别与遍历写在前面1.Collection 单列集合2. List 集合接口下的子类3....数组的长度是固定的,当添加的元素超过了数组的长度时需要对数组重新定义,而集合能存储...
  • Java集合面试题

    万次阅读 多人点赞 2019-06-25 14:46:19
    Set ,是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模,被用来代表集合,就如一副牌。 List ,是一个有序集合,可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态...
  • Java集合

    千次阅读 2020-07-24 18:08:04
    无序集合允许放重复的数据 主要继承结构图: Iterable接口:可迭代的 里面有iterator()方法,返回一个Iterator迭代器 Iterator接口:迭代器 里面有hasNext()、next()、remove()等方法。 hasNext():判断...
  • 数 据:是描述客观事物的符号,是计算机可以操作的对象,是能被计算机识别,并输入给计算机处理的符号集合,数据仅仅指我们通常所说的数值类型, 还包括字符及声音,图像,视频等非数值类型 。 数 据 项:在数据...
  • import java.util.ArrayList;... (1)生成10个1至100之间的随机整数(不能重复),存入一个List集合 (2)编写方法对List集合进行排序 (2)然后利用迭代器遍历集合元素并输出 (3)如:15 18 20 40 46 60 65 70
  • Redis有序集合

    千次阅读 2019-05-15 20:31:36
    文章目录一、有序集合介绍二、常用命令介绍三、有序集合数据结构为什么有序集合需要同时使用跳跃表和字典来实现?采用哪种编码由什么决定?压缩列表压缩列表节点的构成跳跃表 一、有序集合介绍 有序集合,顾名思义,...
  • Java 集合深入理解(3):Collection

    万次阅读 多人点赞 2016-10-10 01:20:51
    比如一副扑克牌(许多牌组成集合); 比如一个电话本(许多姓名和号码的映射)。 什么是集合框架?集合框架是一个代表、操作集合的统一架构。所有的集合框架都包含以下几点: 接口:表示集合的抽象数据类型。接口...
  • 第一个集合带来了以下插件: 干净整洁且响应Swift的javascript日历,日期和时间选择器。 它与jExcel集成在一起,为您的应用程序和基于Web的系统带来灵活性和响应能力; 我们的多功能下拉菜单旨在为用户提供最佳...
  • 集合的例题

    千次阅读 2019-07-02 17:24:16
    例题1:自定义MyList类,实现存取元素的功能。 定义add方法,可以保存元素,添加MyList尾部。 ...定义remove方法,可以获取到最后添加的元素,并从MyList中移除该元素。...集合工具类。 定义findIndex方法,在某...
  • Java-Collection集合和Map集合总结

    千次阅读 2018-05-27 14:43:11
    本文欢迎转载,转载前请联系作者,经允许后方可转载。转载后请注明出处,谢谢! http://blog.csdn.net/colton_null 作者:...我们在编程的时候,有时候在程序运行中需要根据当时的情况去创建对象,在此之前可能...
  • Java集合基础整理

    千次阅读 2021-01-20 15:42:48
    Java基础集合整理 集合是java中提供的一种容器,可以用来存储多个数据。集合和数组的区别在于:数组的长度是固定的。集合的长度是可变的。数组中存储的是同一类型的元素,可以存储任意类型数据。集合存储的都是引用...
  • 对于Android开发者来说深入了解Java的集合类很有必要主要是从Collection和Map接口衍生出来的,目前主要提供了List、Set和 Map这三大类的集合 Collection接口主要有两种子类分别为List和Set,区别主要是List保存的...
  • 【Java集合 1】java集合有哪些

    千次阅读 多人点赞 2020-06-12 15:20:56
    2、JAVA集合可以存储和操作数目固定的一组数据。 3、若程序时知道究竟需要多少对象,需要在空间不足时自动扩增容量,则需要使用容器类库,array适用。  注:使用相应的toArray()和Arrays.asList()方法可以...
  • JAVA泛型集合

    千次阅读 2017-04-05 18:17:17
    集合框架接口声明了对不同集合类型执行的一般性操作,以下是一些框架集合的接口: (1) Collection:集合层次中的根接口,它派生Set、Queue和List接口。 (2) Set:包含重复值的集合。 (3) Queue:通常是建模排队...
  • 集合框架 这就是集合框架的构成。由于数据结构的不同,有不同的集合,也叫容器。 ...为了方便对多个对象的操作,就对对象进行存储,... 2)集合:长度是可变的,存储的事对象,可以存储基本数据类型 Colle
  • java中的集合详解

    千次阅读 2020-07-21 15:02:17
    Collection接口和Map接口 1 Collection集合 1.1 集合概述 集合集合是java中提供的一种容器,可以用来存储多个数据。...而且对象的类型可以一致。在开发中一般当对象多的时候,使用集合进行存储。 1.2...
  • Java集合系列总结

    千次阅读 2017-04-02 10:49:19
    目录来源:Java 集合系列目录(Category) 转自:Java 集合系列01之 总体框架 Java集合是java提供的工具包,包含了常用的数据结构:集合、链表、队列、栈、数组、映射等。Java集合工具包位置是java.util.* Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 269,261
精华内容 107,704
关键字:

以下不能组成集合的是