精华内容
下载资源
问答
  • 下列能组成集合的是
    千次阅读
    2021-01-14 22:40:50

    【填空题】表达式 len([i for i in range(10)]) 的值为( )。

    【判断题】Python 中的类( class )具有自身的特殊性,不能看成是一种对象。

    【判断题】1、深槽式轮辋主要用于轻型越野车上。

    【判断题】列表、元组、字符串属于有序序列,而字典和集合属于无序序列。

    【单选题】下列可以作为Python变量名的是( )

    【填空题】表达式 int('123', 16) 的值为( )。

    【单选题】下列叙述正确的是( )

    【单选题】[1,2,3]+[4,5,6] 在功能上等价于列表的哪个方法( )

    【填空题】对象的构造方法名是( )。

    【单选题】已知 x=['1234', 'ab', 'ABC'] ,那么执行语句 sorted(x) 和 sorted(x,key=len) 的结果分别为( )

    【填空题】语句 x = 3,5 执行后, x 的类型为( )。

    【判断题】运动电荷周围没有电场,只有磁场。

    【判断题】4、装有防滑轮胎及防滑钉轮胎的汽车,在雪地上行驶,就不需要装用防滑链。

    【单选题】下面关键字中,用来定义函数的是 ( )

    【单选题】以下说法错误的是( )

    【判断题】PLC 按硬件结构不同分为整体式、模块式和混合式

    【填空题】PLC主要由 、 输入模块 、 和编程器组成。

    【判断题】农村最后一公里快递资源缺乏。

    【单选题】关键字( )用于测试一个对象是否是一个可迭代对象的元素。

    【单选题】Python 表示一个原始字符串,要在字符串前加上哪个字符( )

    【判断题】2、低压胎能提高汽车的动力性、经济性、制动性。

    【单选题】例 L = [1,2,3,4] ,如何得到列表 [1, 4, 27, 256] 。( )

    【单选题】根据下列语句表程序画出梯形图程序,正确的是: LD I0.0 O Q0.0 AN I0.1 AN I0.2 AN Q0.1 = Q0.0

    【单选题】表达式max('1111', '222', '33', '4')的值是( )

    【多选题】电商物流服务平台的功能包括()

    【单选题】下面的转义字符中,表示换行的是( )

    【单选题】函数 定义 fun(*args,**kwargs) 中的形参 args 和 kwargs的 意思是( )

    【判断题】1、低压胎弹性好、断面宽、接地面积大、壁薄散热性好。

    【单选题】设存在一个列表 lst ,从第一个元素开始,隔一个取一个元素形成一个新的列表,则相关语句为( )

    【单选题】下面关于 lambda 表达式的描述中,不正确的是( )

    【填空题】面向对象的主要特征是( )、( )、( )。每空2个字。

    【单选题】已知I0.0是启动按钮,I0.1是停止按钮,关于下图,说法正确的是 。

    【判断题】3、我国货车常用的轮辋为平底是轮辋。

    【单选题】下列叙述不正确的是( )

    【单选题】下面 4 个特点, Python 不具备的是( )

    【判断题】线圈中的顺磁质可以增强总磁场。

    【判断题】梯形图中,若Q0.0的线圈通电时对应的硬件继电器的常开触点闭合。

    【填空题】这种“ x, y, z = range(3) ”同时对多个变量赋值的形式称为( )。该空4个字。

    【单选题】随机生成位于闭区间 [10,20] 内的一个随机整数的方式为( )。

    【单选题】下面运算符中可以支持字符串与整数进行运算的是( )

    【判断题】安培环路定理公式中的B是由环路中的电流决定的。

    【填空题】表达式 [4,5,6] is [4,5,6] 的结果是( ),表达式 [4,5,6] == [4,5,6] 的结果是( )。

    【判断题】3、缓冲层广泛应用于子午线轮胎中。

    【判断题】2、幅板式车轮上,幅板上对称的孔可以减轻质量,利于制动器散热,也便于拆装。

    【判断题】5、按照轮辋的结构不同,车轮可以分为幅板式和辐条式两种

    【判断题】线圈在稳定平衡位置时,受磁力矩为零,此时线圈正法线所指的方向定义为线圈所在处的磁场方向

    【单选题】以下都是不可变数据类型的是( )

    【单选题】例 x='123';y='abc' ,要得到串 'a123b123c' ,下面表达式正确的是( )

    【判断题】磁场的高斯定理表明磁场是有源场。

    【判断题】载流闭合线圈在磁场中合外力为零。

    更多相关内容
  • 设有两个非空集合A和B,每个集合由矩阵的若干列组成集合A和B互斥是指对于矩阵的任意一行,同时满足下列2个条件:1)若A中有一个或多个元素在这一行上的值是1,则B中的元素在这一行全部是0;2)若B中有一个或多个...
  • python集合是可变类型吗

    千次阅读 2020-12-20 11:12:14
    python 集合的元素为什么不是可变数据类型集合(set)是可以变的,它是一个无序不重复元素集 元组(touple)才是不可变的Python 中的可变类型对象和不可变类型是什么意思?Python3 中有六个标准的数据类型(内置数据类型...

    python 集合的元素为什么不能是可变数据类型

    集合(set)是可以变的,它是一个无序不重复元素集 元组(touple)才是不可变的

    Python 中的可变类型对象和不可变类型是什么意思?

    Python3 中有六个标准的数据类型(内置数据类型): Number(数字) String(字符串) List(列表) Tuple(元组) Set(集合) Dictionary(字典) 六个标准数据类型中: 不可变类型(3 个):Number(数字)、String(字符串)、Tuple(元组)

    python中 集合(set)是无序的不可变类型 但是为什集合(set)是可以变的,它是一个无序不重复元素集 元组(touple)才是不可变的

    PYTHON 下列数据类型中哪个是可变数据类型?

    A. 列表 List B. 集合 Sets C. 字典 Dictionary D. 字符串 String

    python很热门,很好学的。 可变数据类型:列表list和字典dict、集合set; 不可变数据类型:字符串型string和元组tuple. 学会做总结: Python 6个标准数据类型.png 所以。

    python 可变不可变类型

    python的数据类型和c不太一样,有一种分类标准,可变(mutable)/不可变(immutable). 我理解的可变,就是在内存中的那块内容(value)是否可以被改变。如果是不可变的,在对对象本身操作的时候,必须在内存的另外地方再申请一块区域(因为老区域#不

    python中的可变数据类型和不可变数据类型的区别

    最近在研究某一博主的代码时偶然发现了一个问题,第一反应肯定是我自己知识上的欠缺。然后经过各种百度啊之类的终于找到了原因。上面就是我遇到的问题,按照我的理解,featLabel这个列表经过函数调用后值应该还是空的,如果普通的参数。

    Python可变类型有哪些

    python可变不可变类型

    可变:list,dict 不可变:str,int,float,complex,tuple

    关于python的可变类型和不可变类型有个问题?

    a = [1,2] b = a id(a) id(b) b = [2,3] id(a) id(b) 为什么第一次两个i第一次a和b都指向了[1,2]这个列表对象,所以id一样,但是第二次b=[2,3]是一个新的赋值语句,它重新生成了一个列表对象,现在b指向的是[2,3]这个对象,所以id自然也变了,列表是可变数据类型的意思是你可以对这个列表对象本身进行改变。

    python中集合的特点和注意点?

    集合的特点: 1.不同元素组成(元素不能重复) 2.无序(集合元素的顺序和定义、添加的顺序不一致) 3.集合中的元素必须是不可变类型 集合的注意点: 1.定义一个集合,如果直接写my_set = {},不添加数据,python解释器会把my_set作为字典处理 2

    展开全文
  • 首先给出结论,ArrayList,LinkedList,HashMap,StringBuilder是不安全的...Java API中所用的集合类,都是实现了Collection接口,他的一个类继承结构如下: Collection<–List<–Vector Collection<–Li...

    首先给出结论,ArrayList,LinkedList,HashMap,StringBuilder是不安全的。vector,HashTable,StringBuffer是线程安全的。下面用代码来看看。


    Java API中所用的集合类,都是实现了Collection接口,他的一个类继承结构如下: Collection<–List<–Vector Collection<–List<–ArrayList Collection<–List<–LinkedList Collection<–Set<–HashSet Collection<–Set<–HashSet<–LinkedHashSet Collection<–Set<–SortedSet<–TreeSet 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的对应存储项。
    1. ArrayList测试
    package testThread;
    
    import java.util.ArrayList;
    import java.util.List;
    
    class Ticket implements  Runnable {
        private static int t=0;
        List<Integer> data = new ArrayList<>();
        boolean flag=true;  
        public void run() { 
            while (flag) {
                if (t<100) {
                      data.add(t);
                      t++;
                      //System.out.println(t);
                        }else {                                             
                            flag=false;
                            System.out.println("数据宽度"+data.size());                                 
                            for (int i = 0; i < data.size(); i++) {
                                System.out.println(data.get(i));
                            }
                        }           
            }
    
        }   
    }
    public class thread1 {
         public static  void main(String[] args)
         {
            Ticket t=new Ticket();
            Thread t1=new Thread(t);   
            Thread t2=new Thread(t);
            Thread t3=new Thread(t);
            t1.start();
            t2.start();     
            t3.start();
    
         }
    }
    
    
    

    ArrayList测试结果
    这里写图片描述
    2.LinkedList

    package te;
    import java.util.LinkedList;
    import java.util.List;
    
    class Ticket implements  Runnable {
        private static int t=0;
        List<Integer> data = new LinkedList<Integer>();
        boolean flag=true;  
        public void run() { 
            while (flag) {
                if (t<100) {
                      data.add(t);
                      t++;
                      //System.out.println(t);
                        }else {                                             
                            flag=false;
                            System.out.println("数据宽度"+data.size());                                 
                            for (int i = 0; i < data.size(); i++) {
                                System.out.println(data.get(i));
                            }
                        }           
            }
    
        }   
    }
    public class Thread7 {
         public static  void main(String[] args)
         {
            Ticket t=new Ticket();
            Thread t1=new Thread(t);   
            Thread t2=new Thread(t);
            Thread t3=new Thread(t);
            t1.start();
            t2.start();     
            t3.start();
    
         }
    }
    
    
    

    LinkedList结果
    这里写图片描述

    3.HashMap

    package te;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    
    class Ticket implements  Runnable {
        private static int t=0;
        Map data = new HashMap<Integer,Integer>();
        boolean flag=true;  
        public void run() { 
            while (flag) {
                if (t<100) {
                      data.put(t,t);
                      t++;
                      //System.out.println(t);
                        }else {                                             
                            flag=false;                                                         
                            Collection da=data.values();
                            Iterator<Integer> it=da.iterator();
                            while (it.hasNext()) {
                                Integer integer = (Integer) it.next();
                                System.err.println(integer);
    
                            }
                        }           
            }
    
        }   
    }
    public class Thread7 {
         public static  void main(String[] args)
         {
            Ticket t=new Ticket();
            Thread t1=new Thread(t);   
            Thread t2=new Thread(t);
            Thread t3=new Thread(t);
            t1.start();
            t2.start();     
            t3.start();
    
         }
    }
    
    
    

    HashMap测试
    这里写图片描述
    4.vector

    package te;
    import java.util.Vector;
    
    class Ticket implements  Runnable {
        private static int t=0;
        Vector<Integer> vector=new Vector<Integer>();
        boolean flag=true;  
        public void run() { 
            while (flag) {
                if (t<100) {
                      vector.add(t);
                      t++;            
                        }else {                                             
                            flag=false;                                                         
                            for(int i=0;i<vector.size();i++)
                            {
                                System.out.println(vector.get(i));
                            }
                        }           
            }
    
        }   
    }
    public class Thread7 {
         public static  void main(String[] args)
         {
            Ticket t=new Ticket();
            Thread t1=new Thread(t);   
            Thread t2=new Thread(t);
            Thread t3=new Thread(t);
            t1.start();
            t2.start();     
            t3.start();
    
         }
    }
    
    
    

    vector线程是安全的
    5.stringbuilder和stringbuffer

    package te;
    
    class Ticket implements  Runnable {
        private static int t=0;
    
         StringBuffer sb = new StringBuffer();  
         StringBuilder sc=new StringBuilder();
        boolean flag=true;  
         public void run() {    
            while (flag) {
                if (t<100) {
                      sb.append(t+"a ");
                      sc.append(t+"a ");
                      t++;            
                        }else {                                             
                            flag=false;                                                         
                            System.out.println("stringbuffer"+sb);
                            System.out.println("stringbuilder"+sc);
                        }           
            }
    
        }   
    }
    public class Thread7 {
         public static  void main(String[] args)
         {
            Ticket t=new Ticket();
            Thread t1=new Thread(t);   
            Thread t2=new Thread(t);
            Thread t3=new Thread(t);
            t1.start();
            t2.start();     
            t3.start();
    
         }
    }
    
    
    

    结果测试 stringbuilder是不安全的
    这里写图片描述

    6.分析总结
    凡是线程不安全的,我们可以来看源码来分析 ,这是arraylist的源码,我们很容易发现这是由于没有synchronized关键字。

     public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
          

    再来看看vector,有synchronized关键字。

     public synchronized boolean add(E e) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = e;
            return true;
        }
    
    
    展开全文
  • 数 据:是描述客观事物的符号,是计算机可以操作的对象,是能被计算机识别,并输入给计算机处理的符号集合,数据不仅仅指我们通常所说的数值类型, 还包括字符及声音,图像,视频等非数值类型 。 数 据 项:在数据...

    先讲下什么是数据结构

            程序设计= 数据结构 + 算法

    数据结构由以下构成:

    1.  数      据:是描述客观事物的符号,是计算机可以操作的对象,是能被计算机识别,并输入给计算机处理的符号集合,数据不仅仅指我们通常所说的数值类型, 还包括字符及声音,图像,视频等非数值类型 。
    2. 数 据  项:在数据结构中,我们把数据项定义为最小单位,是有助于我们更好的解决问题。
    3. 数据元素:一个数据元素可以由若干个数据项组成,并且有一定意义的基本单位,在计算机中通常作为整体处理,也被成为记录。例如如人由眼,耳,手,鼻,口,脚,这些数据项 数据项是数据不可分割的最小单位,组成一个数据元素。数据元素才是我们在数据结构建立数据模型的着眼点。
    4. 数据类型:在一种程序设计语言中,变量所具有的数据种类。整型、浮点型、字符型等等 ​​​​​​
    5. 物理结构/存储结构:数据在计算机中的表示。物理结构是描述数据具体在内存中的存储(如:顺序结构、链式结构、索引结构、哈希结构等。
    6. 逻辑结构:数据之间的相互关系。在数据结构中,从逻辑上可以将其分为线性结构和非线性结构
    •  集合 结构中的数据元素除了同属于一种类型外,别无其它关系。
    • 线性结构 数据元素之间一对一的关系
    • 树形结构 数据元素之间一对多的关系
    • 图状结构或网状结构 结构中的数据元素之间存在多对多的关系

    总结:数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系,并对这种结构定义相应的运算,而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。

    算法的概念:

       算法:算法是计算机处理信息的本质,因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务。

       算法的五大特性

    1. 输入: 算法具有0个或多个输入。
    2. 输出: 算法至少有1个或多个输出。
    3. 有穷性: 算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成。
    4. 确定性:算法中的每一步都有确定的含义,不能出现歧义。
    5. 可行性:算法的每一步都是可行的,也就是说每一步都能够执行有限的次数完成。

    java中数据结构有什么用?

    当你用着java里面的容器类很爽的时候,你有没有想过,怎么ArrayList就像一个无限扩充的数组,也好像链表之类的。好用吗?好用,这就是数据结构的用处,只不过你在不知不觉中使用了。

    现实世界的存储,我们使用的工具和建模。每种数据结构有自己的优点和缺点,想想如果Google的数据用的是数组的存储,我们还能方便地查询到所需要的数据吗?而算法,在这么多的数据中如何做到最快的插入,查找,删除,也是在追求更快。

     

    我们java是面向对象的语言,就好似自动档轿车,C语言好似手动档吉普。数据结构呢?是变速箱的工作原理。你完全可以不知道变速箱怎样工作,就把自动档的车子从 A点 开到 B点,而且未必就比懂得的人慢。写程序这件事,和开车一样,经验可以起到很大作用,但如果你不知道底层是怎么工作的,就永远只能开车,既不会修车,也不能造车。当然了,数据结构内容比较多,细细的学起来也是相对费功夫的,不可能达到一蹴而就。我们将常见的数据结构:堆栈、队列、数组、链表和红黑树 这几种给大家介绍一下。

    数据存储的常用结构有:栈、队列、数组、链表和红黑树。我们分别来了解一下:

    • 栈:stack,又称堆栈,它是运算受限的线性表,其限制是仅允许在标的一端进行插入和删除操作,不允许在其他任何位置进行添加、查找、删除等操作。简单的说:采用该结构的集合,对元素的存取有如下的特点
    • 先进后出(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素)。例如,子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先弹出上面的子弹,然后才能弹出下面的子弹。
    • 栈的入口、出口的都是栈的顶端位置。

                        

    • 压栈:就是存元素。即,把元素存储到栈的顶端位置,栈中已有元素依次向栈底方向移动一个位置。
    • 弹栈:就是取元素。即,把栈的顶端位置元素取出,栈中已有元素依次向栈顶方向移动一个位置。

    队列

    • 队列queue,简称队,它同堆栈一样,也是一种运算受限的线性表,其限制是仅允许在表的一端进行插入,而在表的另一端进行删除。

    简单的说,采用该结构的集合,对元素的存取有如下的特点:

    • 先进先出(即,存进去的元素,要在后它前面的元素依次取出后,才能取出该元素)。例如,小火车过山洞,车头先进去,车尾后进去;车头先出来,车尾后出来。
    • 队列的入口、出口各占一侧。例如,下图中的左侧为入口,右侧为出口。

    数组 

    • 数组:Array,是有序的元素序列,数组是在内存中开辟一段连续的空间,并在此空间存放元素。就像是一排出租屋,有100个房间,从001到100每个房间都有固定编号,通过编号就可以快速找到租房子的人。

    简单的说,采用该结构的集合,对元素的存取有如下的特点:

    • 查找元素快:通过索引,可以快速访问指定位置的元素。

    • 增删元素慢,指定索引位置增加元素:需要创建一个新数组,将指定新元素存储在指定索引位置,再把原数组元素根据索引,复制到新数组对应索引的位置。如下图

    • 指定索引位置删除元素:**需要创建一个新数组,把原数组元素根据索引,复制到新数组对应索引的位置,原数组中指定索引位置元素不复制到新数组中。如下图
    •  

     

    红黑树

     

    • 二叉树**:binary tree ,是每个结点不超过2的有序树(tree)

    简单的理解,就是一种类似于我们生活中树的结构,只不过每个结点上都最多只能有两个子结点。

    二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点,两边被称作“左子树”和“右子树”。

    如图:

    我们要说的是二叉树的一种比较有意思的叫做红黑树,红黑树本身就是一颗二叉查找树,将节点插入后,该树仍然是一颗二叉查找树。也就意味着,树的键值仍然是有序的。

    红黑树的约束:

    1. 节点可以是红色的或者黑色的

    2. 根节点是黑色的

    3. 叶子节点(特指空节点)是黑色的

    4. 每个红色节点的子节点都是黑色的

    5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

    红黑树的特点:

    ​ 速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

     

    好了开始说正事哈:

    java集合体系:

    单例集合 的体系:

    ---------| Collection 单例集合的根接口

    ------------------| List  如果是实现了List接口的集合类, 具备的特点:有序,重复。

    -------------------------| ArraryList  底层 是使用了Object数组实现的,特点: 查询速度快,增删慢。

    -------------------------| LinkedList 底层是使用了链表数据结构实现 的, 特点: 查询速度慢,增删快。

    -------------------------| Vector Vector的实现与ArrayList是一致,但是是线程安全 的,操作效率低。 jdk1.0的时候出现的

    ------------------| Set  如果是实现了Set接口的集合类,具备的特点:无序,不可重复。

    --------------------------| HashSet  底层是使用了一个哈希表支持的, 特点:存取速度快。

    ---------------------------------| LinkedHashSet 继承了HashSet  链表和哈希表组合的一个数据存储结构。 特点:有顺序的插入。

    --------------------------| TreeSet  底层是使用了红黑树(二叉树)数据结构实现的, 特点:会对元素进行排序存储。(目前已经被淘汰了。)

     

    双列集合:
    -------------| Map  如果是实现了Map接口的集合类,具备的特点: 存储的数据都是以键值对的形式存在的,键不可重复,值可以重复。

    ----------------------| HashMap<K,V>

    --------------------------------| LinkedHashMap<K,V> :继承HashMap,存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

    ----------------------| TreeMap

    ----------------------| Hashtable 

     

     

    1.1 List接口介绍

    java.util.List接口继承自Collection接口,是单列集合的一个重要分支,习惯性地会将实现了`List`接口的对象称为List集合。在List集合中允许出现重复的元素,所有的元素是以一种线性方式进行存储的,在程序中可以通过索引来访问集合中的指定元素。另外,List集合还有一个特点就是元素有序,即元素的存入顺序和取出顺序一致。

    看完API,我们总结一下:

    List接口特点:

    1. 它是一个元素存取有序的集合。例如,存元素的顺序是11、22、33。那么集合中,元素的存储就是按照11、22、33的顺序完成的)。

    2. 它是一个带有索引的集合,通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)。

    3. 集合中可以有重复的元素,通过元素的equals方法,来比较是否为重复的元素。

    1.2 List接口中常用方法

    List作为Collection集合的子接口,不但继承了Collection接口中的全部方法,而且还增加了一些根据元素索引来操作集合的特有方法,如下:

    • public void add(int index, E element): 将指定的元素,添加到该集合中的指定位置上。

    • public E get(int index):返回集合中指定位置的元素。

    • public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。

    • public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

    List集合特有的方法

    public class ListDemo {
        public static void main(String[] args) {
    
             // 创建List集合对象
        	List<String> list = new ArrayList<String>();
        	
        	// 往 尾部添加 指定元素
        	list.add("图图");
        	list.add("小美");
        	list.add("不高兴");
        	
        	System.out.println(list);
        	// add(int index,String s) 往指定位置添加
        	list.add(1,"没头脑");
        	
        	System.out.println(list);
        	// String remove(int index) 删除指定位置元素  返回被删除元素
        	// 删除索引位置为2的元素 
        	System.out.println("删除索引位置为2的元素");
        	System.out.println(list.remove(2));
        	
        	System.out.println(list);
        	
        	// String set(int index,String s)
        	// 在指定位置 进行 元素替代(改) 
        	// 修改指定位置元素
        	list.set(0, "三毛");
        	System.out.println(list);
        	
        	// String get(int index)  获取指定位置元素
        	
        	// 跟size() 方法一起用  来 遍历的 
        	for(int i = 0;i<list.size();i++){
        		System.out.println(list.get(i));
        	}
        	//还可以使用增强for
        	for (String string : list) {
    			System.out.println(string);
    		}  	
    	}
    }

    List的子类 

    ------------------- ArrayList集合

     java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢,查找快,由于日常开发中使用最多的功能为查询数据、遍历数据,所以ArrayList是最常用的集合。

    许多程序员开发时非常随意地使用ArrayList完成任何需求,并不严谨,这种用法是不提倡的。

    ------------------- LinkedList集合

    java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

    LinkedList是一个双向链表,那么双向链表是什么样子的呢,我们用个图了解下

     

    实际开发中对一个集合元素的添加与删除经常涉及到首尾操作,而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可:

    • public void addFirst(E e):将指定元素插入此列表的开头。

    • public void addLast(E e):将指定元素添加到此列表的结尾。

    • public E getFirst():返回此列表的第一个元素。

    • public E getLast():返回此列表的最后一个元素。

    • public E removeFirst():移除并返回此列表的第一个元素。

    • public E removeLast():移除并返回此列表的最后一个元素。

    • public E pop():从此列表所表示的堆栈处弹出一个元素。

    • public void push(E e):将元素推入此列表所表示的堆栈。

    • public boolean isEmpty():如果列表不包含元素,则返回true。

    LinkedList是List的子类,List中的方法LinkedList都是可以使用,这里就不做详细介绍,我们只需要了解LinkedList的特有方法即可。在开发时,LinkedList集合也可以作为堆栈,队列的结构使用。

    public class LinkedListDemo {
        public static void main(String[] args) {
            LinkedList<String> link = new LinkedList<String>();
            //添加元素
            link.addFirst("abc1");
            link.addFirst("abc2");
            link.addFirst("abc3");
            System.out.println(link);
            // 获取元素
            System.out.println(link.getFirst());
            System.out.println(link.getLast());
            // 删除元素
            System.out.println(link.removeFirst());
            System.out.println(link.removeLast());
    
            while (!link.isEmpty()) { //判断集合是否为空
                System.out.println(link.pop()); //弹出集合中的栈顶元素
            }
    
            System.out.println(link);
        }
    }

    Set接口 

    java.util.Set接口和java.util.List接口一样,同样继承自Collection接口,它与Collection接口中的方法基本一致,并没有对Collection接口进行功能上的扩充,只是比Collection接口更加严格了。与List接口不同的是,Set接口中元素无序,并且都会以某种规则保证存入的元素不出现重复。

    Set集合有多个子类,这里我们介绍其中的java.util.HashSetjava.util.LinkedHashSet这两个集合。

    tips:Set集合取出元素的方式可以采用:迭代器、增强for。

    HashSet集合介绍 

    java.util.HashSetSet接口的一个实现类,它所存储的元素是不可重复的,并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持,由于我们暂时还未学习,先做了解。

    HashSet是根据对象的哈希值来确定元素在集合中的存储位置,因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于:hashCodeequals方法。

    我们先来使用一下Set集合存储,看下现象,再进行原理的讲解:

    public class HashSetDemo {
        public static void main(String[] args) {
            //创建 Set集合
            HashSet<String>  set = new HashSet<String>();
    
            //添加元素
            set.add(new String("cba"));
            set.add("abc");
            set.add("bac"); 
            set.add("cba");  
            //遍历
            for (String name : set) {
                System.out.println(name);
            }
        }
    }

    输出结果如下,说明集合中不能存储重复元素: 

    cba
    abc
    bac

    tips:根据结果我们发现字符串"cba"只存储了一个,也就是说重复的元素set集合不存储。 

     

    HashSet集合存储数据的结构(哈希表)

    什么是哈希表呢?

    JDK1.8之前,哈希表底层采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。而JDK1.8中,哈希表存储采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。

    简单的来说,哈希表是由数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的,如下图所示。

    看到这张图就有人要问了,这个是怎么存储的呢?

    为了方便大家的理解我们结合一个存储流程图来说明一下:

     总而言之,JDK1.8引入红黑树大程度优化了HashMap的性能,那么对于我们来讲保证HashSet集合元素的唯一,其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象,那么保证其唯一,就必须复写hashCode和equals方法建立属于当前对象的比较方式。

    HashSet存储自定义类型元素

    给HashSet中存放自定义类型元素时,需要重写对象中的hashCode和equals方法,建立自己的比较方式,才能保证HashSet集合中的对象唯一

    创建自定义Student类

    public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            Student student = (Student) o;
            return age == student.age &&
                   Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
    public class HashSetDemo2 {
        public static void main(String[] args) {
            //创建集合对象   该集合中存储 Student类型对象
            HashSet<Student> stuSet = new HashSet<Student>();
            //存储 
            Student stu = new Student("于谦", 43);
            stuSet.add(stu);
            stuSet.add(new Student("郭德纲", 44));
            stuSet.add(new Student("于谦", 43));
            stuSet.add(new Student("郭麒麟", 23));
            stuSet.add(stu);
    
            for (Student stu2 : stuSet) {
                System.out.println(stu2);
            }
        }
    }
    执行结果:
    Student [name=郭德纲, age=44]
    Student [name=于谦, age=43]
    Student [name=郭麒麟, age=23]

     LinkedHashSet

    我们知道HashSet保证元素唯一,可是元素存放进去是没有顺序的,那么我们要保证有序,怎么办呢?

    在HashSet下面有一个子类java.util.LinkedHashSet,它是

    演示代码如下:

    public class LinkedHashSetDemo {
    	public static void main(String[] args) {
    		Set<String> set = new LinkedHashSet<String>();
    		set.add("bbb");
    		set.add("aaa");
    		set.add("abc");
    		set.add("bbc");
            Iterator<String> it = set.iterator();
    		while (it.hasNext()) {
    			System.out.println(it.next());
    		}
    	}
    }
    结果:
      bbb
      aaa
      abc
      bbc

     

    TreeSet(目前已经被淘汰了)


    ------------------| TreeSet  底层是使用了红黑树(二叉树)数据结构实现的, 特点:会对元素进行排序存储。
    TreeSet要注意的事项:
        1. 往TreeSet添加元素的时候,如果元素本身具备自然顺序的特性,那么会根据元素自然顺序的特性进行排序存储。
        2. 往TreeSet添加元素的时候,如果元素本身不具备自然顺序的特性,那么元素所属的类必须要实现Comparable接口,把元素的比较规则定义
        在CompareTo方法上。
        3. 往TreeSet添加元素的时候,如果元素本身不具备自然顺序的特性,而且元素所属的类没有实现COmparable接口,那么必须要在创建
        TreeSet对象的时候传入比较器。
        4. 如果比较的方法(CompareTo 或者Compare )返回的是0的时候,那么该元素就被视为重复元素,不允许添加。
        比较器的定义格式:  自定义一个类实现COmparator接口即可。    
            class 类名  implements Comparator{    
            }

     

    泛型


    泛型:泛型是jdk1.5出现的新特性。
    泛型的好处:
        1. 将运行时出现 的问题提前至了编译时。
        2. 避免了无谓强制类型转换。
    自定义泛型: 自定义泛型就是一个数据类型的占位符或者理解为一个数据类型的变量。    
    泛型方法:
        修饰符  <声明自定义的泛型>返回值类型  函数名(自定义的泛型  变量名..)
    泛型方法要注意的事项: 
        1. 泛型方法中 的自定义泛型的具体数据类型是在调用该函数的时候传入实参时确定的。
        2. 自定义泛型所用 的标识符只要符合标识符 的命名规则即可。但是我们一般都习惯使用一个大写字母表示。
    泛型类:
        泛型类的定义格式    
            class 类名<声明自定义的泛型>{    
            }
    泛型类要注意的事项:
        1. 泛型类上的自定义泛型是在使用该类创建对象的时候指定具体的数据类型的。
        2. 如果一个类已经自定义了泛型,使用该类创建对象的时候如果没有指定泛型的具体数据类型,那么默认为Object类型。
        3. 静态的函数不能使用类上自定义的泛型,如果静态函数需要使用,必须要在函数上自定义泛型。
    泛型接口:
        泛型接口的定义格式:
            
            interface 接口名<声明自定义的泛型>{
            }
        
    泛型接口要注意事项:
        1. 泛型接口上的自定义泛型是在实现该接口的时候指定具体数据类型的。
        2. 如果实现接口的时候没有指定接口上 的自定义泛型的具体数据类型,那么默认为Object数据类型。
        3. 如果需要在创建接口实现类对象的时候才指定接口上自定义泛型,那么需要以下格式:    class<T> 类名  implements  接口<T>

    泛型上下限:
        ? super Integer   允许是Integer数据类型或者是Integer父类类型       泛型的下限
        ?  extedns Number  允许是Number数据类型或者是Number子类的数据类型   泛型的上限。

     

     

    双列集合:


    -------------| Map  如果是实现了Map接口的集合类,具备的特点: 存储的数据都是以键值对的形式存在的,键不可重复,值可以重复。

    -------------------| HashMap 

    -----------------------------| LinkedHashMap 

    ------------------| TreeMap

    ------------------| Hashtable 
     

     

    Map接口中的常用方法

    • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。

    • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的值。

    • public V get(Object key) 根据指定的键,在Map集合中获取对应的值。

    • boolean containsKey(Object key) 判断集合中是否包含指定的键。

    • public Set<K> keySet(): 获取Map集合中所有的键,存储到Set集合中。

    • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

         
         添加:
             put(K key, V value) 
             putAll(Map<? extends K,? extends V> m) 
         
         删除
             remove(Object key) 
             clear() 

         获取:
             get(Object key) 
             size() 
         
         判断:
             containsKey(Object key) 
             containsValue(Object value) 
             isEmpty() 

    Map接口的方法演示

    public class MapDemo {
        public static void main(String[] args) {
            //创建 map对象
            HashMap<String, String>  map = new HashMap<String, String>();
    
            //添加元素到集合
            map.put("黄晓明", "杨颖");
            map.put("文章", "马伊琍");
            map.put("邓超", "孙俪");
            System.out.println(map);
    
            //String remove(String key)
            System.out.println(map.remove("邓超"));
            System.out.println(map);
    
            // 想要查看 黄晓明的媳妇 是谁
            System.out.println(map.get("黄晓明"));
            System.out.println(map.get("邓超"));    
        }
    }

     

    tips:使用put方法时,若指定的键(key)在集合中没有,则没有这个键对应的值,返回null,并把指定的键值添加到集合中;

    若指定的键(key)在集合中存在,则返回值为集合中键对应的值(该值为替换前的值),并把指定键所对应的值,替换成指定的新值。

    Map集合遍历键找值方式

    键找值方式:即通过元素中的键,获取键所对应的值

    分析步骤:

    1. 获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示:keyset()

    2. 遍历键的Set集合,得到每一个键。

    3. 根据键,获取键所对应的值。方法提示:get(K key)

    代码演示:

    public class MapDemo01 {
        public static void main(String[] args) {
            //创建Map集合对象 
            HashMap<String, String> map = new HashMap<String,String>();
            //添加元素到集合 
            map.put("胡歌", "霍建华");
            map.put("郭德纲", "于谦");
            map.put("薛之谦", "大张伟");
    
            //获取所有的键  获取键集
            Set<String> keys = map.keySet();
            // 遍历键集 得到 每一个键
            for (String key : keys) {
              	//key  就是键
                //获取对应值
                String value = map.get(key);
                System.out.println(key+"的CP是:"+value);
            }  
        }
    }

    遍历图解:

     

     

    Entry键值对对象

    我们已经知道,Map中存放的是两种对象,一种称为key(键),一种称为value(值),它们在在Map中是一一对应关系,这一对对象又称做Map中的一个Entry(项)Entry将键值对的对应关系封装成了对象。即键值对对象,这样我们在遍历Map集合时,就可以从每一个键值对(Entry)对象中获取对应的键与对应的值。

    既然Entry表示了一对键和值,那么也同样提供了获取对应键和对应值得方法:

    • public K getKey():获取Entry对象中的键。

    • public V getValue():获取Entry对象中的值。

    在Map集合中也提供了获取所有Entry对象的方法:

    • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

    Map集合遍历键值对方式

    键值对方式:即通过集合中每个键值对(Entry)对象,获取键值对(Entry)对象中的键与值。

    操作步骤与图解:

    1. 获取Map集合中,所有的键值对(Entry)对象,以Set集合形式返回。方法提示:entrySet()

    2. 遍历包含键值对(Entry)对象的Set集合,得到每一个键值对(Entry)对象。

    3. 通过键值对(Entry)对象,获取Entry对象中的键与值。 方法提示:getkey() getValue()

    4. public class MapDemo02 {
          public static void main(String[] args) {
              // 创建Map集合对象 
              HashMap<String, String> map = new HashMap<String,String>();
              // 添加元素到集合 
              map.put("胡歌", "霍建华");
              map.put("郭德纲", "于谦");
              map.put("薛之谦", "大张伟");
      
              // 获取 所有的 entry对象  entrySet
              Set<Entry<String,String>> entrySet = map.entrySet();
      
              // 遍历得到每一个entry对象
              for (Entry<String, String> entry : entrySet) {
                 	// 解析 
                  String key = entry.getKey();
                  String value = entry.getValue();  
                  System.out.println(key+"的CP是:"+value);
              }
          }
      }

      遍历图解:

    tips:Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

    HashMap
      HashMap的存储原理:
        往HashMap添加元素的时候,首先会调用键的hashCode方法得到元素 的哈希码值,然后经过运算就可以算出该
        元素在哈希表中的存储位置。 
        情况1: 如果算出的位置目前没有任何元素存储,那么该元素可以直接添加到哈希表中。
        情况2:如果算出 的位置目前已经存在其他的元素,那么还会调用该元素的equals方法与这个位置上的元素进行比较
        ,如果equals方法返回 的是false,那么该元素允许被存储,如果equals方法返回的是true,那么该元素被视为
        重复元素,不允存储。

    public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }

    编写测试类: 

    public class HashMapTest {
        public static void main(String[] args) {
            //1,创建Hashmap集合对象。
            Map<Student,String>map = new HashMap<Student,String>();
            //2,添加元素。
            map.put(newStudent("lisi",28), "上海");
            map.put(newStudent("wangwu",22), "北京");
            map.put(newStudent("zhaoliu",24), "成都");
            map.put(newStudent("zhouqi",25), "广州");
            map.put(newStudent("wangwu",22), "南京");
            
            //3,取出元素。键找值方式
            Set<Student>keySet = map.keySet();
            for(Student key: keySet){
                Stringvalue = map.get(key);
                System.out.println(key.toString()+"....."+value);
            }
        }
    }

     

    • 当给HashMap中存放自定义对象时,如果自定义对象作为key存在,这时要保证对象唯一,必须复写对象的hashCode和equals方法(如果忘记,请回顾HashSet存放自定义对象)。

    • 如果要保证map中存放的key和取出的顺序一致,可以使用java.util.LinkedHashMap集合来存放。

    LinkedHashMap

    我们知道HashMap保证成对元素唯一,并且查询速度很快,可是成对元素存放进去是没有顺序的,那么我们要保证有序,还要速度快怎么办呢?

    在HashMap下面有一个子类LinkedHashMap,它是链表和哈希表组合的一个数据存储结构。

    public class LinkedHashMapDemo {
        public static void main(String[] args) {
            LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
            map.put("邓超", "孙俪");
            map.put("李晨", "范冰冰");
            map.put("刘德华", "朱丽倩");
            Set<Entry<String, String>> entrySet = map.entrySet();
            for (Entry<String, String> entry : entrySet) {
                System.out.println(entry.getKey() + "  " + entry.getValue());
            }
        }
    }

    结果:

    邓超  孙俪
    李晨  范冰冰
    刘德华  朱丽倩

     TreeMap(基本没人使用了)

    TreeMap   TreeMap也是基于红黑树(二叉树)数据结构实现 的, 特点:会对元素的键进行排序存储。

    TreeMap 要注意的事项:
        1.  往TreeMap添加元素的时候,如果元素的键具备自然顺序,那么就会按照键的自然顺序特性进行排序存储。
        2.  往TreeMap添加元素的时候,如果元素的键不具备自然顺序特性, 那么键所属的类必须要实现Comparable接口,把键
        的比较规则定义在CompareTo方法上。
        
        3. 往TreeMap添加元素的时候,如果元素的键不具备自然顺序特性,而且键所属的类也没有实现Comparable接口,那么就必须
        在创建TreeMap对象的时候传入比较器

     

    常见面试题   HashMap 和 HashTable 有什么区别?

    1. HashMap 是线程不安全的,HashMap 是一个接口,是 Map 的一个子接口,是将键映射到值得对象,不允许键值重复,允许空键和空值;由于非线程安全,HashMap 的效率要较 HashTable 的效率高一些.
    2. HashTable 是线程安全的一个集合,不允许 null 值作为一个 key 值或者 Value 值;
    3. HashTable 是 sychronize,多个线程访问时不需要自己为它的方法实现同步,而 HashMap 在被多个线程访问的时候需要自己为它的方法实现同步

     

    最后再赋两张图

    最后最后  :写文章不易,未经本人许可,严禁转载!!!!!

    展开全文
  • 下列各个集合说出集合C与集合AB之间的关系吗 1A={ab}B={cd },C={abcd}; 2 A={ 1,3,5 },B={ 2,4,6 };C={ 1,2,3,4,5,6 } 3A={xx是有理数}B={x x是无理数} C={x x是实数}; 一般地,由所有属于集合A或属于集合B的...
  • [Java集合篇] Collection 单列集合和 Map 双列集合的区别与遍历写在前面1.Collection 单列集合2. List 集合接口下的子类3....数组的长度是固定的,当添加的元素超过了数组的长度时需要对数组重新定义,而集合能存储...
  • 人教B版必修第一册 逆袭之路 第一... 用适当的方法表示下列集合 1方程 的所有解组成集合 A 2平面直角坐标系中第一象限内所有点组成集合 B. ) 3. 用适当的方法表示下列集合 1由方程 的所有实数根组成集合 2由小于
  • Python中集合的常用操作

    千次阅读 2021-09-26 11:00:42
    1、定义:集合是无序的,集合中的元素是唯一的,集合一般用于元组或者列表中的元素去重。 2、特性:集合的目的是将不同的值存放在一起,不同的集合间用来做关系运算,无须纠结于集合中的单个值。 (1、不同元素...
  • 下列哪项类型数据是不可变化的:

    千次阅读 2020-12-05 00:57:57
    下列哪项类型数据是不可变化的:自顶向下的设计也被称为逐步细化。((2>=2)or(2<2)and 2)的结果是True。以下不创建一个字典的语句是:字符串是一个字符序列,例如,字符串s,从右侧向左第2个字符用什么索引?...
  • 【多选题】路由器A的G0/0/1接口配置信息如下,下列说法正确的有?(多选) acl number 3000 rule 5 deny 17 rule 10 deny 89 rule 15 deny 6 # interface GigabitEthernet0/0/1 traffic-filter inbound acl 3000 #【单选...
  • 1.1.1+集合的概念与表示+... 用描述法表示下列集合 1小于10的所有有理数组成集合 2所有奇数组成集合 3平面 内到定点 的距离等于定长 的所有点组成集合 . ) 3. 已知集合 若 . 1求实数 的值 2如果集合 是集合 的列举表示
  • 1.1.1+集合的概念与表示+教学设计1-北师大版高中数学必修第一册 一解答题 ) 1. 用列举法表示下列集合 1由大于3且小于10的所有整数组成的集合 2方程 的... 用描述法表示下列集合 1小于10的所有有理数组成集合 2所有奇
  • 用列举法表示下列集合 1小于10的所有自然数组成集合 2方程 的所有实数根组成集合. ) 2. 试分别用描述法和列举法表示下列集合 1方程 的所有实数根组成集合 A 2由大于10且小于20的所有整数组成集合 B. ) 3. ...
  • 考察下列每组对象能组成一个集合的是 某高中高一年级聪明的学生直角坐标系中横纵坐标相等的点 不小于3的正整数 的近似值 A B C D ) 2. 下列关系中正确的是 A B C D ) 3. 已知集合 那么下列结论正确的是 A B C D ) 4...
  • 1 第 3 题 主存存储单元是指 ( ) A.存放一个二进制信息位的存储元 B.存放一个机器字的所有...硬件和软件结合来 答案:C 2第 5 题 下列不属于计算机科学奠基人冯 诺伊曼思想的是 A.存储程序 B.二进制运算 C.流水线 D.将
  • 计算机组成原理——指令系统

    千次阅读 多人点赞 2021-11-04 15:12:00
    一台计算机中所有机器指令的集合,称为这台计算机的指令系统(指令集)。指令系统是表征一台计算机性能的重要因素,它的格式与功能不仅影响到机器的硬件结构,而且影响到系统软件。因为指令是设计一台计算机的硬件与...
  • 2集合的基本运算

    千次阅读 2020-12-19 01:26:39
    集合的基本运算一、教学目标1、知识与技能(1)理解并集和交集的含义,会求两个简单集合的交集与并集(2)能够使用Venn图表达两个集合的运算,体会直观图像对抽象概念理解的作用2、过程与方法(1)进一步体会类比的作用(2)...
  • 【单选题】下列关于Map集合的使用说法错误的一项是( )。 【单选题】关于履行合同中争议的解决,下列做法正确的是( )。 【填空题】网络协议的组成部分包含()、()、()。 【单选题】光纤的纤芯折射率应( )包层的折射率...
  • a) 显示 A 和 B 的结果。要求每行最多显示10个数,每个数占 5 列,右对 齐; b) 要求用户输入 A | B 和 A & B 的结果,并告诉用户他(或她)的答案是 否正确。 如果用户回答错误,允许他(或她)修改解决方案,...
  • Python:第7章字典与集合 课后习题

    千次阅读 2022-01-02 23:50:17
    《Python语言程序设计》刘卫国主编,中国工信出版集团,电子工业出版社 习题7 一、选择题 1.Python语句print(type({1:1,2:2,3:3,4:4}))的输出结果是( )。B ...2.以下不创建字典的语句是...
  • 计算机组成原理:最详细笔记

    万次阅读 多人点赞 2021-01-21 14:26:44
    参考:《王道计算机组成原理》学习笔记总目录+思维导图 2019 王道考研 计算机组成原理 第一章 计算机系统概述 1.1 计算机发展历程 1.1.1 计算机硬件的发展 计算机系统=硬件+软件 计算机硬件的发展: 第一代计算机...
  • 集合论、二元关系、集合的基数知识概述
  • Python 集合不支持使用下标访问其中的元素答:对下列对于新创企业的优势的描述中,错误的是()。答:开拓新市场投资多,但潜在的回报少与欧洲近代科学革命相比,18世纪美国科学发展的优势是()答:不需要承受历史负担...
  • 计算机组成原理期末考试题库(超级多的那种)

    千次阅读 多人点赞 2021-07-23 09:54:00
    废话不多说,不管是应对期末考试还是考研基础复习,刷题是必不可少的!!! 大家冲就完了!!!! 记得给 罡罡同学点关注哦!...2.下列说法中______是正确的。 A.加法指令的执行周期一定要访存; B.加法指令
  • VBA系列(4)——VBA中的对象和集合

    千次阅读 2019-10-23 20:51:36
    VBA的对象是以分层的结构组织的,本节介绍Excel中的对象和集合 Application对象(也就是Excel)包含其他对象,是VBA中的顶层对象,下面举例说明Application对象中包含的对象: Workbooks(所有Workbook对象的集合) ...
  • 集合代数

    千次阅读 2015-04-19 11:03:19
    集合是精确定义的基本概念。直观地说,把一些事物汇集到一起组成一个整体就叫集合,而这些事物就是这个集合的元素或成员。 设A,B为集合,如果B中的每个元素都是A中的元素,则称B是A的子集合,简称子集。这时也...
  • 的所有因子组成集合 , " ∣ | ∣ " 是 A A A 上的整除关系 ; 问题 1 : 证明该 关系 是 偏序关系 ; 问题 2 : 画出关系的哈斯图 问题 3 : 确定 A A A 中的最长链 ; 写出所有最长链 ; 问题4 : ...
  • Java面试题总结 - Java集合篇(附答案)

    千次阅读 多人点赞 2021-05-29 20:25:21
    第二章 Java集合 一、Java容器都有哪些? 1、Collection (1)set HashSet、TreeSet (2)list ArrayList、LinkedList、Vector 2、Map HashMap、HashTable、TreeMap 二、Collection 和 Collections 有什么...
  • 一、前言 概念:关系代数是一种抽象的查询语言,它用对关系的运算来表达查询。 关系代数的运算按运算符不同可分为传统的集合运算和...结果仍然为n目关系,由属于R或属于S的元组组成。 例如 2.交运算 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,165
精华内容 25,666
关键字:

下列能组成集合的是