使用next()获得序列中的下一个元素,1.ArrayList 

HashMap 意气风发种存款和储蓄key:value关联的映射

14.LinkedHashSet  能够记住插入次序的集结

2.java set

集合Sets

  • set:可变集结
    • set和dict相同,也是大器晚成组key的聚合,但不存款和储蓄value;这一个key既不另行,也冬季
  • frozenset:不可变集合
set frozenset 说明
add y
clear y y
copy y
difference y y
difference_update y
discard y
intersection y y
intersection_update y
isdisjoint y y
issubset y y
issuperset y y
pop y
remove y
symmetric_differen y y
symmetric_difference_update y
union y y
update y

参考:

    在Java中平等提供了这么的泛型算法,分裂的是这几个算法函数都以Collections中静态方法。见如下Java代码:

ArrayDeque  一种用循环数组完毕的双端队列

4.TreeSet   有序集

  Iterator是Java迭代器最简便的兑现,为List设计的ListIterator具备越来越多的作用,它能够从多个样子遍历List,也足以从List中插入和删除成分。

序列Sequence

  • list:列表,有序的 可变 序列
  • tuple:元组,有序的 不可变 序列
  • str:字符组成的 有序的 不可变 连串,字符可使用编码来掌握
  • bytes:字节组成的 有序的 不可变 类别
    • (分歧:字符串是字符组成的队列,以三个字符为单位;字节种类是字节组成的种类,以字节为单位)
  • bytearray:字节组成的 有序的 可变 体系

小技能:查看三个类的嵌入方法

for _def in dir:    if "__" in _def:   # 内部方法跳过        continue    else:        print

对照list和tuple的结果如下:

append clear copy count extend index insert pop remove reverse sort
list y y y y y y y y y y y
tuple y y

PS:元组只然而是可读的列表,并由[]改为()

# 定义empty_list = []num_list = [1,2,3,4,5,6,7,8,9,10]mix_list = [1,"str",[1,2],[3,4]]empty_tuple = ()num_tuple = (1,2,3,4,5,6,7,8,9,10)mix_tuple = (1,"str",,[3,4])# 增empty_list.append("a")       # 插入元素,默认末端插入empty_list.append("b")empty_list.insert(0,"e")     # 指定位置插入元素empty_list.insert(-1,"e")empty_list.extend(["c","d"]) # 扩展,在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)empty_list.append(["c","d"])# 拼接print(num_list + mix_list)   # 拼接两个listprint(num_list * 3)          # 拼接三个相同的list# 删empty_list.remove("e") # 指定元素删除,# 移除列表中某个值的第一个匹配项empty_list.pop()       # 弹栈,删除末端的一个元素del(empty_list[-1])    # 非list内置方法del(empty_list)        # 整个对象删除,连变量名都不存在了empty_list.clear()     # 清空,变成空的列表[],变量还是存在的;与del不同,del后对象是不存在的,使用该变量的花会直接报错# 改empty_list[0] = 'change' # 查--切片printprint(num_list[0:2])print(num_list[:2])print(num_list[7:])print(num_list[7:-1])print(num_list[-3:])print(num_list[-3:-1])print(num_list[10:])print(num_list[0:-1:3]) # 间隔切片print(num_list[::3])    # 间隔切片# 查--检验print(4 in mix_list)print(4 in mix_list[-1])print(1 not in mix_list)# 查--计数print(len)        # 查看整个list的元素数量print(num_list.count   # 查看指定元素的数量# 查cmp(list1, list2)           # 比较两个列表的元素print(num_list          # 从列表中找出某个值第一个匹配项的索引位置print(len)        # 查看整个list的元素数量print(min)        # 返回列表元素最小值print(max)        # 返回列表元素最大值# 对象的复制num_copy = num_list.copy()  # 使用copy才会在内存中开辟新的内存去存储num_copy的值num_copy = num_list         # 简单的赋值语句只不过是两个不同的变量名指向同一块内存,感觉上就是改变一个,另一个也改变num_copy = list        # 将元组转换为列表# 顺序操作num_list.reverse()          # 反向列表中元素printnum_list.sort()             # 对原列表进行排序,模式升序,配合reverse(),升降序就都实现了print
 1     public class TestMain {
 2         public static void main(String[] args) {
 3             PriorityQueue<String> pq = new PriorityQueue<String>();
 4             pq.add("1");
 5             pq.add("6");
 6             pq.add("4");
 7             pq.offer("5");
 8             pq.offer("3");
 9             pq.offer("2");
10             pq.offer("7");
11             //以下输出将以无序的结果输出
12             System.out.println(pq);
13             //以下输出将以有序的结果输出
14             while (pq.peek() != null) {
15                 String str = pq.poll();
16                 System.out.println(str);
17             }
18             int initCapacity = 20;
19             PriorityQueue<TestComparator> pq1 = new PriorityQueue<TestComparator>(initCapacity,
20                 new Comparator<TestComparator>() {
21                     public int compare(TestComparator t1, TestComparator t2) {
22                         return t1.getID() - t2.getID();
23                     }
24                 });
25             pq1.offer(new TestComparator(1));
26             pq1.offer(new TestComparator(6));
27             pq1.offer(new TestComparator(4));
28             pq1.offer(new TestComparator(5));
29             pq1.offer(new TestComparator(3));
30             pq1.offer(new TestComparator(2));
31             pq1.offer(new TestComparator(7));
32             System.out.println("The following is for TestComparator.");
33             System.out.println(pq1);
34             while (pq1.peek() != null) {
35                 int id = pq1.poll().getID();
36                 System.out.println(id);
37             }
38         }
39     }
40     
41     class TestComparator {
42         public TestComparator(int id) {
43             _id = id;
44         }
45         public int getID() {
46             return _id;
47         }
48         public String toString() {
49             return Integer.toString(_id);
50         }
51         private int _id;
52     }

