精华内容
下载资源
问答
  • 数组和集合的区别
    万次阅读 多人点赞
    2018-06-24 09:19:39

    数组和集合的定义

    一、数组

    数组是java语言内置的数据类型,他是一个线性的序列,所有可以快速访问其他的元素,数组和其他语言不同,当你创建了一个数组时,他的容量是不变的,而且在生命周期也是不能改变的,还有JAVA数组会做边界检查,如果发现有越界现象,会报RuntimeException异常错误,当然检查边界会以效率为代价。

    二、集合

    JAVA还提供其他集合,list,map,set,他们处理对象的时候就好像这些对象没有自己的类型一样,而是直接归根于Object,这样只需要创建一个集合,把对象放进去,取出时转换成自己的类型就行了。

    三、数组和集合的区别

    一、数组声明了它容纳的元素的类型,而集合不声明。

    二、数组是静态的,一个数组实例具有固定的大小,一旦创建了就无法改变容量了。而集合是可以动态扩展容量,可以根据需要动态改变大小,集合提供更多的成员方法,能满足更多的需求。

    三、数组的存放的类型只能是一种(基本类型/引用类型),集合存放的类型可以不是一种(不加泛型时添加的类型是Object)

    四、数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查都是最快的。

    集合体系结构

    Collection
    ├List (有序集合,允许相同元素和null)
    │├LinkedList (非同步,允许相同元素和null,遍历效率低插入和删除效率高)
    │├ArrayList (非同步,允许相同元素和null,实现了动态大小的数组,遍历效率高,用的多)
    │└Vector(同步,允许相同元素和null,效率低)
    │ └Stack(继承自Vector,实现一个后进先出的堆栈)
    └Set (无序集合,不允许相同元素,最多有一个null元素)

         |-HashSet(无序集合,不允许相同元素,最多有一个null元素)

       

     


    Map (没有实现collection接口,key不能重复,value可以重复,一个key映射一个value)
    ├Hashtable (实现Map接口,同步,不允许null作为key和value,用自定义的类当作key的话要复写hashCode和eques方法,)
    ├HashMap (实现Map接口,非同步,允许null作为key和value,用的多)
    └WeakHashMap(实现Map接口)


    Collection接口
      Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
      所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collection,有一个Collection参数的构造函数用于创建一个新的Collection,这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
      如何遍历Collection中的每一个元素?不论Collection的实际类型如何,它都支持一个iterator()的方法,该方法返回一个迭代子,使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下:
       Iterator it = collection.iterator(); // 获得一个迭代子
        while(it.hasNext()) {
          Object obj = it.next(); // 得到下一个元素
        }
      Collection接口派生的两个接口是ListSet

    一、List接口

     List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。
    和下面要提到的Set不同,List允许有相同的元素。
      除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。
      实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。

    LinkedList类
     LinkedList实现了List接口,允许null元素。LinkenList底层采用了双向链表来存储数据,每个节点都存储着上一个节点和下一个节点的地址以及本节点的数据。此外LinkedList提供额外的get,remove,insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
      注意:LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
        List list = Collections.synchronizedList(new LinkedList(...));
    ArrayList类
     
     ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList底层采用动态数组的存储方式,便利效率非常高,ArrayList是线程不安全的。
    size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
      每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

    ArrayList和LindedList的区别:
            1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。 
         2.对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。 
         3.对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。 

    Vector类
     
     Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。
    Stack 类
      Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

    二、Set接口
    Set是一种无序的并且不包含重复的元素的Collection,即任意的两个元素e1e2都有e1.equals(e2)=falseSet最多有一个null元素
      很明显,Set的构造函数有一个约束条件,传入的Collection参数不能包含重复的元素。

    HashSet 类

    是哈希表实现的,HashSet中的数据是无序的,可以放入null,但只能放入一个null,两者中的值都不能重复,因为HashSet的底层实现是HashMap,但是HashSet只使用了HashMap的key来存取数据所以HashSet存的数据不能重复。 

    HashSet要求放入的对象必须实现HashCode()方法,放入的对象,是以hashcode码作为标识的,而具有相同内容的 String对象,hashcode是一样,所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。


    三、Map接口
    Map没有继承Collection接口 Map 提供 key value 的映射。 一个Map中不能包含相同的key,每个key只能映射一个value Map 接口提供 3 种集合的视图, Map 的内容可以被当作一组 key 集合,一组 value 集合,或者一组 key-value 映射。

    Hashtable类
    Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value
      添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。

    使用Hashtable的简单示例如下,将123放到Hashtable中,他们的key分别是”one””two””three”
    Hashtable numbers = new Hashtable();
    numbers.put(“one”, new Integer(1));
    numbers.put(“two”, new Integer(2));
    numbers.put(“three”, new Integer(3));
      要取出一个数,比如2,用相应的key
    Integer n = (Integer)numbers.get(“two”);
    System.out.println(“two = ” + n);
      由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCodeequals方法。hashCodeequals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希表的操作。
      如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。
      Hashtable是同步的。


    HashMap类

    HashMapHashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null valuenull key,但是将HashMap视为Collection时(values()方法可返回Collection)。
    WeakHashMap类
    WeakHashMap是一种改进的HashMap,它对key实行弱引用,如果一个key不再被外部所引用,那么该key可以被GC回收。

    总结
    1.如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。
    2.如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
    3.要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
    4.尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。

    更多相关内容
  • Python中的字典和集合

    千次阅读 2019-01-03 09:48:19
    1. 字典( dict ) 字典( dict ,全称: dictionary )是 ...内置的一种使用“键值对结构...# 集合支持一系列标准操作,包括并集、交集、差集对称差集 a = t | s # t s的并集 b = t & s # t s...

    1. 字典(dict

    字典(dict,全称: dictionary )是python内置的一种使用“键值对结构”存储数据的存储模型。在其它语言中也称为map或者是object(对象)

    1.1 字典的操作

    • 创建/查询/修改字典

      # 创建字典:变量名 = {键1:值1,键2:值2,……}
      d = {'kendny': 99, 'Mary': 88}
      # 添加数据:变量名[键] = 值	(字典中没有对应的键)
      d['Tom'] = 87	
      # 获取数据:	 变量名[键]
      d['kendny'] # 或 d.kendny
      # 修改数据:变量名[键] = 值	(字典中存在对应的键)
      d['kendny'] = 100
      
      # 通过键名取字典的值, 如果键名不存在, 就会报错; 通常可以通过 in或者get()方法判断键是否存在
      if 'Thomas' in d:
          value = d['Thomas']
          
       # 或者
      value = d.get('Thomas'); # 不存在value什么值都没有
      
    • 常见操作字典的函数

    函数说明实例
    len(d)获取字典d中元素的长度len(d)
    d.setdefault(key, value)向字典中添加新的键值对, 如果存在对应的键, 则忽略该操作; 返回添加成功键值对的值。`d.setdefault(‘f’, 33)``
    d1.update(d2)使用新字典中的数据对原始字典数据进行更新dict1 = {"name":"itcast","age":11} dict2 = {"address":"北京","age":22} dict1.update(dict2)
    d.pop(key)从字典中删除指定键key对应的键值对, 如果键key不存在将报错; 返回值:被删除的值valued.pop(‘Mary’)
    popitem()从字典中删除字典最后一个键值对; 返回值: 被删除的键值对, 以元组的形式返回d.popitem()
    d.get(key)从字典中获取键为key的值, 如果key不存在, 则什么都不返回,也不报错d.get(key)
    d.keys()以列表的形式返回字典中所有的键名d.keys()
    d.values()以列表的形式返回字典中所有的键值d.value()
    d.items()将字典中的每一项键值对转化成元组, 并以列表的方式返回d.items()
    d.clear()清除字典中的元素d.clear()

    1.2 字典的特点

    • 字典不具备索引的概念,但可以通过字典的键key操作字典中存储的数据值value
    • 字典(dict)内部存放的顺序和键key放入的顺序是没有关系的。
    • 字典可以根据键(key)进行数据的添加、删除、修改、查询等操作
    • 字典通过键(key)计算位置的算法称为哈希算法(Hash)
    • 要保证hash的正确性, 作为key的对象就不能变。 在Python中, 字符串、整数等不可变类型的数据可作为 字典的键
    • 字典的key是唯一的且必须是不可变的类型(对象), 如纯元素可以作为字典的key

    *为什么字典dict*查找速度这么快?

    因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。

    第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。

    总结: 字典的查找方式就是第二种, 字典在内部可以直接通过键key直接计算出对应的存放值的内存地址, 直接取出来, 所以速度非常快。

    2 集合(set)

    集合(set)是python内置的一种存储无序不重复数据的数据存储模型

    2. 1 集合的操作

    • 创建集合

      s = {1, 2, 3} # 创建集合
      

      集合是无序不重复数据的数据存储模型,它没有索引的概念,集合中的数据可以进行添加、删除等操作;

    • 常见集合的函数

      函数说明实例
      len(s)获取集合中元素的个数len(s)
      s.add(data)向集合s中添加数据datas.add(4)
      s.remove(data)从集合中删除指定的数据, 如果数据不存在将报错s.remove(2)
      s.discard(data)删除集合中的data元素, 若data不存在,什么都不做s.remove(22)
      s.pop()从集合中删除字典的第一个元素并返回(不需要参数)s.pop()
      s.clear()清空集合中的数据s.clear()
      s.copy()复制集合ns=s.copy()
      s1.difference(s2)计算2个集合的差集(在s1中, 但不在s2中)
      s1.union(s2)计算2个集合的并集``
      s1.intersection(s2)计算2个集合的交集
    • 集合中的其它操作

      s = {1, 2, 3}
      >>> 2 in s    #True 集合的成员检测
      >>> {'*' + i '*' for i in s} # 集合推导式
      >>> {i for i in s if i>1} # 带有条件的集合推导式
      
      # 多循环集合推导式
      >>>colors = {'red','blue','pink'}
      >>>sizes = {36,37,38,39}
      >>>result = {c + str(s) for c in colors for s in sizes}
      print(result)
      
      #difference() 计算2个集合的差集
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      result = dreamers.difference(girls)# result = a + b
      print(result)
      
      #difference_update()  计算2个集合的差集(差集更新操作)
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      dreamers.difference_update(girls)#a = a + b  a += b
      print(dreamers)
      
      #union()  并集操作
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      result = dreamers.union(girls)
      print(result)
      
      #update()  并集更新操作
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      dreamers.update(girls)
      print(dreamers)
      
      #intersection()  计算2个集合的交集
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      result = dreamers.intersection(girls)
      print(result)
      
      #intersection_update  交集更新操作
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      dreamers.intersection_update(girls)
      print(dreamers)
      
      #超集和子集
      boys = {'zzy','yqw','dw','wzc','lyb','wym','chy'}
      zoudu = {'wzc','lyb','wym'}
      girls = {'lsy','mmf','syj'}
      
      #issuperset()  检测当前集合是否是另一个集合的超集
      result = boys.issuperset(zoudu)
      print(result)
      
      #issubset()  检测当前集合是否是另一个集合的子集
      result = zoudu.issubset(boys)
      print(result)
      
      #isdisjoint()  检测2个集合是否不存在交集  存在交集 False
      result = boys.isdisjoint(girls)
      print(result)
      
      #symmetric_difference()  对称差集
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      result = dreamers.symmetric_difference(girls)
      print(result)
      
      #symmetric_difference_update()  对称更新差集
      dreamers = {'ljl','wc','xy','zb','lsy'}
      girls = {'mmf','lsy','syj'}
      dreamers.symmetric_difference_update(girls)
      print(dreamers)
      
      #冰冻集合
      #冰冻集合是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)
      #创建冰冻集合
      #一般不会创建空的冰冻集合
      var = frozenset()
      print(var,type(var))
      
      #带有数据的冰冻集合
      var = frozenset(('qs','szx','bjh','acs'))
      print(var,type(var))
      
      #成员检测
      result = 'szx' in var
      print(result)
      
      #遍历冰冻集合
      for i in var:
          print(i)
      
      #集合推导式(无法得到冰冻集合,可以得到集合,列表,元组,字典类型)
      result = {i for i in var}
      print(result,type(result))
      
      #函数
      #冰冻集合可以使用集合的函数(不修改集合本身的函数都可以使用)
      var = frozenset(('qs','szx','bjh','acs'))
      
      #copy()
      result = var.copy()
      print(result)
      
      #集合操作  交集,并集,差集,对称差集等  不修改冰冻集合本身就能使用:冰冻集合的操作结果都是冰冻集合
      var1 = frozenset(('qs','szx','bjh','acs'))
      var2 = {'szx','bjh','lc','wb'}
      
      #冰冻集合操作
      result = var1.union(var2)
      print(result)
      
      #普通集合操作(冰冻集合是参考集合)
      result = var2.union(var1)
      print(result)
      
      # 集合支持一系列标准操作,包括并集、交集、差集和对称差集
      a = t | s          # t 和 s的并集 
         
      b = t & s          # t 和 s的交集 
         
      c = t – s          # 求差集(项在t中,但不在s中) 
         
      d = t ^ s          # 对称差集(项在t或s中,但不会同时出现在二者中)
      

    3 字典和几种常见的存储数据型比较

    • 列表listdict

      ​ 在进行数据存储与查找方面,列表list是用时间换取空间, 它存储数据占用的空间小,浪费内存很少。但是查找和插入的时间随着元素的增加而增加; 字典dict是用空间换取时间, 它存储数据占用大量的空间, 内存浪费多。

    • 字典setdict

      ​ 集合和字典检索的原理是一样的, 唯一区别就是没有存储对应的value值; 字典的键值和集合的元素不可以放入可变对象, 因为无法判断两个可变对象是否相等, 也就无法保证集合(字典键值)不会有重复的元素。

    • 将列表/元组转化成集合

      l = [1, 2, 3, 4]
      s1 = set(l)
      
      t = (1, 2, 3, 4)
      s2 = set(t)
      
      

    说明: 后面我将逐渐将我的blog转移到我的个人网站 http://www.kendny.cn, 欢迎关注并评论!

    展开全文
  • 集合A和集合B的并运算图示

    千次阅读 2021-01-27 14:55:27
    集合A和集合B的并运算图示

    集合A和集合B的并运算图示

    Kagula

    2021-1-27

    正文

    U是全集,A和B均为U的子集,A+B表示A集合和B集合的并操作,AB表示AB集合的交操作。规定集合中允许出现相同的元素。P是集合的函数。

    求P(A+B)

    图一 P(A+B)的图示

    观察图形,不管A、B是否相交,只要A、B均是U的子集,以上两个公式的运算结果相等。

            假设P是概率函数,A、B分别代表某个事件,且互为独立事件,使用图一中的公式可以求由独立元器件构成的并行系统的故障率.。

     

     

    展开全文
  • 数组和集合区别

    万次阅读 多人点赞 2018-09-04 14:07:38
    一、数组声明了它容纳的元素的类型,而集合不声明。  二、数组是静态的,一...而集合是可以动态扩展容量,可以根据需要动态改变大小,集合提供更多的成员方法,能满足更多的需求。  三、数组不论是效率还是类型...

    https://blog.csdn.net/qq_27088383/article/details/50468779 

    一、数组声明了它容纳的元素的类型,而集合不声明。

           二、数组是静态的,一个数组实例具有固定的大小,一旦创建了就无法改变容量了。而集合是可以动态扩展容量,可以根据需要动态改变大小,集合提供更多的成员方法,能满足更多的需求。

           三、数组不论是效率还是类型检查都是最好的。

     

    1.数组是大小固定的,一旦创建无法扩容;集合大小不固定,

    2.数组的存放的类型只能是一种,集合存放的类型可以不是一种(不加泛型时添加的类型是Object);

    3.数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查(不懂),都是最快的.

      ArrayList就是基于数组创建的容器类.

     

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    数组Array和集合的区别:

     

    (1)数组是大小固定的,并且同一个数组只能存放类型一样的数据(基本类型/引用类型)

     

    (2)JAVA集合可以存储和操作数目不固定的一组数据。 (3)若程序时不知道究竟需要多少对象,需要在空间不足时自动扩增容量,则需要使用容器类库,array不适用。

     

    联系:使用相应的toArray()和Arrays.asList()方法可以回想转换。

     

    一.集合的体系结构:

     

    List、Set、Map是这个集合体系中最主要的三个接口。 List和Set继承自Collection接口。 Map也属于集合系统,但和Collection接口不同。

     

    Set不允许元素重复。HashSet和TreeSet是两个主要的实现类。Set 只能通过游标来取值,并且值是不能重复的。

     

    List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。 ArrayList 是线程不安全的, Vector 是线程安全的,这两个类底层都是由数组实现的 LinkedList 是线程不安全的,底层是由链表实现的

     

    Map 是键值对集合。其中key列就是一个集合,key不能重复,但是value可以重复。 HashMap、TreeMap和Hashtable是Map的三个主要的实现类。 HashTable 是线程安全的,不能存储 null 值 HashMap 不是线程安全的,可以存储 null 值

     

    二.List和ArrayList的区别

     

      1.List是接口,List特性就是有序,会确保以一定的顺序保存元素.

     

      ArrayList是它的实现类,是一个用数组实现的List.

     

      Map是接口,Map特性就是根据一个对象查找对象.

     

      HashMap是它的实现类,HashMap用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速散列查找.(关于散列查找,可以参看<<数据结构>>)

     

      2.一般情况下,如果没有必要,推荐代码只同List,Map接口打交道.

     

      比如:List list = new ArrayList();

     

      这样做的原因是list就相当于是一个泛型的实现,如果想改变list的类型,只需要:

     

      List list = new LinkedList();//LinkedList也是List的实现类,也是ArrayList的兄弟类

     

      这样,就不需要修改其它代码,这就是接口编程的优雅之处.

     

      另外的例子就是,在类的方法中,如下声明:

     

      private void doMyAction(List list){}

     

      这样这个方法能处理所有实现了List接口的类,一定程度上实现了泛型函数.

     

      3.如果开发的时候觉得ArrayList,HashMap的性能不能满足你的需要,可以通过实现List,Map(或者Collection)来定制你的自定义类.

     

     

    三。图示说明:

     注:图参来之http://www.cnblogs.com/xiaoqv/archive/2011/11/24/2262142.html

    int[] m = { 1, 2, 3 };

    String[] strings = { "aaa", "bbb" };

    List<String> list = new ArrayList<String>();

    List<Integer> lists = new ArrayList<Integer>();

    List<Map<String, Object>> list2 = new ArrayList<Map<String,Object>>();

    List<City> listcity = new ArrayList<City>();

    展开全文
  • 字典和集合

    千次阅读 2018-09-08 18:17:13
    集合:是无序的,不支持下标索引,它是可变的数据类型,集合中的元素是唯一的,一般...4.集合只支持成员操作符for循环 5.集合的常用方法 1)增加 2)删除 3)交集、并集、差集 4)对等差分 5)判断...
  • Java 数组和集合的区别

    千次阅读 多人点赞 2019-07-05 22:16:43
    目录 相同点 存储元素的区别 : 长度的区别: 使用选择 ...集合和数组都是Java中的容器。...1.1,数组既可以存储基本数据类型,...1.2,集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会...
  • 一、集合的表示 列举法:列出集合中的全体元素,元素之间用逗号分开,然后用花括号括起来 描述法:用谓词P(x)表示x具有性质P,用{x|P(x)}表示具有性质P的集合 注意事项:集合中的元素是各不相同的 ​ 集合...
  • JAVA中数组和集合的相互转换

    万次阅读 2020-05-13 10:29:42
    数组转集合: 1.遍历,最常用的方法,但是过程会繁琐一点 int arrs[] = {1, 2}; //1.遍历 List<Integer> list = new ArrayList<>(); for (int ele : arrs) { list.add(ele); } System.out.println...
  • 数组、列表和集合的区别

    千次阅读 2019-07-11 11:37:07
    请你讲讲数组(Array)列表(ArrayList)的区别?什么时候应该使用Array而不是ArrayList? https://www.nowcoder.com/questionTerminal/203b16053654416c905721828160bf96?orderByHotValue=1&page=1&...
  • 求解集合A和集合B的差集

    千次阅读 2017-07-25 20:43:24
    求解集合A和集合B的差集 题目:已知集合AB的元素分别用不含头结点的单链表存储,函数difference()用于求解集合A与B的差集,并将结果保存在集合A的单链表中。例如,若集合A={5,10,20,15,25,30},集合B={5,15,35,25...
  • void intersection(lklist *ha,lklist *hb,lklist *&hc) { lklist *p,*q,*t; for(p=ha,hc=0;p!=0;p=p->next) { for(q=hb;q!=0;q=q->next) if (q->data==p->data) ...=0)...
  • js数组和集合互转

    千次阅读 2018-12-06 22:29:00
    js数组和集合互转可用于去重: 数组转集合 var arr = [55, 44, 65]; var set = new Set(arr); console.log(set.size === arr.length); console.log(set.has(65)); 集合转数组 var set = new Set([1, 2, 3...
  • Java必要准确区别之数组Array和集合list、map、set

    千次阅读 多人点赞 2018-10-17 18:12:27
    世间上本来没有集合,(只有数组参考C语言)但有人想要,所以有了集合 有人想有可以自动扩展的数组,所以有了List 有的人想有没有重复的数组,所以有了set 有人想有自动排序的组数,所以有了TreeSet,TreeList,Tree** ...
  • 1、集合是一个无序不重复元素的序列(由于集合是无序的,所以不支持索引) , 集合的元素不能为可变类型(列表、字典、集合) 2、可以使用 { } 或 set( ) 创建集合,但是创建一个空集合时,只能使用set( ) ...
  • kotlin数组和集合

    万次阅读 2019-03-11 11:30:55
    一、Kotlin数组 1.对象数组 由Kotlin的main函数的写法,可以看出Kotlin中的对象数组...(1)使用arrayOf函数指定的数组元素创建数组 //Java写法: String[]params1={"str1","str2","str...
  • java集合详解和集合面试题目

    万次阅读 多人点赞 2018-02-12 11:01:14
    一、集合与数组 数组(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用。 集合(只能存储对象,对象类型可以不一样)的长度可变,可在多数情况下使用。 ...
  • java中的集合和集合的选择

    千次阅读 多人点赞 2018-03-27 00:25:56
    一、java中的集合介绍 学习东西,首先要知道学习他有什么用,他能够带给我什么样的效果。只有知道什么时候用,怎么用,这样才会对我们有用处,不然百学浪费时间。本篇主要讲解java中的常使用的集合的简单对比,没有...
  • Map集合和List集合总结

    千次阅读 2019-05-27 17:32:15
    Map集合和List集合哪个效率更高 List接口 List集合是一个元素有序(存储有序)、可重复的集合,集合中的每个元素都有对应的索引,以便于查询和修改,List集合是允许存储null值的。 List集合可重复原因,请看源码: ...
  • MYSQL数据库中的枚举类型和集合类型

    万次阅读 2016-01-14 18:13:16
    注意:站在 mysql的角度,尽量多用枚举和集合! 但是站在php操作mysql的角度,尽量少用!(兼容性差) ...
  • #include #include typedef int ElemType; typedef struct Lnode { ElemType date; struct Lnode* next; }*LNode; LNode InitLnode(void) //初始化链表 { LNode L;... L = (LNode)malloc(sizeof(struct
  • Kotlin之数组和集合

    千次阅读 2018-04-06 12:31:55
     到这里kotlin的数组和集合基本的用法基本上讲完了,其实和java的数组和集合基本相似,就是多了一些可变集合和不可变集合,以及提供的方法更多了一些,方便我们开发。其实kotlin自己并没有实现任何集合与数组都是...
  • foreach循环遍历数组和集合

    万次阅读 2014-11-13 15:41:11
    此时无需获得数组的集合长度,无需更具索引来访问数组元素和集合元素。自动遍 历数组和集合的每个元素‘ foreach循环语法格式: for(type variableName:array|collection) { 此时variableName ...
  • Python每日一练——列表,元组字典第一关:列表和集合的相关知识以及列表与集合之间的转换
  • JS中定义对象和集合

    千次阅读 2019-03-01 16:53:59
    在JS中定义的对象: var obj={}; obj ['a'] = a; obj ['b'] = b; 在JS中定义集合: var arr=[]; arr.push(obj);
  • java 字符串和集合互相转换

    万次阅读 2018-03-29 23:40:46
    今天在写项目的时候遇到一个问题,就是要把得到的一个集合转换成字符串,发现 import org.apache.commons.lang.StringUtils; 有这么一个简单的方法:String str=StringUtils.join(list,","); 第一个...
  • 集合论、二元关系、集合的基数知识概述
  • 集合 —— 集合集合运算

    千次阅读 2019-08-08 12:13:55
    集合中元素的数目称为集合的基数,集合 A 的基数记作:card(A),当其为有限大时,集合 A 称为有限集,反之则为无限集,简单来说,含有有限个元素的集合叫做有限集,含无限个元素的集合叫做无限集。 一个集合具有三...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,330,341
精华内容 1,332,136
关键字:

和集合