精华内容
下载资源
问答
  • 容器分类

    2019-12-25 21:39:45
    一、结构与分类 1、序列容器 A、Array:固定大小数组。 B、Vector :自动扩充的数组。 C、Deque:前后都可自动扩充的数组。 D、List:双向链表。 E、Forward-List:单向链表。 2、关联式容器 A、Set/Multiset...

    一、结构与分类

    1、序列容器

    	A、Array:固定大小数组。
    	B、Vector :自动扩充的数组。
    	C、Deque:前后都可自动扩充的数组。
    	D、List:双向链表。
    	E、Forward-List:单向链表。
    

    2、关联式容器

    	A、Set/Multiset:红黑树,节点只有值,Multi元素可重复。
    	B、Map/Multimap:红黑树,节点包含关键字(Key)和值(Value)。
    

    3、不定序容器

    	A、Unordered Set/Multiset
    	B、Unordered Map/Multimap
        所有版本STL用哈希表实现。
    

    4、图示

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Java容器分类

    2020-05-19 10:56:43
    容器分类 容器的第一个接口是Collection叫集合。集合不管这个容器是什么结构都能把元素放在里面,是一个一个地放;Map是以键值对的方式往里放。其实Map可以看作是Collection一个特殊的变种,可以把一对对象看成一个...

    本文相当于一个目录,用来指导我之后的学习内容。

    容器.png

    容器分类

    容器的第一个接口是Collection叫集合。集合不管这个容器是什么结构都能把元素放在里面,是一个一个地放;Map是以键值对的方式往里放。其实Map可以看作是Collection一个特殊的变种,可以把一对对象看成一个entry对象,所以这也是一整个对象。容器就是用来装一个个对象的。严格来讲数组也属于容器。从数据结构角度来讲在物理上的这种存储的数据结构其实只有两种,一种是连续存储的数组Array,另一种就是非连续存储的一个指向另外一个的链表。

    Queue - 为并发而生

    容器有两大接口:Collection是一个一个的,Map是一对一对的。
    Collection又分三大类。List、Set,Queue是后来加入的接口,而这个接口专门就是为高并发准备的,所以这个接口对高并发来说才是最重要的。List有序可重复,Set无序不重复。

    Queue就是一个队列,有进有出,先进先出。它是在这个基础之上实现了很多的多线程的访问方法(比如说put阻塞式的放、take阻塞式的取),这个在其他的List、Set里面都是没有的。采用队列结构最主要的原因是为了实现任务的装载和取出,这里面最重要的就是阻塞队列,它实现的初衷就是为了线程池、高并发做准备的。

    原来的队列结构是为了装东西做准备的。所以在说Queue的区别的时候主要就说高并发和普通的这种容器这上面的一个区别。Queue是Collection的子接口,里面又分了各种各样的队列,Queue里面还有一个子接口叫Deque叫双端队列,一般的队列只是从一端往里扔从另一端往外取。Deque可以从反方向装从另外一个方向取。

    参考:马士兵《多线程与高并发》

    展开全文
  • 容器分类,array、vector容器精解容器分类和array容器的使用vector容器 容器分类和array容器的使用 #include<iostream> #include<cstdlib> #include<string> #include<vector> #include <...

    容器分类,array、vector容器精解

    容器分类和array容器的使用

    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<vector>
    #include <memory>
    #include <array>
    using namespace std;
    
    
    int main(void)
    {
    	//包含5个元素的数组
    	array<string, 5>mystring = { "fsdfd","fsfds","ds","dsf","dfd" };
    	cout << mystring.size() << endl;//5
    	mystring[0] = "fsdffffsdfsdfsdfsdfsfsfdf";
    	cout << sizeof(string) << endl;//字符串类型的大小---28
    	for (size_t i=0;i<mystring.size();i++)
    	{
    		cout << "------------------------------1" << endl;
    		const char*p = mystring[i].c_str();
    		cout << "元素内容为:" << p << endl;
    		printf("对象地址为=%p", &mystring[i]);
    		cout << endl;
    		printf("指向的字符串地址=%p", p);
    		cout << endl;
    		cout << "------------------------------2" << endl;
    
    	}
    	
    	/*
    			 ------------------------------1
    			元素内容为:fsdffffsdfsdfsdfsdfsfsfdf
    			对象地址为=002EFB60
    			指向的字符串地址=0063DA38
    			------------------------------2
    			------------------------------1
    			元素内容为:fsfds
    			对象地址为=002EFB7C
    			指向的字符串地址=002EFB80
    			------------------------------2
    			------------------------------1
    			元素内容为:ds
    			对象地址为=002EFB98
    			指向的字符串地址=002EFB9C		//string 比较短,直接在后面存储
    			------------------------------2
    			------------------------------1
    			元素内容为:dsf
    			对象地址为=002EFBB4
    			指向的字符串地址=002EFBB8
    			------------------------------2
    			------------------------------1
    			元素内容为:dfd
    			对象地址为=002EFBD0
    			指向的字符串地址=002EFBD4
    			------------------------------2
    			请按任意键继续. . .
    
    
    	 */
    	//总结:对象是连续的,但是对象指向的字符串的内存空间没有关系
    	
    	
    	system("pause");
    	return 0;
    }
    
    /*
    *(1)容器的分类
    *vector
    *list
    *map
    *容易用于保存数据,
    *STL中的容器可以分为3大类
    *	1.顺序容器(Sequence containers),放在那里就在那里,array,vector,deque ,list, Forward-List
    *	2.关联容器(Associative Containers),元素一般是hi键值对,使用键(key)来找值(value)特别适合查找
    *		set /multiset map/multimap
    *		根据键自动在内部排序,能控制插入内容,但是不能控制插入位置。
    *		可以使用树,或者哈希来实现
    *		
    *	3.无序容器(unordered containers)c++11中推出的新名字。元素的位置不重要,重要的是元素是否在容器中
    *		无序容易也是属于一种关联容器。
    *		随着元素的的插入,每个元素在容器中的位置可能随着发生改变。内部可能使用哈希表来实现
    *		常见的有:unordered_set unordered_multiset unordered_map  unordered_multimap
    *	c++标准没有规定是用什么算法实现上面容器
    *
    *(2)容器的说明说明和应用事项例
    *	2.1array本质上是一个内存空间连续的数组,大小固定,不能增加它的大小
    *	对象是连续的,但是对象指向的字符串的内存空间没有关系
    *
    *(3)
    *
    *
    */
    
    

    vector容器

    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<vector>
    #include <memory>
    
    using namespace std;
    
    class A
    {
    public:
    	A(int a):m_i(a)
    	{
    		cout << "构造函数执行" << endl;
    	}
    	A(const A&a):m_i(a.m_i)
    	{
    		cout << "A的拷贝构造函数执行" << endl;
    	}
    
    	~A()
    	{
    		cout << "A的析构函数执行" << endl;
    	}
    public:
    	int m_i;
    };
    
    int main(void)
    {
    	vector<A>myA;
    	for (int i=0;i<5;i++)
    	{
    		cout << "----------begin-----------" << endl;
    		myA.push_back(A(i));
    		cout << "----------end-----------" << endl;
    
    	}
    	/*
    	 * ----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		请按任意键继续. . .
    
    	总结:先调用构造函数,创建一个临时地对象,然后使用拷贝构造函数,将对象拷贝进myA容器中,调用析构函数析构掉对象。
    		
    	 */
    
    	//查看元素个数
    	cout << myA.size() << endl;//5
    	//查看容器空间个数
    	cout << myA.capacity() << endl;//6
    
    	//容器的地址和第一个元素的地址不相同
    	printf("第一个元素的地址=%p\n", &myA[0]);//0073B730
    	printf("容器的地址=%p\n", &myA);//0036F998
    
    	//删除下标为2的元素,只调用一次析构函数
    	int icount = 0;
    	cout << "-------------" << endl;
    	for (vector<A>::iterator iter=myA.begin();iter!=myA.end();iter++)
    	{
    		icount++;
    		if (icount==2)
    		{
    			myA.erase(iter);
    			break;
    		}
    	}
    
    	cout << "****************************" << endl;
    	for (vector<A>::iterator iter = myA.begin(); iter != myA.end(); iter++)
    	{
    		icount++;
    		if (icount == 3)
    		{
    			myA.insert(iter, A(34));
    			break;
    		}
    	}
    	/*
    	 *	 构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    
    	 */
    
    	//设置容器的最大元素个数
    	vector<int>myint;
    	myint.reserve(10);
    	cout << myint.capacity() << endl;//10
    	system("pause");
    	return 0;
    }
    
    /*
    *(1)vector容器实现类似于一个栈,向顶部增加元素和删除元素都很快,删除中间的元素很慢,查找的速度也不会太快
    *
    *	vector容器内存是挨着的,vector有一个“空间”的概念,每一个空间可以装一个元素。
    *	当只有一个元素的时候,只有一个空间。当再插入一个元素的时候,找一段可以装两个元素的“空间”,
    *	将原来的对象在新空间构造,析构掉老空间的对象。所以插入元素会调用多次构造函数和析构函数。
    *	但是容器观测到你多次插入元素,容器会给你多分配内存,以便不用每次新分配内存。
    *
    *	也就是说,vector容器插入元素是不断寻找新的内存空间,析构和构造的过程。
    *
    *为什么要析构老元素,构造新元素?
    *	主要的原因是这种容器的实现要求内存是连续的。
    *	
    *(2)我们使用vector,一般需要提前知道元素不超过多少个,把capacity设置为最大值
    *
    *(3)
    *
    *
    */
    
    展开全文
  • 001容器分类和array容器的使用 #include<iostream> #include<cstdlib> #include<string> #include<vector> #include <memory> #include <array> using namespace std; int ...

    001容器分类和array容器的使用

    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<vector>
    #include <memory>
    #include <array>
    using namespace std;
    
    
    int main(void)
    {
    	//包含5个元素的数组
    	array<string, 5>mystring = { "fsdfd","fsfds","ds","dsf","dfd" };
    	cout << mystring.size() << endl;//5
    	mystring[0] = "fsdffffsdfsdfsdfsdfsfsfdf";
    	cout << sizeof(string) << endl;//字符串类型的大小---28
    	for (size_t i=0;i<mystring.size();i++)
    	{
    		cout << "------------------------------1" << endl;
    		const char*p = mystring[i].c_str();
    		cout << "元素内容为:" << p << endl;
    		printf("对象地址为=%p", &mystring[i]);
    		cout << endl;
    		printf("指向的字符串地址=%p", p);
    		cout << endl;
    		cout << "------------------------------2" << endl;
    
    	}
    	
    	/*
    			 ------------------------------1
    			元素内容为:fsdffffsdfsdfsdfsdfsfsfdf
    			对象地址为=002EFB60
    			指向的字符串地址=0063DA38
    			------------------------------2
    			------------------------------1
    			元素内容为:fsfds
    			对象地址为=002EFB7C
    			指向的字符串地址=002EFB80
    			------------------------------2
    			------------------------------1
    			元素内容为:ds
    			对象地址为=002EFB98
    			指向的字符串地址=002EFB9C		//string 比较短,直接在后面存储
    			------------------------------2
    			------------------------------1
    			元素内容为:dsf
    			对象地址为=002EFBB4
    			指向的字符串地址=002EFBB8
    			------------------------------2
    			------------------------------1
    			元素内容为:dfd
    			对象地址为=002EFBD0
    			指向的字符串地址=002EFBD4
    			------------------------------2
    			请按任意键继续. . .
    
    
    	 */
    	//总结:对象是连续的,但是对象指向的字符串的内存空间没有关系
    	
    	
    	system("pause");
    	return 0;
    }
    
    /*
    *(1)容器的分类
    *vector
    *list
    *map
    *容易用于保存数据,
    *STL中的容器可以分为3大类
    *	1.顺序容器(Sequence containers),放在那里就在那里,array,vector,deque ,list, Forward-List
    *	2.关联容器(Associative Containers),元素一般是hi键值对,使用键(key)来找值(value)特别适合查找
    *		set /multiset map/multimap
    *		根据键自动在内部排序,能控制插入内容,但是不能控制插入位置。
    *		可以使用树,或者哈希来实现
    *		
    *	3.无序容器(unordered containers)c++11中推出的新名字。元素的位置不重要,重要的是元素是否在容器中
    *		无序容易也是属于一种关联容器。
    *		随着元素的的插入,每个元素在容器中的位置可能随着发生改变。内部可能使用哈希表来实现
    *		常见的有:unordered_set unordered_multiset unordered_map  unordered_multimap
    *	c++标准没有规定是用什么算法实现上面容器
    *
    *(2)容器的说明说明和应用事项例
    *	2.1array本质上是一个内存空间连续的数组,大小固定,不能增加它的大小
    *	对象是连续的,但是对象指向的字符串的内存空间没有关系
    *
    *(3)
    *
    *
    */
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    002vector容器

    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<vector>
    #include <memory>
    
    using namespace std;
    
    class A
    {
    public:
    	A(int a):m_i(a)
    	{
    		cout << "构造函数执行" << endl;
    	}
    	A(const A&a):m_i(a.m_i)
    	{
    		cout << "A的拷贝构造函数执行" << endl;
    	}
    
    	~A()
    	{
    		cout << "A的析构函数执行" << endl;
    	}
    public:
    	int m_i;
    };
    
    int main(void)
    {
    	vector<A>myA;
    	for (int i=0;i<5;i++)
    	{
    		cout << "----------begin-----------" << endl;
    		myA.push_back(A(i));
    		cout << "----------end-----------" << endl;
    
    	}
    	/*
    	 * ----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		----------begin-----------
    		构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		----------end-----------
    		请按任意键继续. . .
    
    	总结:先调用构造函数,创建一个临时地对象,然后使用拷贝构造函数,将对象拷贝进myA容器中,调用析构函数析构掉对象。
    		
    	 */
    
    	//查看元素个数
    	cout << myA.size() << endl;//5
    	//查看容器空间个数
    	cout << myA.capacity() << endl;//6
    
    	//容器的地址和第一个元素的地址不相同
    	printf("第一个元素的地址=%p\n", &myA[0]);//0073B730
    	printf("容器的地址=%p\n", &myA);//0036F998
    
    	//删除下标为2的元素,只调用一次析构函数
    	int icount = 0;
    	cout << "-------------" << endl;
    	for (vector<A>::iterator iter=myA.begin();iter!=myA.end();iter++)
    	{
    		icount++;
    		if (icount==2)
    		{
    			myA.erase(iter);
    			break;
    		}
    	}
    
    	cout << "****************************" << endl;
    	for (vector<A>::iterator iter = myA.begin(); iter != myA.end(); iter++)
    	{
    		icount++;
    		if (icount == 3)
    		{
    			myA.insert(iter, A(34));
    			break;
    		}
    	}
    	/*
    	 *	 构造函数执行
    		A的拷贝构造函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的拷贝构造函数执行
    		A的析构函数执行
    		A的析构函数执行
    
    	 */
    
    	//设置容器的最大元素个数
    	vector<int>myint;
    	myint.reserve(10);
    	cout << myint.capacity() << endl;//10
    	system("pause");
    	return 0;
    }
    
    /*
    *(1)vector容器实现类似于一个栈,向顶部增加元素和删除元素都很快,删除中间的元素很慢,查找的速度也不会太快
    *
    *	vector容器内存是挨着的,vector有一个“空间”的概念,每一个空间可以装一个元素。
    *	当只有一个元素的时候,只有一个空间。当再插入一个元素的时候,找一段可以装两个元素的“空间”,
    *	将原来的对象在新空间构造,析构掉老空间的对象。所以插入元素会调用多次构造函数和析构函数。
    *	但是容器观测到你多次插入元素,容器会给你多分配内存,以便不用每次新分配内存。
    *
    *	也就是说,vector容器插入元素是不断寻找新的内存空间,析构和构造的过程。
    *
    *为什么要析构老元素,构造新元素?
    *	主要的原因是这种容器的实现要求内存是连续的。
    *	
    *(2)我们使用vector,一般需要提前知道元素不超过多少个,把capacity设置为最大值
    *
    *(3)
    *
    *
    */
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 容器分类 array vector qeque list forward-list set/multiset map/multimap unordered set/multiset unordered map/multimap hashtable 容器测试(测试创建时间和排序时间) #include <iostream> #include &...
  • 文章目录一:pod的容器分类:1.1:infrastructure container 基础容器1.2:initContainers:初始化容器1.3:container:业务容器二:镜像拉取策略(image PullPolicy)2.1:查看已创建deployment的拉取政策2.2:编写...
  • 一、完整的容器分类法 下面是集合类库更加完备的图。包括抽象类和遗留构件(不包括Queue的实现): java SE5新添加了: Queue接口(正如之前所介绍,LinkedList已经为实现该接口做了修改)及其实现...
  • 容器分类:(三大类) 1、顺序容器:放进去在哪里元素就排在哪里。如:arrary、vector、deque、list、forward_list; 2、关联容器:元素是 键/值 对,特别适合做查找。你能控制插入内容,但是一般来讲你不能控制...
  • C++ 11 STL中常用容器分类和对比

    千次阅读 2018-06-23 19:53:29
    STL容器分类1,顺序容器 sequence containersarrayvectordequelistforward-list 2,关联容器 associative containerssetmultisetmapmultimap3,无序容器 unordered containers (非标准,也可以划分到关联容器)...
  • 通用容器分类 STL 对定义的通用容器分三类:顺序性容器、关联式容器容器适配器。 下表列出STL 定义的三类容器所包含的具体容器类: 顺序性容器 是一种各元素之间有顺序关系的线性表,是一种线性结构的可序...
  • STL容器分类

    2019-11-02 18:40:49
  • java 容器分类

    2014-04-10 15:05:04
    java容器le
  • 介绍python中容器及大致分类
  • Java容器分类与概述

    2020-05-12 17:08:59
    一、容器接口(Collection,Map,Iterator) 容器接口是容器的基础。使用接口可以将容器的实现与容器接口分开,因而可以使用相同的方法访问容器而不需关心容器具体的数据结构。 同理,Iterator接口也使用户能够使用...
  • Java容器类是java提供的工具包,包含了常用的数据结构:集合、链表、队列、栈、数组、映射等。从本文开始将开启一个系列详细分析Java容器中的每个成员,包括源代码分析,性能分析,不同容器之间对比等等,链接将同步...
  • 关联容器的特点每个关联容器都有一个键(key)可以根据键高效地查找元素接口插入:insert删除:erase查找:find定界:lowerbound、upperbound、equal_range计数:count关联容器概念图四种关联容器单重关联容器(set和...
  • Pod资源管理了解podPod容器分类:镜像拉取策略(image PullPolicy)创建pods资源k8s和Harbor服务过程node节点配置连接私有仓库在node节点下载tomcat基于本地镜像创建tomcat上传镜像到harbor创建资源从harbor中下载...
  • Sword STL容器分类介绍

    2018-10-30 23:54:00
    标准STL序列容器:vector、string、deque和list。 标准STL关联容器:set、multiset、map和multimap。 非标准序列容器slist和rope。slist是一个单向链表,rope本质上是一个重型字符串 非标准关联容器hash_set、...
  • Java容器分类介绍

    2018-02-26 15:52:58
    一,Java常见容器关系图1、List集合的关系图List接口下的实现类是基于数组或链表的实现。Set接口下的实现类是基于HashMap中哈希表实现的,只是将value都置为空。2、Map键值对HashMap是线程不安全的,但是速度快。...
  • Java容器可以说是增强程序员编程能力的基本工具,本系列将带您深入理解容器类。容器的用途如果对象的数量与生命周期都是固定的,自然我们也就不需要很复杂的数据结构。我们可以通过创建引用来持有对象,如Class ...
  •  CC1型圆片高频瓷介电容器:适用于谐振回路及其他电路做温度补偿,耦合,隔直使用。  允许偏差:5p(+-0.5p) 6-10p(+-1P) 10p以上(J,K,M)温度系数:-150--- -1000PPM/C环境温度:-25-85C 相对湿度:+40C时达96% ...
  • Java容器分类示意图

    2017-08-25 14:57:40
    Java容器类库简化图: 完整的Java集合类库图:
  • 序列式容器 vector 简介 vector ( 向量 ) 头文件 vector ( 向量 ) 声明及初始化 vector ( 向量 ) 添加元素 vector ( 向量 ) 查询元素 vector ( 向量 ) 删除元素 vector ( 向量 ) 容量改变 vector ( 向量 ) 涉及到的...
  • 简单的容器分类

    2015-09-01 17:41:00
    转载于:https://www.cnblogs.com/gyzboy/p/4776368.html

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,466
精华内容 1,786
关键字:

容器分类