ArrayList 风度翩翩种能够动态增加和减削的目录类别

1.ArrayList   能够动态增加和减少的目录体系

List(列表):     List的性状是其元素以线性方式存储,集结中能够寄存重复对象。
    List接口首要实现类包含:
    ArrayList() : 代表长度能够转移得数组。可以对成分进行大肆的拜候,向ArrayList()中插入与
    与删除成分的速度慢。
    LinkedList(): 在达成中使用链表数据结构。插入和删除速度快,访谈速度慢。
    对于List的人身自由探问以来,正是只随机来查找位于特定岗位的元素。
    List 的 get(int index) 方法放回集合中由参数index钦赐的目录地方的指标,下标从“0” 初步。
    最宗旨的三种检索集合中的全体指标的措施:     1: 用for循环和get()方法:

映射Mapping

  • dict:字典
    • dict内置函数如下:
      • copy:重临一个字典的浅复制
      • fromkeys:以钦点类别为键创建二个新字典,值都以同意气风发的,使用境况很特定
      • update:以键批量更新的不二诀要,(相仿的改革,贫乏的填补)
      • get:重回内定键的值,若是值不在字典中回到default值
      • setdefault:和get()相像, 但假若键空头支票于字典中,将会增多键并将值设为default
      • pop:删除字典给定键 key 所对应的值,再次来到值为被删去的值;key值必得交给,否则重回default值
      • popitem:随机重返并删除字典中的风流倜傥对键和值
      • clear:删除字典内全数因素,变为{}
      • items
      • keys
      • values
# 键必须是唯一的,但值则不必。# 值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组# d = {key1 : value1, key2 : value2 }dict1 = { 'abc': 456,'sss':'sss',100:100 }dict2 = { 'abc': 123, 98.6: 37, 'sss':['a',3,5] }dict3 = dict.fromkeys([1,2,3], [1,2,3])   # {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}# 访问/取值,依靠键dict2['abc']       # 返回123dict2.get('abc','no')   # 效果一样,但如果建不存在,会方法默认值,这里设为no,默认值的参数默认是Nonedict2.setdefault('s','sd') # 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default,default默认为None# 批量更新dict2.update # 相同的键,就更新值,缺少的键,直接增补print        # {98.6: 37, 100: 100, 'abc': 456, 'sss': 'sss'}# 删除print(dict2.pop("abc")) # 指定键,进行删除,并返回该键对应的值,如果键不存在,直接报错print(dict2.popitem  # 随机删除一对键值,并返回该对键值的元组形式# 遍历for k,v in dict2.items():    print(k,":",v)for k in dict2.keys():    printfor v in dict2.values():    print

请必得注意,dict内部存放的后生可畏黄金时代和key归入的风度翩翩一是平昔不提到的

和list对比,dict有以下几个个性:

  1. 搜索和插入的速度非常的慢,不会趁着key的扩张而变慢
  2. 亟待占用大量的内部存款和储蓄器,内部存款和储蓄器浪费多

而list相反:

  1. 查找和插入的时日随着成分的充实而充实
  2. 吞并空间小,浪费内部存款和储蓄器少之甚少

于是,dict是用空间来换取时间的生机勃勃种办法

dict能够用在须要快速查找的好多地方,在Python代码中大致无处不在,准确行使dict相当的重大,需求记住的率先条就是dict的key必需是不可变对象

