精华内容
下载资源
问答
  • 字符串集合中相互包含关系算法
    千次阅读
    2018-03-05 12:24:10

    字符串集合中相互包含关系算法

    先介绍下使用场景,源文件是一个excel表格,要根据某一列的值生成正则表达式,为保证正则表达式的准确性,被包含的数据肯定是不能直接生成正则表达式的,例如,产科和妇产科,如果直接生成正则表达式,那么所有妇产科应该匹配到的字符串都能被产科所匹配到,所以将需要实现一种算法,能对整个字符串数组进行相互包含关系的校验
    python实现

    备选算法:

    • 简单遍历
    • 先按长度排序再遍历
    • 先合并成一个字符串

    简单遍历

    介绍:
    这种介绍起来最简单,就简单的对字符串数组进行遍历,判断当前字符串A是否与其后面的任意字符串存在包含关系(双向判断),长度短的肯定不能包含长度更长的,所以使用判断一次就好,另外,由于是双向判断,所以每次只用比较位于其后的即可
    优点:
    实现简单
    缺点:
    慢,特别慢,字符串数量越多,效率阶乘降低


    先按长度排序再遍历

    介绍:
    按长度排序或者叫做按长度分类更合适,根据字符串长度,将源字符串集合分成若干集合,预先需要确定所有数据不重复,然后我们就可以遍历长度较短的数据集合,判断是否被长度更长的集合里的数据所包含
    优点:
    比简单遍历略快,就是把所有的双向判断部分优化了,每次都判断哪个长度更长无疑是比较浪费时间的
    缺点:
    还是不够快,效率很大长度取决于数据长度的分布,比如只有长度为2和长度为3的数据,那只用判断2里面的数据是否被3里面的数据包含即可


    先合并成一个字符串

    介绍:
    这种算法其实很大程度依赖于python内部的搜索算法的效率(其实每一种算法都会调用这个find,或者count方法),首先,我们将所有的字符串数组拼接成一个字符串,并用分隔符分开,分隔符分开的目的是为了避免前一个字符串的后半段加上后一个字符串的前半段连起来包含了某个字符串的情况,然后遍历字符串数组,接下来只用判断这个拼接字符串包含每个字符串的次数是否超过1即可,超过1即说明该字符串被其他字符串包含了
    优点:
    相比较前两种算法,这种算法的效率提升无疑是成倍增加的,每个字符串的判断仅调用了一次find或者count方法,而不是多次
    缺点:或者说待提升
    其实也就是它的局限性,效率依赖于python内部实现的搜索算法的效率,另外,其他两种算法每次调用find或者count的字符串都是单个字符串,是比较短的,虽然调用了很多次,这种算法虽然每个字符串只调用了一次,但是拼接字符串的长度非常长,所以这也是待提升的地方
    提升方案:
    这里的提升方案,仅适用于当前情况,由需求的背景我们可以知道,其实我们这里只需返回被包含的字符串集合即可,所以,我们只要确定在拼接字符串中包含字符串的次数大于1即可,也就是不去调用count方法,那样会把整个拼接字符串遍历完再返回结果,我们需要使用find,并且是我们自己重写的find,find的作用是找到第一个匹配项,返回位置,我们可以重写成找到第二个再返回,否则返回-1,这样在拼接字符串中,如果已经发现字符串被包含了两次,我们将可以直接返回了,而不用每次都将拼接字符串遍历完,同样,为了进一步优化,我们还可以根据长度排序后再进行拼接,保证尽可能的早返回
    第二次更新
    晚上加完班公交车上想到的,上述的提升方案其实还是有一定问题的,查找的速度不固定,因为被包含的和包含的项位置不确定,所以接下来想到的这种优化方案就是,先根据长度进行排序,将长度较长的放在前面,然后只需要判断比当前字符串更长的值组成的字符串是否包含了当前字符串一次即可,这样还不用重写find算法,另外,在排序的时候,可以采取单独一个变量用于记录每次插入字符串后各长度的位置,这样插入就能直接定位到合适的位置再插入,而不用每次判断
    代码
    这里只给出单纯第三种的代码了,提升方案是针对于大数据量下的优化,对于我的工具中适用性不强,仅给出思路,就不写代码了,有空再写

    # 判断两两包含,具体看开发文档包含关系算法第二种
    def isContain(dataStr):
        global splitSign
        # 被包含列表,需要将被包含的部分提出来
        baoHanList = []
        # 其他列表,只要未被包含均放入该列表
        otherList = []
        # 过滤第一个分隔符号
        for childData in dataStr[len(splitSign):].split(splitSign):
            # 找到两个就返回
            if -1 !=dataStr.find(childData, dataStr.find(childData) + 1):
                baoHanList.append(childData)
            else:
                otherList.append(childData)
        return {"baoHanList":baoHanList,"otherList":otherList}
    ... prompt'''

    总结:

    总结嘛,就算了吧,就是最后一种最好最快,然后给出了优化的思路,并未提供代码,后续有空再填坑

    更多相关内容
  • ( 2 ) 偏序关系 与 等价关系 ( 等价关系 用于分类 | 偏序关系 用于组织 ) 2. 偏序集定义 ( 1 ) 偏序集定义 二. 偏序关系 示例 1. 小于等于关系 ( 1 ) 小于等于关系 说明 ( 2 ) 小于等于关系 分析 2. 大于等于...









    一. 偏序关系




    1. 偏序关系定义



    ( 1 ) 偏序关系定义 ( 自反 | 反对称 | 传递 )


    偏序关系 定义 :

    • 1.前置条件 1 : A ̸ = ∅ A \not= \varnothing A̸= , 并且 R ⊆ A × A R \subseteq A \times A RA×A ;

    • 2.前置条件 2 : 如果 R R R自反 , 反对称 , 传递的 ;

      • ① 自反 : 每个元素 自己 和 自己 都有关系 , x R x xRx xRx ;
      • ② 反对称 : 如果 x R y xRy xRy 并且 y R x yRx yRx x = y x=y x=y , x ̸ = y x \not=y x̸=y , x R y xRy xRy y R x yRx yRx 不能同时存在 ; 可以没有 , 但是一定不能同时出现 ;
      • ③ 传递 : 如果 有 x R y xRy xRy , y R z yRz yRz , 那么必须有 x R z xRz xRz , 如果前提不成立 , 那么也勉强称为传递 ;
    • 3.结论 : R R R A A A 上的偏序关系 ;

    • 4.表示 : 使用 ⪯ \preceq 表示偏序关系 ;

    • 5.读法 : ⪯ \preceq 读作 "小于等于" ;

    • 6.使用公式表示 :
      &lt; x , y &gt; ∈ R ⟺ x R y ⟺ x ⪯ y &lt;x, y&gt; \in R \Longleftrightarrow xRy \Longleftrightarrow x \preceq y <x,y>RxRyxy

    • 7.公式解读 : 如果 x x x , y y y 两个元素 构成 有序对 &lt; x , y &gt; &lt;x,y&gt; <x,y> , 并且在偏序关系 R R R , x x x y y y 具有 R R R 关系 , 也可以写成 x x x 小于等于 ( 偏序符号 ) y y y ;

    • 8.常见的偏序关系 : 树 上 的 小于等于关系 , 集合上的包含关系 , 0 0 0 自然数之间的整除关系 , 都是常见的偏序关系 ;




    ( 2 ) 偏序关系 与 等价关系 ( 等价关系 用于分类 | 偏序关系 用于组织 )


    偏序关系 与 等价关系 :

    • 1.表示层次结构 : 偏序关系是非常常用的二元关系 , 通常用来 表示 层次结构 ;
    • 2.等价关系 : 等价关系 是 用来分类的 , 将一个 集合 分为 几个等价类 ;
    • 3.偏序关系 : 偏序关系 通常是 用来组织的 , 在每个类的内部 , 赋予其一个结构 , 特别是层次结构 , 有上下层级 ,




    2. 偏序集定义



    ( 1 ) 偏序集定义


    偏序集 定义 :

    • 1.前置条件 1 : ⪯ \preceq A A A 上的 偏序关系 ;
    • 2.结论 : &lt; A , ⪯ &gt; &lt;A , \preceq&gt; <A,> 是偏序集 ;
    • 3.解读 : 集合 A A A 与 偏序关系 ⪯ \preceq 构成的有序对 , 称为 偏序集 ;





    二. 偏序关系 示例




    1. 小于等于关系



    ( 1 ) 小于等于关系 说明


    偏序集示例 1 ( 小于等于关系 ≤ \leq 是 偏序关系 ) :

    • 1.公式表示 : ∅ ̸ = A ⊆ R , &lt; A , ≤ &gt; \varnothing \not= A \subseteq R , &lt;A , \leq &gt; ̸=AR,<A,>
    • 2.语言描述 : 如果 A A A 是 实数集 R R R 的 子集 , 并且 A A A 不能 是 空集 ∅ \varnothing , 集合 A A A 中的 小于等于关系 , 是偏序关系 ;
    • 3.使用集合形式表示关系 : ≤ = { &lt; x , y &gt; ∣ x , y ∈ A ∧ x ≤ y } \leq = \{ &lt;x,y&gt; | x,y \in A \land x \leq y \} ={<x,y>x,yAxy}



    ( 2 ) 小于等于关系 分析


    实数集 A A A 上的 小于等于关系 ( ≤ \leq ) 分析 :

    • 1.自反性质分析 : x x x 小于等于 x x x , x ≤ x x \leq x xx , 是成立的 , 小于等于关系 是 自反的 ;
    • 2.反对称性质分析 : x x x 小于等于 y y y , y y y 小于等于 x x x , 推出 x = y x = y x=y , 符合 反对称性质 的 定义 , 因此 小于等于 关系 是 反对称的 ,
    • 3.传递性质分析 : x x x 小于等于 y y y , y y y 小于等于 z z z , x x x 小于等于 z z z , 是成立的 , 因此 小于等于关系 是 传递的 ;
    • 4.总结 : 综上所述 , 小于等于 关系 是 偏序关系 ;




    2. 大于等于关系



    ( 1 ) 大于等于关系 说明


    偏序集示例 2 ( 大于等于关系 ≥ \geq 是 偏序关系 ) :

    • 1.公式表示 : ∅ ̸ = A ⊆ R , &lt; A , ≥ &gt; \varnothing \not= A \subseteq R , &lt;A , \geq &gt; ̸=AR,<A,>
    • 2.语言描述 : 如果 A A A 是 实数集 R R R 的 子集 , 并且 A A A 不能 是 空集 ∅ \varnothing , 集合 A A A 中的 大于等于关系 ( ≥ \geq ) , 是偏序关系 ;
    • 3.使用集合形式表示关系 : ≥ = { &lt; x , y &gt; ∣ x , y ∈ A ∧ x ≥ y } \geq = \{ &lt;x,y&gt; | x,y \in A \land x \geq y \} ={<x,y>x,yAxy}



    ( 2 ) 大于等于关系 分析


    实数集 A A A 上的 大于等于关系 ( ≥ \geq ) 分析 :

    • 1.自反性质分析 : x x x 大于等于 x x x , x ≥ x x \geq x xx , 是成立的 , 大于等于关系 是 自反的 ;
    • 2.反对称性质分析 : x x x 大于等于 y y y , y y y 大于等于 x x x , 推出 x = y x = y x=y , 符合 反对称性质 的 定义 , 因此 大于等于 关系 是 反对称的 ,
    • 3.传递性质分析 : x x x 大于等于 y y y , y y y 大于等于 z z z , x x x 大于等于 z z z , 是成立的 , 因此 大于等于关系 是 传递的 ;
    • 4.总结 : 综上所述 , 大于等于 关系 是 偏序关系 ;




    3. 整除关系



    ( 1 ) 整除关系 说明


    偏序集示例 3 ( 整除关系 是 偏序关系 ) :

    • 1.公式表示 : ∅ ̸ = A ⊆ Z + = { x ∣ x ∈ Z ∧ x &gt; 0 } &lt; A , ∣ &gt; \varnothing \not= A \subseteq Z_+ = \{ x | x \in Z \land x &gt; 0 \}&lt;A , | &gt; ̸=AZ+={xxZx>0}<A,>
    • 2.语言描述 : 如果 A A A 是 正整数集 Z + Z_+ Z+ 的 子集 , 并且 A A A 不能 是 空集 ∅ \varnothing , 集合 A A A 中的 整除关系 ( ∣ | ) , 是偏序关系 ;
    • 3.使用集合形式表示关系 : ∣ = { &lt; x , y &gt; ∣ x , y ∈ A ∧ x ∣ y } |= \{ &lt;x,y&gt; | x,y \in A \land x | y \} ={<x,y>x,yAxy}
    • 4.整除关系 : x ∣ y x|y xy , x x x y y y 的因子 , 或 y y y x x x 的倍数 ;



    ( 2 ) 整除关系 分析


    正整数集 A A A 上的 整除关系 ( ∣ | ) 分析 :

    • 1.自反性质分析 : x x x 整除 x x x , x ∣ x x | x xx , 是成立的 , 整除关系 ( | ) 是 自反的 ;
    • 2.反对称性质分析 : x x x 整除 y y y , y y y 整除 x x x , 两个正整数互相都能整除 , 它们只能相等 , 推出 x = y x = y x=y , 符合 反对称性质 的 定义 , 因此 整除 关系 是 反对称的 ,
    • 3.传递性质分析 : x x x 整除 y y y , y y y 整除 z z z , x x x 整除 z z z , 是成立的 , 因此 整除关系 是 传递的 ;
    • 4.总结 : 综上所述 , 整除 关系 是 偏序关系 ;




    4. 包含关系



    ( 1 ) 包含关系 说明


    偏序集示例 4 ( 包含关系 ⊆ \subseteq 是 偏序关系 ) :

    • 1.公式表示 : A ⊆ P ( A ) , ⊆ = { &lt; x , y &gt; ∣ x , y ∈ A ∧ x ⊆ y } \mathscr{A} \subseteq P(A) , \subseteq = \{&lt;x , y&gt; | x , y \in \mathscr{A} \land x \subseteq y \} AP(A),={<x,y>x,yAxy}
    • 2.语言描述 : 集合 A A A 上的幂集合 P ( A ) P(A) P(A) , P ( A ) P(A) P(A) 的子集合 构成 集族 A \mathscr{A} A , 该集族 A \mathscr{A} A 上的包含关系 , 是偏序关系 ;



    ( 2 ) 包含关系 分析


    分析 集合的 子集族 之间的包含关系 :


    ① 假设一个比较简单的集合

    A = { a , b } A=\{a, b\} A={a,b}


    ② 分析 下面 A A A 的 3 个子集族 ;

    A 1 = { ∅ , { a } , { b } } \mathscr{A}_1 = \{ \varnothing , \{a\} , \{b\} \} A1={,{a},{b}}

    集族 A 1 \mathscr{A}_1 A1 包含 空集 ∅ \varnothing , 单元集 { a } \{a\} {a} , 单元集 { b } \{b\} {b} ;

    A 2 = { { a } , { a , b } } \mathscr{A}_2 = \{ \{a\} , \{a, b\} \} A2={{a},{a,b}}

    集族 A 2 \mathscr{A}_2 A2 包含 单元集 { a } \{a\} {a} , 2 元集 { a , b } \{a, b\} {a,b} ;

    A 3 = P ( A ) = { ∅ , { a } , { b } , { a , b } } \mathscr{A}_3 = P(A) = \{ \varnothing , \{a\} , \{b\} , \{a, b\} \} A3=P(A)={,{a},{b},{a,b}}

    集族 A 3 \mathscr{A}_3 A3 包含 空集 ∅ \varnothing , 单元集 { a } \{a\} {a} , 单元集 { b } \{b\} {b} , 2 元集 { a , b } \{a, b\} {a,b} ; 这是 集合 A A A 的 幂集 ;


    ③ 列举出集族 A 1 \mathscr{A}_1 A1 上的包含关系 :

    ⊆ 1 = I A 1 ∪ { &lt; ∅ , { a } &gt; , &lt; ∅ , { b } &gt; } \subseteq_1 = I_{\mathscr{A}1} \cup \{ &lt;\varnothing , \{a\}&gt; , &lt;\varnothing , \{b\}&gt; \} 1=IA1{<,{a}>,<,{b}>}

    ⊆ 1 \subseteq_1 1 是集合 A 1 \mathscr{A}1 A1 上的偏序关系 ;

    即 分析 空集 ∅ \varnothing , 单元集 { a } \{a\} {a} , 单元集 { b } \{b\} {b} 三个 集合之间的包含关系 :

    • 1.恒等关系 I A 1 I_{\mathscr{A}1} IA1 : &lt; { a } , { a } &gt; 和 &lt; { b } , { b } &gt; &lt;\{a\} , \{a\}&gt; 和 &lt;\{b\} , \{b\}&gt; <{a},{a}><{b},{b}> , 集合上的恒等关系 , 每个集合 肯定 自己包含自己 ;
    • 2. &lt; ∅ , { a } &gt; &lt;\varnothing , \{a\}&gt; <,{a}> : 空集 肯定 包含于 集合 { a } \{a\} {a} ;
    • 3. &lt; ∅ , { b } &gt; &lt;\varnothing , \{b\}&gt; <,{b}> : 空集 肯定 包含于 集合 { b } \{b\} {b} ;
    • 4.总结 : 这些包含关系 的性质分析 :
      • ① 自反 : 每个元素自己 包含 自己 , A ⊆ A A \subseteq A AA , 包含关系具有 自反性质 ;
      • ② 反对称 : 如果 集合 A ⊆ B A \subseteq B AB , B ⊆ A B \subseteq A BA , 那么 A = B A = B A=B , 显然 包含关系 具有反对称性质 ;
      • ③ 传递 : 如果 A ⊆ B A \subseteq B AB , 并且 A ⊆ C A \subseteq C AC , 那么有 A ⊆ C A \subseteq C AC , 包含关系 具有传递性质 ;

    ④ 列举出集族 A 2 \mathscr{A}_2 A2 上的包含关系 :

    ⊆ 2 = I A 2 ∪ { &lt; { a } , { a , b } &gt; \subseteq_2 = I_{\mathscr{A}2} \cup \{ &lt;\{a\} , \{a, b\}&gt; 2=IA2{<{a},{a,b}>

    ⊆ 2 \subseteq_2 2 是集合 A 2 \mathscr{A}2 A2 上的偏序关系 ;


    ⑤ 列举出集族 A 3 \mathscr{A}_3 A3 上的包含关系 :

    ⊆ 3 = I A 3 ∪ { &lt; ∅ , { a } &gt; , &lt; ∅ , { b } &gt; , &lt; ∅ , { a , b } &gt; , &lt; { a } , { a , b } &gt; , &lt; { b } , { a , b } &gt; } \subseteq_3 = I_{\mathscr{A}3} \cup \{ &lt;\varnothing , \{a\}&gt; , &lt;\varnothing , \{b\}&gt;, &lt;\varnothing , \{a, b\}&gt; , &lt;\{a\} , \{a, b\}&gt; , &lt;\{b\} , \{a, b\}&gt; \} 3=IA3{<,{a}>,<,{b}>,<,{a,b}>,<{a},{a,b}>,<{b},{a,b}>}

    ⊆ 3 \subseteq_3 3 是集合 A 3 \mathscr{A}_3 A3 上的偏序关系 ;




    5. 加细关系



    ( 1 ) 加细关系 说明


    偏序集示例 5 ( 加细关系 ⪯ 加 细 \preceq_{加细} 是 偏序关系 ) :

    • 1.加细关系描述 : A ̸ = ∅ A \not= \varnothing A̸= , π \pi π 是 由 A A A 的 一些划分 组成的集合 ;

    ⪯ 加 细 = { &lt; x , y &gt; ∣ x , y ∈ π ∧ x 是 y 的 加 细 } \preceq_{加细} = \{&lt;x , y&gt; | x , y \in \pi \land x 是 y 的 加细\} ={<x,y>x,yπxy}

    • 2.划分 : 划分 是 一个 集族 ( 集合的集合 ) , 其元素是集合 又叫 划分快 , 其中 每个元素(集族中的元素)集合 中的 元素 是 非空集合 A A A 的元素 ;
      • ① 该集族不包含空集 ;
      • ② 该集族中任意两个集合都不想交 ;
      • ③ 该集族中 所有 元素 取并集 , 得到 集合 A A A ;



    ( 2 ) 加细关系 分析


    分析 集合的 划分之间 的 加细 关系 :

    ① 集合 A = { a , b , c } A = \{a, b, c\} A={a,b,c} , 下面的 划分 和 加细 都基于 该 集合 进行分析 ;


    ② 下面 列出集合 A A A 的 5 个划分 :

    划分 1 : 对应 1 个等价关系 , 分成 1 类 ;
    A 1 = { { a , b , c } } \mathscr{A}_1 =\{ \{ a, b, c \} \} A1={{a,b,c}}

    划分 2 : 对应 2 个等价关系 , 分成 2 类 ;
    A 2 = { { a } , { b , c } } \mathscr{A}_2 = \{ \{ a \} , \{ b, c \} \} A2={{a},{b,c}}

    划分 3 : 对应 2 个等价关系 , 分成 2 类 ;
    A 3 = { { b } , { a , c } } \mathscr{A}_3 = \{ \{ b \} , \{ a, c \} \} A3={{b},{a,c}}

    划分 4 : 对应 2 个等价关系 , 分成 2 类 ;
    A 4 = { { c } , { a , b } } \mathscr{A}_4 = \{ \{ c \} , \{ a, b \}\} A4={{c},{a,b}}

    划分 5 : 对应 3 个等价关系 , 分成 3 类 ; 每个元素自己自成一类
    A 5 = { { a } , { b } , { c } } \mathscr{A}_5 = \{ \{ a \} , \{ b \}, \{ c \} \} A5={{a},{b},{c}}

    ③ 下面 列出要分析的几个由划分组成的集合 :

    集合 1 :
    π 1 = { A 1 , A 2 } \pi_1 = \{ \mathscr{A}_1, \mathscr{A}_2 \} π1={A1,A2}

    集合 2 :
    π 2 = { A 2 , A 3 } \pi_2 = \{ \mathscr{A}_2, \mathscr{A}_3 \} π2={A2,A3}

    集合 3 :
    π 3 = { A 1 , A 2 , A 3 , A 4 , A 5 } \pi_3 = \{ \mathscr{A}_1, \mathscr{A}_2, \mathscr{A}_3, \mathscr{A}_4, \mathscr{A}_5 \} π3={A1,A2,A3,A4,A5}

    ④ 集合 π 1 \pi_1 π1 上的加细关系分析 :

    • 1.自己是自己的加细 : 每个划分 , 自己是自己的加细 , 因此 加细关系中 有 I π 1 I_{\pi 1} Iπ1 , &lt; A 1 , A 1 &gt; &lt;\mathscr{A}_1 , \mathscr{A}_1&gt; <A1,A1> , &lt; A 2 , A 2 &gt; &lt;\mathscr{A}_2 , \mathscr{A}_2&gt; <A2,A2> ;
    • 2.其它加细关系 : A 2 \mathscr{A}_2 A2 划分中的 每个划分块 , 都是 A 1 \mathscr{A}_1 A1 划分 中块 的某个划分块的子集合 , 因此有 A 2 \mathscr{A}_2 A2 A 1 \mathscr{A}_1 A1 的加细 , 记做 &lt; A 2 , A 1 &gt; &lt;\mathscr{A}_2, \mathscr{A}_1&gt; <A2,A1> ;
    • 3.加细的定义 : A 1 \mathscr{A}_1 A1 A 2 \mathscr{A}_2 A2 都是集合 A A A 的划分, A 2 \mathscr{A}_2 A2 中的 每个划分块 , 都含于 A 1 \mathscr{A}_1 A1 中的某个划分块中 , 则称 A 2 \mathscr{A}_2 A2 A 1 \mathscr{A}_1 A1 的加细 ;

    - 4.加细关系列举 :
    ⪯ 1 = I π 1 ∪ { &lt; A 2 , A 1 &gt; } \preceq_1 = I_{\pi 1} \cup \{ &lt;\mathscr{A}_2, \mathscr{A}_1&gt; \} 1=Iπ1{<A2,A1>}


    ⑤ 集合 π 2 \pi_2 π2 上的加细关系分析 :

    • 1.自己是自己的加细 : 每个划分 , 自己是自己的加细 , 因此 加细关系中 有 I π 2 I_{\pi 2} Iπ2 , &lt; A 3 , A 3 &gt; &lt;\mathscr{A}_3 , \mathscr{A}_3&gt; <A3,A3> , &lt; A 2 , A 2 &gt; &lt;\mathscr{A}_2 , \mathscr{A}_2&gt; <A2,A2> ;
    • 2.其它加细关系 : A 2 \mathscr{A}_2 A2 A 3 \mathscr{A}_3 A3 这两个划分互相不是加细 , 因此 该集合中没有其它加细关系 ;

    - 4.加细关系列举 :
    ⪯ 2 = I π 2 \preceq_2 = I_{\pi 2} 2=Iπ2


    ⑥ 集合 π 3 \pi_3 π3 上的加细关系分析 :

    • 1.自己是自己的加细 : 每个划分 , 自己是自己的加细 , 因此 加细关系中 有 I π 3 I_{\pi 3} Iπ3 , &lt; A 1 , A 1 &gt; &lt;\mathscr{A}_1 , \mathscr{A}_1&gt; <A1,A1> , &lt; A 2 , A 2 &gt; &lt;\mathscr{A}_2 , \mathscr{A}_2&gt; <A2,A2>, &lt; A 3 , A 3 &gt; &lt;\mathscr{A}_3 , \mathscr{A}_3&gt; <A3,A3>, &lt; A 4 , A 4 &gt; &lt;\mathscr{A}_4 , \mathscr{A}_4&gt; <A4,A4>, &lt; A 5 , A 5 &gt; &lt;\mathscr{A}_5 , \mathscr{A}_5&gt; <A5,A5> ;
    • 2.其它加细关系 :
      • ① 与 A 5 \mathscr{A}_5 A5 划分相关的加细 : A 5 \mathscr{A}_5 A5 是划分最细的 等价关系 , A 5 \mathscr{A}_5 A5 是其它所有 划分 的加细 , 因此有 &lt; A 5 , A 4 &gt; &lt;\mathscr{A}_5 , \mathscr{A}_4&gt; <A5,A4> , &lt; A 5 , A 3 &gt; &lt;\mathscr{A}_5 , \mathscr{A}_3&gt; <A5,A3> , &lt; A 5 , A 2 &gt; &lt;\mathscr{A}_5 , \mathscr{A}_2&gt; <A5,A2> , &lt; A 5 , A 1 &gt; &lt;\mathscr{A}_5 , \mathscr{A}_1&gt; <A5,A1> ;
      • ② 与 A 1 \mathscr{A}_1 A1 划分相关的加细 : A 1 \mathscr{A}_1 A1 是划分最粗的 等价关系 , 所有的划分 都是 A 1 \mathscr{A}_1 A1 的加细 , 因此有 &lt; A 5 , A 1 &gt; &lt;\mathscr{A}_5 , \mathscr{A}_1&gt; <A5,A1> , &lt; A 4 , A 1 &gt; &lt;\mathscr{A}_4 , \mathscr{A}_1&gt; <A4,A1> , &lt; A 3 , A 1 &gt; &lt;\mathscr{A}_3 , \mathscr{A}_1&gt; <A3,A1> , &lt; A 2 , A 1 &gt; &lt;\mathscr{A}_2 , \mathscr{A}_1&gt; <A2,A1> ;
    • 4.加细关系列举 :

    ⪯ 3 = I π 3 ∪ { &lt; A 5 , A 4 &gt; , &lt; A 5 , A 3 &gt; , &lt; A 5 , A 2 &gt; , &lt; A 5 , A 1 &gt; , &lt; A 4 , A 1 &gt; , &lt; A 3 , A 1 &gt; , &lt; A 2 , A 1 &gt; } \preceq_3 = I_{\pi 3} \cup \{ &lt;\mathscr{A}_5 , \mathscr{A}_4&gt; , &lt;\mathscr{A}_5 , \mathscr{A}_3&gt; , &lt;\mathscr{A}_5 , \mathscr{A}_2&gt; , &lt;\mathscr{A}_5 , \mathscr{A}_1&gt; , &lt;\mathscr{A}_4 , \mathscr{A}_1&gt;, &lt;\mathscr{A}_3 , \mathscr{A}_1&gt;, &lt;\mathscr{A}_2 , \mathscr{A}_1&gt; \} 3=Iπ3{<A5,A4>,<A5,A3>,<A5,A2>,<A5,A1>,<A4,A1>,<A3,A1>,<A2,A1>}


    展开全文
  • 单列集合 以及双列集合

    千次阅读 2020-11-19 22:15:14
    概念:集合是一个容器,数组也是一个容器,但是呢数组的大小是固定的、类型是唯一的因此在某些需求有限制 集合特点: 1、容器大小可变 2、可以存储多种数据类型的值【只能是引用数据类型,对基本数据类型而言...

    集合框架

    1. 概念:集合是一个容器,数组也是一个容器,但是呢数组的大小是固定的、类型是唯一的因此在某些需求上有限制

    2. 集合特点:

      1、容器大小可变

      2、可以存储多种数据类型的值【只能是引用数据类型,对基本数据类型而言存储的是其包装类】

      3.根据集合的存储方式不同,将集合划分两大类:一类是单列集合,另一类是双列集合

      关键词:Collection(单列集合)、Map(双列集合)

    一.Collection 单列集合

    1. List集合是有序集合,集合中的元素可以重复,访问集合中的元素可以根据元素的索引来访问。
    2. Set集合是无序集合,集合中的元素不可以重复,访问集合中的元素只能根据元素本身来访问(也是集合里元素不允许重复的原因)

    ​ 3. Collection中的方法:

    ​ 添加

    ​ add(Object obj) 向集合中添加一个元素

    ​ add All (Collection coll) 向集合中添加另一个集合

    ​ 移除

    ​ remove(Object obj) 从集合中移除指定的元素

    ​ remove All(Collection coll)从集合中移除指定的元素集合

    ​ clear() 清空集合中的所有元素

    ​ 判断

    ​ is Empty() 判断集合是否为空—看集合中是否有元素

    ​ contains(Object obj) 判断集合中是否包含指定的元素

    ​ Constantinople(Collection coll) 判断集合中是否有另一个集合中对应的所有的元素




    举例:添加方法

    public static void addMethod() {
    		//创建集合对象
    		Collection coll = new ArrayList();
    		coll.add("haha");
    		coll.add("马保国");
    		coll.add(123);
    		System.out.println("coll--"+coll);
    		
    		Collection coll2 = new ArrayList();
    		coll2.add(123);
    		coll2.add("马保国");
    		System.out.println("coll2--"+coll2);
    	}
    

    举例: 是否包含

    public static void judgeMethod() {
    		Collection coll = new ArrayList();
    		coll.add("enen");
    		coll.add("马保国");
    		coll.add(123);
    		System.out.println("coll--"+coll);
    		System.out.println("是否包含马保国:"+coll.contains("马保国")); //true
            System.out.println("是否包含123:"+coll.contains("123"));//false 类型不一致
    		
    		Collection coll2 = new ArrayList();
    		coll2.add("马保国");
    		coll2.add(123);
    		//此处是包含关系
    		System.out.println("是否包含某个集合:"+coll.containsAll(coll2));//true
    		System.out.println("获取集合大小:"+coll.size());//3
    	}
    

    因为包含马保国这个元素,所以输出结果为true

    coll中包含了coll2的所有元素,所以输出结果为true

    coll的集合大小为3

    举例:移除元素

    public static void removeMethod() {
    		//创建元素对象
    		Collection coll = new ArrayList();
    		coll.add("元素一");
    		coll.add(123);
    		coll.add("元素二");
    		System.out.println("移除前的集合:"+coll);//[元素一, 123, 元素二]
    		
    		//移除单个元素
    		coll.remove("元素一");
    		System.out.println("移除后的集合:"+coll);//[123, 元素二]
    		//移除指定集合的元素 只要有相同的就移除
    		Collection coll2 = new ArrayList();
    		coll2.add("元素三");
    		coll2.add(123);
    		//交集关系
    		coll.removeAll(coll2);
    		System.out.println("移除指定集合后的集合:"+coll);//[元素二]
    		System.out.println("coll2中的元素:"+coll2);// [元素三, 123] 不影响coll2的内容
    		
    		//清空集合 只是将集合中的元素清除了
    		coll.clear();
    		System.out.println("清空后的集合:"+coll);//[]
    		//判断集合是否为空 isEmpty()
    		System.out.println("是否为空:"+coll.isEmpty());//true
    	}
    

    举例:转数组集合

    public static void changeArrayMethod() {
    		Collection coll = new ArrayList();
    		coll.add("元素一");
    		coll.add("元素二");
    		coll.add(123);
    		//将集合转换为数组
    		Object[] obj=coll.toArray();
    		for( int i=0; i<obj.length;i++) {
    			if(obj[i] instanceof String) {
    				String str = (String)obj[i];
    				System.out.println(str);
    			}
    		}
    	}
    

    输出结果为 元素一 , 元素二

    迭代器(遍历):

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-od9IW6HB-1605790360523)(C:\Users\Administrator\Desktop\asset\image-20201118201857098.png)]

    举例:

    public static void iteratorMethod() {
    		Collection coll = new ArrayList();
    		coll.add("haha");
    		coll.add(123);
    		coll.add("张三");
    		
    		Iterator it = coll.iterator();
    		/*System.out.println(it.next());
    		System.out.println(it.next());
    		System.out.println(it.next());*/  // 有几个元素就可以输出几行,但是手动添加太麻烦
    	  //System.out.println(it.next()); 超出元素数量就会报错
    		//先通过指针去判断是否有下一个元素
    		while(it.hasNext()) {
    			//需求:如果是字符串就输出其长度
    			Object obj = it.next();
    			if(obj instanceof String) {
    				String str= (String)obj;
    				System.out.println(str);
    			}
    		}
    	}
    

    输出结果为haha , 张三, (123是Integer类型,不是字符串)

    迭代:

    public static void iteratorMethod2() {
    		Collection coll = new ArrayList();
    		coll.add("haha");
    		coll.add(123);
    		coll.add("张三");
    		
    		Iterator it = coll.iterator();
    		//先通过指针去判断是否有下一个元素,有的话就继续执行,没有的话结束while语句
    		while(it.hasNext()) {
    			//需求:当数据类型为Integer时,就删除该元素
    			if(it.next() instanceof Integer) {
    				it.remove();
    			}
    		}
    		System.out.println("移除后的集合元素:"+coll);
    	}
    

    移除后的集合元素:[haha, 张三]

    迭代2:(错误示范)

    public static void iteratorMethod3() {
    		Collection coll = new ArrayList();
    		coll.add("haha");
    		coll.add(123);
    		coll.add("张三");
    		Iterator it = coll.iterator();
    		//先通过指针区判断是否有下一个元素
    		while(it.hasNext()) {
    			//需求:当数据类型为Integer类型时,再添加一条数据
    			if(it.next() instanceof Integer) {
    				//并发  
    				coll.add("新增的");
    			}	
    		}
    		System.out.println("修改后的集合元素:"+coll);
    	}
    

    这种情况称为并发修改, 同一个元素在同一时刻出现了不同的操作,比如同一张银行卡同时存钱又取钱,没有必要进行这种操作

    1.1.List 接口

    1.允许重复、有序(输入输出顺序) 数组的数据结构(底层维护的是一个数组) 查询快、增删慢

    2.List中常用的子类有两个:

    ​ ArrayList:底层维护的是一个数组数据结构,查询快,增删慢

    ​ LinkedList:底层维护的是一个链表数据结构,增删快、查询慢

    ​ 如果查询多就用ArrayList,如果增删多就用LinkedList,如果不知道就选ArrayList,因为往往查询比增删需求多

    举例1: 通过下标进行元素添加

    public static  void addMethod() {
    		 List list = new ArrayList();
    		 list.add("嵩山");
    		 list.add("泰山");
    		 list.add("华山");
    		 list.add("衡山");
    		 list.add(2,"恒山");
    		 System.out.println("list:"+list);//list:[嵩山, 泰山, 恒山, 华山, 衡山]
    		 
    		 List list2 = new ArrayList();
    		 list2.add("西流湖");
    		 list2.add("龙子湖");
    		 list2.add("龙湖");
    		 System.out.println("list2:"+list2);//list2:[西流湖, 龙子湖, 龙湖]
    		 
    		 list.addAll(4,list2);
    		 System.out.println("添加后的集合:"+list);//添加后的集合:[嵩山, 泰山, 恒山, 华山, 西流湖, 龙子湖, 龙湖, 衡山]
    	}
    

    通过list接口可以向指定位置添加数据,list.add(2,“恒山”); 那就是在下标为2的地方插入"恒山"

    list.addAll(4,list2); 就是把list2 插入list下标为4的地方


    举例2:通过下标移除元素

    public static void removeMethod() {
    		 List list = new ArrayList();
    		 list.add("嵩山");
    		 list.add("泰山");
    		 list.add("华山");
    		 list.add("衡山");
    		 list.add(2,"恒山");
    		 System.out.println("list:"+list);//list:[嵩山, 泰山, 恒山, 华山, 衡山]
    		 
    		 //移除指定下标对应的元素
    		 list.remove(1);
    		 System.out.println("移除后的list:"+list);//移除后的list:[嵩山, 恒山, 华山, 衡山]
    		 
    		 List list2 = new ArrayList();
    		 list2.add("西流湖");
    		 list2.add("龙子湖");
    		 list2.add("华山");
    		 //移除指定集合
    		 list.removeAll(list2);
    		 System.out.println("移除后的list:"+list);//移除后的list:[嵩山, 恒山, 衡山]
    	}
    

    remove() 移除指定下标对应的元素,当下标为1是,移除的就是泰山

    removeAll()移除指定集合,list和list2中相交的就是"华山"元素,所以只移除了list中的"华山"元素



    举例3:在迭代的过程中修改集合中的元素

    public static void listIteratorMethod() {
    		List list= new ArrayList();
    		list.add("嵩山");
    		 list.add("泰山");
    		 list.add("华山");
    		 //获取迭代器
    		 ListIterator listIt = list.listIterator();
    		 int i=0;
    		 //先用指针去判断是否有下一个元素
    		 while(listIt.hasNext()) {
    			 Object obj = listIt.next();
    			 if(i%2 != 0) {
    				 listIt.add("东"+i+"山");
    			 }else {
    				 listIt.set("西"+i+"山");
    			 }
    			 i++;
    		 }
    		 System.out.println("修改后的集合:"+list);//修改后的集合:[西0山, 泰山, 东1山, 西2山]
    	}
    

    当i为基数时,添加"东"+i+“山” ,当i为基数时,修改为"西"+i+“山”

    1.2.Set集合

    1.Set集合 不允许重复,且不保证输出顺序

    2.Set集合中常用的两个子类

    HashSet 底层是通过HashMap实现的

    HashMap的底层是哈希表结构

    1.2.1.HashSet举例
    public static void method() {
    		Set set = new HashSet();
    		set.add("太平洋");
    		set.add("大西洋");
    		set.add("北冰洋");
    		set.add("印度洋");
    		set.add("大西洋");
    		System.out.println(set);
    	}
    

    如何实现的不重复?以代码为例:

    public static void method2() {
    		Set set = new HashSet();
    		set.add(new User(13,"张飞"));//每次创建对象,都会运行一个HashCode
    		set.add(new User(15,"赵云"));
    		set.add(new User(11,"关羽"));
    		set.add(new User(13,"张飞"));
    		set.add(new User(15,"赵云"));
    		System.out.println(set);
    	}
    
    public class User {
    	private int age;
    	private String name;
    
    	public User() {
    	}
    
    	public User(int age, String name) {
    		super();
    		this.age = age;
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
    		return "User [age=" + age + ", name=" + name + "]";
    	}
    	
    	/**
    	 * 降低hash冲突
    	 */
    	@Override
    	public int hashCode() {
    		System.out.println("--hashCode--");
    		return this.age + this.name.hashCode();
    	}
    
    	@Override
    	public boolean equals(Object obj) {
    		System.out.println("--equals--");
    		User user = (User)obj;
    		int temp = this.age - user.age;
    		if(temp == 0) {//年龄相同的时候才去比较名字
    			return this.name.equals(user.name);
    		}
    		return false;
    	}
    }
    

    以上结果为:

    --hashCode--
    --hashCode--
    --hashCode--
    --hashCode--
    --equals--
    --hashCode--
    --equals--
    [User [age=13, name=张飞], User [age=15, name=赵云], User [age=11, name=关羽]]
    

    我们可以从中发现每次创建一个对象之后,系统会先运行hashCode()进行地址的比较

    所以我们进行修改:

    @Override
    	public int hashCode() {
    		System.out.println("-hashcode 默认的-");
    		return 1;//设定一个固定值从而让所有的对象的地址相同
    		}
    

    再次运行主程序

    -hashcode-
    -hashcode-
    -equal -
    -hashcode-
    -equals-
    -equals-
    -hashcode-
    -equals-
    -equals-
    -equals-
    -hashcode-
    -equals-
    -equals-
    -equals-
    -equals-
    [User [age=13, name=张飞], User [age=15, name=赵云], User [age=11, name=关羽]]
    

    我们可以发现,如果在所有的对象的地址相同的情况下,程序就会运行 equals(Object obj)对值进行对比。先进来两个对象,然后运行equals对两个对象进行对比,然后再进来一个对象,将这个对象和之前的两个对象再进行对比…

    最后我们做出以下修改

    @Override
    public int hashCode() {
    	System.out.println("-hashcode 默认的-");
    	//return 1;//如果使用固定值,所有的对象地址相同,会造成哈希冲突
    	//降低哈希冲突
    	return this.id + this.name.hashCode();//只要地区代号和名字的哈希值不同就会识别为不同的地址
    }
    
    @Override
    public boolean equals(Object obj) {
    	System.out.println("-equals 默认的-");
    	User user = (User)obj;
    	int temp = this.id - user.id;
    	if(temp == 0) {//地区编号相同的时候才去比较名字
    		return this.name.equals(user.name);
    	}
    	return false;
    }
    

    这种情况下,程序就会先运行hashCode()对数据的地址进行判断,只要地区代号和名字的哈希值不同就会识别为不同的地址。而如果地址相同,则会运行 equals(Object obj),对地区编号和名字进行对比。正是使用这种方法,set集合保证了元素的不重复

    结果如下
    -hashcode-
    -hashcode-
    -hashcode-
    -hashcode-
    -hashcode-
    -equals-
    [User [age=13, name=张飞], User [age=15, name=赵云], User [age=11, name=关羽]]
    
    1.2.2TreeSet

    TreeSet 底层是TreeMap来实现的,TreeMap的底层是红黑树数据结构

    二叉树:小的在左边,大的在右边

    优点:查询快

    缺点:容易不平衡

    二叉树---->平衡二叉树----->红黑树

    常用的功能:

    1.对于数字和字符默认使用的是自然排序法

    public static void method() {
    		Set set =new TreeSet();
    		set.add(25);
    		set.add(69);
    		set.add(78);
    		set.add(11);
    		System.out.println("纯数字的set集合:"+set);//纯数字的set集合:[11, 25, 69, 78]
    		
    		Set set2 =new TreeSet();
    		set2.add("cba");
    		set2.add("acb");
    		set2.add("bac");
    		set2.add("bca");
    		System.out.println("纯字符串的set集合:"+set2);//纯字符串的set集合:[acb, bac, bca, cba]
    	}
    

    2.引用数据类型排序

    当我们往set类型中存储引用数据类型的时候会报错(类型转换异常),不能把user类转换为comparable类

    comparable是一个接口,该接口对实现它的每一个类强加一个整体排序,是针对引用数据类型的自然排序(类的comparTO方法被称为自然比较方法)

    思路: 先实现comparable接口,再重写comparTO方法

    public static void objMethod() {
    		Set set =new TreeSet();
    		set.add(new User(36,"黄忠"));
    		set.add(new User(25,"张飞"));
    		set.add(new User(23,"赵云"));
    		set.add(new User(25,"马超"));
    		System.out.println(set);
    	}
    
    public class User implements Comparable { // 实现Comparable接口
    	private int age;
    	private String name;
    
    	public User() {
    	}
    
    	public User(int age, String name) {
    		super();
    		this.age = age;
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
    		return "User [age=" + age + ", name=" + name + "]";
    	}
        /**
     * 用于用户自定义排序方式
     * 拿两个对象的年龄进行比较
     * >排左边 <排右边 0相等
     */
    	@Override
    	public int compareTo(Object o) {
    		User user = (User)o; //进行类型转换 
    		int temp=this.age - user.age;
    		if(temp==0) {//先比较年龄,再比较名字,不过不等于0,直接返回结果
    			//比较名字
    			 return this.name.compareTo(user.name);
    		}
    		return temp;
    		
    	}
    

    3.自定义排序

    public static void customObjMethod() { 
    		//这里默认的是有一个比较器,用的是自然排序法,但是我们这里要自定义一个规则,传递进去以后,覆盖掉以前的比较器
    		Set set = new TreeSet( new CompareByPriceAndBance());
    		set.add(new Item(5.5,"大刀肉","良品铺子"));
    		set.add(new Item(1900,"ipad","apple"));
    		set.add(new Item(100,"坚果礼盒","三只松鼠"));
    		System.out.println(set);
    	}
    public class Item {
    	private double price;
    	private String name;
    	private String brand;
    
    	public Item() {
    	}
    
    	public Item(double price, String name, String brand) {
    		super();
    		this.price = price;
    		this.name = name;
    		this.brand = brand;
    	}
    
    	public double getPrice() {
    		return price;
    	}
    
    	public void setPrice(double price) {
    		this.price = price;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getBrand() {
    		return brand;
    	}
    
    	public void setBrand(String brand) {
    		this.brand = brand;
    	}
    
    	@Override
    	public String toString() {
    		return "Item [price=" + price + ", name=" + name + ", brand=" + brand + "]";
    	}
    

    4.Collcetions工具类

    1.Collections是针对Collection集合提供的一个工具类

    2.sort(List list)对list集合进行排序

    3.set集合不重复、TreeSet是默认就有自然排序,list如果想要排序就需要用到Collections工具类

    public class CollectionsDemo {
    
    	public static void main(String[] args) {
    		compareList();
    	}
     public static void compareList() {
    	 List list = new ArrayList();
    	 list.add("baidu.com");
    	 list.add("aliyun");
    	 list.add("taobao");
    	 list.add("yunhe");
    	 System.out.println("未排序的集合:"+list);
    	 //对集合进行排序
    	 Collections.sort(list);
    	 System.out.println("排序后的集合:"+list);
     }
    

    5.Arrays 数组工具类

    public class ArrayDemo {
    
    	public static void main(String[] args) {
    		 int[]arr = {52,41,96,83,11,22};
    		 //注意:此处返回的是Arrays中的一个内部类--ArrayList
    		 List list = Arrays.asList(arr);
            
    		 
    		 //对数组排序 可以代替掉冒泡排序
    		 Arrays.sort(arr);
    		 for(int i=0; i<arr.length;i++) {
    			 System.out.println(arr[i]);//11 22 41 52 83 96
    		 }
    
    	}
    

    当我们把 List list = Arrays.asList(arr); 转换过去之后,数组中的值就会变为integer对象,对象本身就是一个地址,需要注意的是此处返回的是Arrays中的一个内部类–ArrayList

    2.双列排序

    1.Map集合是双列集合,是以键值对的形式存储数据的,关于键值对可以简单的理解为数学学的映射关系

    2.Map集合中key值不能重复的,同时,key所对应的值至多为一个

    3.常用方法有:

    1. 1添加:put(Object key,Object value) putAll(Map map)

    3.2移除: remove(Object key) remove(Object key , Object value)

    3.3获取: get(Object key)

    3.4遍历 :Map集合本身并没有可以直接遍历的形式,将Map集合转换成Collection集合后,利用Collection 中提供的迭代器进行遍历,

    ​ values()拿到所有的值 ; keySet()拿到所有的键 ; entrySet()对key和value进行包装

    2.1添加数据

    key相同时,会按照顺序进行值的覆盖

    null既可以作为key也可以作为值(但是没有必要)

    //put
    	public static void putMethod() {
    		Map map = new HashMap();
    		map.put("name", "马保国");
    		map.put("work", "闪电五连鞭");
    		map.put("age", 69);
    		//当key值相同时,值会进行覆盖
    		map.put("work", "混元形意太极门");
    		System.out.println("map:"+map);//map:{work=混元形意太极门, name=马保国, age=69}
    //自定义类型 putAll
    		Map map2 = new HashMap();
    		map2.put(new Item("辣条","卫龙辣条",9.9), 1);
    		map2.put(2,new Item("蛋黄酥","达利园",25));
    		System.out.println("map2:"+map2);//map2:{Item [itemName=辣条, brand=卫龙辣条, price=9.9]=1, 2=Item [itemName=蛋黄酥, brand=达利园, price=25.0]}
    		
    		map.putAll(map2);
    		System.out.println("整合后的集合:"+map);//整合后的集合:{Item [itemName=辣条, brand=卫龙辣条, price=9.9]=1, 2=Item [itemName=蛋黄酥, brand=达利园, price=25.0], work=混元形意太极门, name=马保国, age=69}
    	}
    

    2.2移除方法

    public static void removeMethod() {
    		Map map= new HashMap();
    		map.put("name", "马保国");
    		map.put("work", "闪电五连鞭");
    		map.put("age", 69);
    		System.out.println("移除前:"+map);
    		//移除
    		map.remove("age");
    		System.out.println("移除后:"+map);//移除后:{work=闪电五连鞭, name=马保国}
    		map.remove("name","老马");
    		System.out.println("再一次移除后:"+map);//再一次移除后:{work=闪电五连鞭, name=马保国}
    		//清空 clear()
    		map.clear();
    		System.out.println("清空后的集合:"+map);//清空后的集合:{}
    		System.out.println("集合的大小:"+map.size());//集合的大小:0
    	}
    

    2.3获取方法

    public static void getMethod() {
    		Map map= new HashMap();
    		map.put("name", "马保国");
    		map.put("work", "闪电五连鞭");
    		map.put("age", 69);
    		System.out.println(map.get("age"));//69
    	}
    

    2.4遍历

    1.values()拿到所有的值, 即遍历所有的值,values以Collection的形式进行遍历

    public static void ergodicMethod() {
    		Map map= new HashMap();
    		map.put("name", "马保国");
    		map.put("work", "闪电五连鞭");
    		map.put("age", 69);
    		//将所有的值以Collection的单列集合进行存储
    		Collection coll = map.values();
        //获取迭代器对象
    		 Iterator it=coll.iterator();
    		 while(it.hasNext()) {
    			 System.out.println(it.next());
    		 }
    	}
    

    2.keySet()拿到所有的键, 即遍历所有的key, 将所有的key封装成一个Set集合进行遍历,Map集合中要求key是不能重复的,而Set集合本身就是不重复的

    public static void ergodicMethod2() {
    		Map map= new HashMap();
    		map.put("name", "马保国");
    		map.put("work", "闪电五连鞭");
    		map.put("age", 69);
        //KeySet()获取所有的Key形成一个单列集合--Set
    		Set set = map.keySet();
        //获取迭代器对象
    		Iterator it=set.iterator();
    		while(it.hasNext()) {
    			Object key=it.next();
    			Object value=map.get(key);
    			System.out.println(key+"--"+value);//work--闪电五连鞭 name--马保国 age--69
    		}
    	}
    

    3.entrySet() (对key和value进行包装),即遍历key-value,将整个映射作为一个整体进行使用,返回值类型Set(Map.Entry)

    Map.Entry是Map集合中的一个内部接口

    public static void ergodicMethod3() {
    		Map map= new HashMap();
    		map.put("name", "马保国");
    		map.put("work", "闪电五连鞭");
    		map.put("age", 69);
        //获取映射关系对应的集合
    		Set set=map.entrySet();
    		//迭代器中存储的整个键值对关系--Entry
    		Iterator it=set.iterator();
    		while(it.hasNext()) {
                //该对象中包含了对应的key和value的关系
    			Map.Entry entry=(Map.Entry)it.next();
    			Object key=entry.getKey();
    			Object value=entry.getValue();
    			System.out.println(key+"--"+value);
    		}
    	}
    

    Map集合中常用的子类有两个:HashMap、TreeMap

    展开全文
  • 小插曲:小编在学习计算机二级的时候,苦于关系代数的关系运算理解,在网上百度很多的资源,大都是概念,而且是文本形式呈现的。个人喜好图文形式的理解,因此将做的比较好的ppt做成帖子供大家参考,如有错误,请...

    小插曲:小编在学习计算机二级的时候,苦于关系代数的关系运算理解,在网上百度很多的资源,大都是概念,而且是文本形式呈现的。个人喜好图文形式的理解,因此将做的比较好的ppt做成帖子供大家参考,如有错误,请批评指正

    声明:

    1)本文主要图文来源:喻小光
    2)原文链接:https://wenku.baidu.com/view/d28c9bbffad6195f302ba61b.html?from=search

    一、集合运算

    关系R和S 是元组的集合(不存在重复元组)
    前提:R和S的模式具有相同的属性集(属性域匹配)
    且属性顺序相同
    属性名不同,可以改名。

     集合运算主要讲:并、交和差。因为传统集合运算很好理解,所以就简要解释。
    

    1.

    A∪B: A和B的并 由A或B中的元组组成

    在这里插入图片描述

    2.

    R∩S: R和S的交 由R和S中都存在的元组组成

    在这里插入图片描述

    3.

    B-A: B和A的差 由在B中而不在A中的元组组成

    在这里插入图片描述

    二、关系运算

    关系运算主要详讲:投影、选择、笛卡尔积和自然连接。

    1.投影

    关系R上的投影是从R中选择若干属性A1,A2,A3…An组成的新的关系(去掉重复元组)。
     记 丌A1,A2,A3..An (R)    A1,A2,A3…An是R中的属性
     习惯上按所列出的顺序显示
    

    在这里插入图片描述

    2.选择

    关系R上的选择运算,即从指定关系中选择满足一定条件C的元组, 得到新的关系。结果集的模式与R相同。
    记: σC(R)
    C是一个条件,取值为“true”或“false”。
    C由逻辑运算符OR AND NOT 连接各条件表达式组成。
    

    在这里插入图片描述

    3.笛卡尔积

    R和S的笛卡尔积(即乘积)是有序对的集合。
     由R的元组和S的元组构成更长的元组。有序对的
          第1个元素是关系R的任何一个元组
          第2个元素是 关系S的任何一个元组. 
     记作  :  R×S
    

    在这里插入图片描述

    4.自然连接

    由R和S在公共属性上相同的元组成对连接构成(去掉重复的列)
    假设A1,A2,…An为R和S的公共属性,当且仅当R的元组r和S的元组s在A1,A2,…An每一个属性
    上都一致时,r和s才能成功地组成一对。
    

    例图1:在这里插入图片描述
    例图2:
    在这里插入图片描述

    展开全文
  • 集合论、二元关系集合的基数知识概述
  • 偏序关系中的特殊元素问题 偏序关系证明 哈斯图 链 反链
  • 数 据:是描述客观事物的符号,是计算机可以操作的对象,是能被计算机识别,并输入给计算机处理的符号集合,数据不仅仅指我们通常所说的数值类型, 还包括字符及声音,图像,视频等非数值类型 。 数 据 项:在数据...
  • 传统的集合运算和专门的关系运算

    千次阅读 2020-07-14 18:27:14
    一、传统的集合运算 传统的集合运算是二目运算,包括并、差、交、笛卡尔积4种运算。 设关系R和关系S具有相同的目n,也就是两个关系中都有n个属性,且相应的属性取自同一个域,t是元组变量,t∈R表示t是R的一个元组。...
  • 建立在集合代数的基础 1. 1域(Domain) 域是一组具有相同数据类型的值的集合。例: 整数、实数、介于某个取值范围的整数、指定长度的字符串集合、{‘男’,‘女’} 1.2 笛卡尔积(Cartesian Product) 笛卡尔积: ...
  • 我觉得理解这个概念首先就是要和实数数列的上限和下限区分开,要理解上限和下限,我认为还是从能不...他们之间还有着相互包含关系,即上限集包含下限集(上限集>=下限集), 这里是上限集和下限集的定义,参考...
  • 列举法:列出集合中的全体元素,元素之间用逗号分开,然后用花括号括起来 描述法:用谓词P(x)表示x具有性质P,用{x|P(x)}表示具有性质P的集合 注意事项:集合中的元素是各不相同的 ​ 集合中的元素不规定...
  • 关系R和关系S的差是由属于R但不属于S的所有元组组成的集合,即关系R中删去与关系S中相同的元组 3.交 关系R和关系S的交是由既属于R又属于S的元组组成的集合,即在两个关系R和S中取相同的元组,组成一个新关系 4....
  • Java集合框架总结

    万次阅读 多人点赞 2019-08-08 09:13:16
    任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。 接口:表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现,从而达到“多态”。在面向对象编程语言中,接口通常用来形成...
  • 传统的集合运算 (并,差,交,笛卡尔积)  专门的关系运算 并(Union) R和S 具有相同的目n(即两个关系都有n个属性) 相应的属性取自同一个域 R∪S 仍为n目关系,由属于R或属于S的元组组成 R∪S = { t|t ...
  • 一、闭包求法 、 二、求闭包示例 ( 关系图角度 ) 、 三、求闭包示例 ( 关系矩阵角度 ) 、 四、闭包运算与关系性质 、 五、闭包复合运算 、
  • 数据库集合运算与关系代数

    千次阅读 2016-03-17 15:45:44
    D2=年龄集合(AGE)={17,18} 二:笛卡尔积:域定义的一种集合运算,就是将每个域中的元素与其它域中的元素分别去组合,组合得到的笛卡尔积中每一个元素叫做一个元组。如图,是D1和D2的笛卡尔积。 NAME AGE yang 17 ...
  • java集合超详解

    万次阅读 多人点赞 2018-08-03 21:28:15
    一、集合大纲 1.集合和数组的区别: 2.Collection集合的方法: 3.常用集合的分类: Collection 接口的接口 对象的集合(单列集合) ├——-List 接口:元素按进入先后有序保存,可重复 │——...
  • C# 集合类型(常用集合类型整理)

    万次阅读 2018-06-24 09:41:16
    一、常用集合类型及概念 2. 1)List &amp;amp;amp;amp;amp;amp;amp;lt; T &amp;amp;amp;amp;amp;amp;amp;gt; 泛型的List 类是一个不限长度的集合类型,它内部实际就是一个数组,初始长度是4,每次...
  • 常用集合运算符号

    万次阅读 2017-08-02 07:29:13
    最近看论文碰到不少之前从未接触过的符号,因为主要是针对的集合操作,所以这里贴下常见(有些对LZ来说并不常见的一些集合运算符)★ 符号名称:和集 [&] ◆ 符号解释:两个或两个以上的集合的所有元素组成一个新...
  • 关系数据库——关系数据语言

    千次阅读 多人点赞 2019-10-22 19:52:51
    关系 域:一组具有相同数据类型的值的集合(即取值范围) 笛卡尔积:域的一种集合运算。... 关系:域的笛卡尔积的子集叫做在域关系,域的个数叫做关系的目或度。(即数,属性的数目),注意...
  • 关系数据库——关系代数

    千次阅读 2021-04-05 10:56:41
    文章目录关系数据库关系代数关系代数的分类及其运算符传统的集合运算专门的关系运算 关系数据库 关系代数 关系模型与其它模型相比,最有特色的是它的数据库语言 这种语言灵活方便、表达能力和功能都很强 目前关系...
  • 单双列集合

    千次阅读 2015-08-09 11:41:58
    Collection(单列集合顶层接口) 一、Collection接口 1、集合与数组的特点 集合:a、长度可变;b、只能储存引用数据类型;c、同一个集合中可以存储多种数据类型 数组:a、长度不可变;b、可以存储基本数据...
  • Java集合详解(超详细)

    千次阅读 多人点赞 2021-02-02 12:09:47
    这里写目录标题一、集合框架的概述二、Collection接口(一)常用方法(二)Iterator迭代器接口(三)JDK 5.0新特性--增强for循环:(foreach循环)三、Collection子接口:List接口 一、集合框架的概述 集合与数组存储...
  • java中的集合详解

    千次阅读 2020-07-21 15:02:17
    集合集合是java中提供的一种容器,可以用来存储多个数据。集合和数组既然都是容器,它们有啥区别呢? 数组的长度是固定的。集合的长度是可变的。 数组中存储的是同一类型的元素,可以存储基本数据类型值。...
  • 这里,我列出了一些关于Java集合的重要问题和答案。1.Java集合框架是什么?说出一些集合框架的优点?每种编程语言中都有集合,最初的Java版本包含几种集合类:Vector、Stack、HashTable和Array。随着集合的广泛使用...
  • 离散数学之集合

    千次阅读 2020-08-17 17:34:16
    集合元素在集合里面叫做A包含a,记作a E A(打不出来),否则记作a !E A。 集合的描述有:列举法:一一列举几个里面的元素,还有采用集合构造器,叙述法。 区间:有疑问请回顾高中知识。 集合相等:两个集合当且仅当...
  • 【数据库原理】关系代数

    万次阅读 多人点赞 2020-08-15 10:22:56
    关系模型中常用的关系操作包括查询操作和更新操作(包括插入、删除和修改)...从计算机语言角度看,后者在前者的基础工作,前者比后者复杂,但前者有理论基础,所以成为了主要的研究对象,也是关系操作中最主要的部分。
  • Java笔试面试-集合详解(

    万次阅读 多人点赞 2019-09-16 12:02:58
    集合的继承关系图,如下: 其中: 外框为虚线的表示接口,边框为实线的表示类; 箭头为虚线的表示实现了接口,箭头为实线的表示继承了类。 集合的根节点是 Collection,而 Collection 下又提供了两大常用集合,...
  • java集合详解和集合面试题目

    万次阅读 多人点赞 2018-02-12 11:01:14
    一、集合与数组 ...二、层次关系 如图所示:图中,实线边框的是实现类,折线边框的是抽象类,而点线边框的是接口 Collection接口是集合类的根接口,Java中没有提供这个接口的直接的实现类。但是却...
  • 答:关系数据结构、关系操作集合关系完整性约束。 2.解释下列术语的含义: (1)笛卡尔积:设D1,D2,…,Dn为任意集合,定义笛卡尔积D1,D2,…,Dn为: D1×D2× …×Dn ={(d1,d2,…,dn) | di ∈Di,i=1,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,281
精华内容 73,312
关键字:

列出集合上的包含关系