那是因为dict依照key来计量value的仓库储存地方,如若每一趟总结同豆蔻梢头的key得出的结果差异,这dict内部就全盘混乱了。那几个通过key总结地点的算法称为哈希算法

    8.    PriorityQueue(优先级对象): 该容器也是铁板钉钉集中,和TreeSet不一样的是,该会集只是保险当从集结的头顶收取数据的时候,总是抽出队列中型迷你小的(优先级最高)的因素。该集结内部是通 过"堆"的数据结构达成的,该协会唯有首先个要素(尾部成分)保障为该集结中最大的或纤维的因素,其余成分未有稳固的次第,不过当集结有新的目的从尾巴部分插 入或是从底部抽出时,集合内部的有关要素会举办相比较的相比较最后再一次决定出谁是最大或一点都不大的要素作为尾部成分。在JDK提供的classes中提姆er是 通过该数据结构达成的,进而确认保证了Timer每一次获得职责时都以最应当被调节的TimerTask,见如下代码:

LinkedList 黄金年代种能够在任何职责张开火速地插入和删除操作的不改变体系

2.LinkedList 方可在其它岗位飞快插入和删除错左的稳步系列

  Java中的Iterator功效比较轻松,并且不能不单向活动:

  • 使用next()获得序列中的下一个元素,1.ArrayList   可以动态增长和缩减的索引序列。Python内置的数据结构
    • 序列Sequence
    • 映射Mapping
    • 集合Sets
 1     public static void main(String[] args) {
 2         List<Integer> v1 = new ArrayList<Integer>();
 3         for (int i = 0; i < 10; ++i)
 4             v1.add(i);
 5         
 6         List<Integer> l1 = new LinkedList<Integer>();
 7         for (int i = 0; i < 20; ++i)
 8             l1.add(i);
 9         
10         Collections.sort(v1);
11         Collections.sort(l1);
12         Collections.binarySearch(v1, 5);
13         Collections.binarySearch(l1, 5);
14     }

LinkHashSet 意气风发种能够记住元素插入次序的会见

13.IdentityHashMap   用==实际不是equals比较键值的映射表

    Set 的 add()方法是怎么剖断指标是否已经贮存在汇集中?

目录

    4.    ArrayList和LinkedList的雷同点:
    1)    都以接口List<E>的落实类;
    2)    都足以经过iterator()方法重回Iterator<E>迭代器对象,并能够透过该目的遍历容器中的成分;
    3)    倘若五个Iterator<E>实例同有的时候候援用同贰个集合对象,那么当有多少个正值遍历,而别的一个改正(add/remove)了集聚对象中的 成分,对于第叁个迭代器再拓宽迭代时将会吸引ConcurrentModificationException相当的产生。
    5.    ArrayList和LinkedList的不相同点:
    1)    对ArrayList和LinkedList来讲,在列表末尾扩充一个要素所花的付出都是一定的。对ArrayList来讲,主要是在里面数组中扩张风度翩翩项,指向所增添的要素,不时可能会导致对数组重新张开分配;而对LinkedList来讲,那个开支是统意气风发的,分配贰当中间Entry对象。
    2)    在ArrayList的中等插入或删除多个要素意味着那几个列表中多余的要素都会被挪动;而在LinkedList的中级插入或删除二个因素的开拓是定位的。
    3)    LinkedList不协理高速的自便成分访问。
    4)    ArrayList的空间浪费主要反映在在list列表的末尾预先留下一定的体积空间,而LinkedList的上空费用则反映在它的每多个要素都亟需成本万分的半空中
    在C++的规范库中,ArrayList和LinkedList之间的行使差别以至分级的优瑕玷也长久以来展现于vector和list。
    6.    HashSet: 散列表为各类对象总结出三个板寸(通过Object缺省的或类重载的hashCode域方法),称为散列码。在Java中,散列表是使用链表的数组来兑现 的,每一个链表被称之为二个哈希桶。要是想在哈希表中查找贰个指标,则须要先总结对象的hashCode,之后对表内的桶数取余数,得到的结果就是哈希桶的索 引,当时风度翩翩经该桶为空桶,就能够直接将该对象插入到该桶中,假设已经有目的存在了,则必要各类实行对比,风华正茂旦开掘该与该目的相等的目的(equals() 再次回到true),就能够遗弃此次插入操作,不然将该目的插入到该桶的前边。HashSet在组织的时候提供三个参数,一个是initialCapacity 内定了桶的多寡(实际的桶数为2的initialCapacity次幂),另叁个是loadFactortian(0.0--1.0,推荐值为 0.75),当桶的填充百分比高达该值后,哈希表内的哈希桶数将double,重新填写原来就有对象,该操作被称为rehash,rehash是分外震慑功用的操作,因为为了尽量防止该事件的爆发,因大概在构造HashSet的时候给出三个创建的参数。以下为HashSet的常用示例代码:

本文由必威发布于必威-编程,转载请注明出处:使用next()获得序列中的下一个元素,1.ArrayList 

相关阅读