容器类
STL Container Header Applications
vector <vector> 直接访问任意元素,快速插入、删除尾部元素
deque <deque> 直接访问任意元素,快速插入、删除头部和尾部元素
list <list> 快速插入、删除任意位置元素
set <set> 快速查询元素,无重复关键字
multiset <set> 与set相同,但允许重复关键字
map <map> Key/value pair mapping(键值对映射)。不允许重复关键字,使用关键字快速查询元素
multimap <map> 与map相同,但允许重复关键字
stack <stack> 后进先出容器.
queue <queue> 先进先出容器
priority_queue <queue> 高优先级元素先删除
 

所有容器共同函数
Functions Description
non-argconstructor 无参构造函数 构造一个空容器
constructor with args带参构造函数 每个容器都有多个带有参数的构造函数
copy constructor 拷贝构造函数 创建一个容器,从一个已有的同类型容器中复制元素
destructor 析构函数 容器销毁后执行清理工作
empty() 若容器中没有元素则返回空
size() 返回容器中的元素数目
operator= 将容器内容复制到另一个容器
Relational operators(<, <=, >, >=, ==, and !=) 顺序比较两个容器中的对应元素,来确定大小关系
一级容器的通用函数
顺序容器+关联容器= 一级容器
Functions Description 
c1.swap(c2) 交换两个容器c1和c2的内容
c1.max_size() 返回一个容器可以容纳的最大元素数量
c.clear() 删除容器中的所有元素
c.begin() 返回容器首元素的迭代器
c.end() 返回容器尾元素之后位置的迭代器
c.rbegin() 返回容器为元素的迭代器,用于逆序遍历
c.rend() 返回容器首元素之前位置的迭代器,用于逆序遍历
c.erase(beg, end) 删除容器中从beg到end-1之间的元素。beg和end都是迭代器

顺序容器(Sequence Container)

1.vector(向量)连续存储的元素。直接访问任意元素,快速插入、删除尾部元素。<vector>
2.双端队列(deque) 连续存储的指向不同元素的指针所组成的数组。直接访问任意元素,快速插入、删除头部和尾部元素。<deque>
3.列表(list) 由节点组成的双向链表,每个结点包含着一个元素。快速插入、删除任意位置元素。<list>
 
顺序容器的共同函数
函数 描述
assign(n, elem) 将指定元素elem的n份拷贝加入(赋值)到容器中
assign(begin, end) 将迭代器[beg,end)间的元素赋值给当前容器
push_back(elem) 将元素附加到容器
pop_back() 删除容器尾元素
front 返回容器首元素
back() 返回容器尾元素
insert(position, elem) 将元素插入到容器指定位置
 
 
 
 
 
 
 
 
 
 
 
  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7. double values[] = {, , , , , , };
  8. // 构造向量,用迭代器[beg, end)间的元素初始化向量
  9. vector<double> doubleVector(values, values + );
  10.  
  11. cout << "Initial contents in doubleVector: ";
  12. for (int i = ; i < doubleVector.size(); i++)
  13. cout << doubleVector[i] << " ";
  14.  
  15. // 顺序容器:assign(n, elem) 将n份元素拷贝赋值给容器
  16. doubleVector.assign(, 11.5);
  17.  
  18. cout << "\nAfter the assign function, doubleVector: ";
  19. for (int i = ; i < doubleVector.size(); i++)
  20. cout << doubleVector[i] << " ";
  21.  
  22. // vector/deque中特有的函数at(index)返回指定位置的元素
  23. doubleVector.at() = 22.4;
  24. cout << "\nAfter the at function, doubleVector: ";
  25. for (int i = ; i < doubleVector.size(); i++)
  26. cout << doubleVector[i] << " ";
  27.  
  28. // 定义迭代器,令其指向向量首位置
  29. vector<double>::iterator itr = doubleVector.begin();
  30. // 顺序容器:insert(position, elem) 将元素插入指定位置
  31. doubleVector.insert(itr + , );
  32. // !!!警告!!! 调用vector的insert之后,所有的迭代器都【可能】失效!
  33. // doubleVector.insert(itr + 1, 666); // itr可能会失效
  34. itr = doubleVector.begin();
  35. doubleVector.insert(itr + , );
  36.  
  37. cout << "\nAfter the insert function, doubleVector: ";
  38. for (int i = ; i < doubleVector.size(); i++)
  39. cout << doubleVector[i] << " ";
  40.  
  41. // 一级容器: erase[beg, end) 删除指定迭代器范围的元素
  42. doubleVector.erase(itr + , itr + );
  43. //!!!警告!!! 调用vector的erase之后,beg及之后的迭代器都会失效!
  44.  
  45. cout << "\nAfter the erase function, doubleVector: ";
  46. for (int i = ; i < doubleVector.size(); i++)
  47. cout << doubleVector[i] << " ";
  48.  
  49. doubleVector.clear();
  50. cout << "\nSize is " << doubleVector.size() << endl;
  51. cout << "Is empty? " <<
  52. (doubleVector.empty() ? "true" : "false") << endl;
  53.  
  54. return ;
  55. }

VectorDemo

  1. #include <iostream>
  2. #include <deque>
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7. double values[] = {, , , , , , };
  8. // 构造deque,用迭代器[beg, end)间的元素初始化deque
  9. deque<double> doubleDeque(values, values + );
  10.  
  11. cout << "Initial contents in doubleDeque: ";
  12. for (int i = ; i < doubleDeque.size(); i++)
  13. cout << doubleDeque[i] << " ";
  14.  
  15. // 顺序容器:assign(n, elem) 将n份元素拷贝赋值给容器
  16. doubleDeque.assign(, 11.5);
  17. cout << "\nAfter assign: ";
  18. for (int i = ; i < doubleDeque.size(); i++)
  19. cout << doubleDeque[i] << " ";
  20.  
  21. // deque/vector中特有:at(index)返回指定位置的元素
  22. doubleDeque.at() = 22.4;
  23. cout << "\nAfter at: ";
  24. for (int i = ; i < doubleDeque.size(); i++)
  25. cout << doubleDeque[i] << " ";
  26.  
  27. deque<double>::iterator itr = doubleDeque.begin();
  28. // 顺序容器:insert(position, elem) 将元素插入指定位置
  29. doubleDeque.insert(itr + , );
  30. // doubleDeque.insert(itr + 1, 666); // Error! Unexpected Behavior
  31. // !!!警告!!! 调用deque的insert之后,所有的迭代器都【必然】失效!
  32. //
  33. itr = doubleDeque.begin(); // 重新获得迭代器
  34. doubleDeque.insert(itr + , );
  35.  
  36. cout << "\nAfter insert: ";
  37. for (int i = ; i < doubleDeque.size(); i++)
  38. cout << doubleDeque[i] << " ";
  39.  
  40. // 一级容器:erase[beg, end) 删除指定迭代器范围的元素
  41. doubleDeque.erase(itr + , itr + );
  42. // !!!警告!!! 调用deque的erase之后,所有的迭代器都【可能】失效!
  43. cout << "\nAfter erase: ";
  44. for (int i = ; i < doubleDeque.size(); i++)
  45. cout << doubleDeque[i] << " ";
  46.  
  47. doubleDeque.clear();
  48. cout << "\nAfter clear: ";
  49. cout << "Size is " << doubleDeque.size() << endl;
  50. cout << "Is empty? " <<
  51. (doubleDeque.empty() ? "true" : "false") << endl;
  52.  
  53. // deque/list特有:push_front(elem)将元素压入队头
  54. doubleDeque.push_front(10.10); // 10.10
  55. doubleDeque.push_front(20.22); // 20.22 10.10
  56. doubleDeque.push_front(30.33); // 30.33 20.22 10.10
  57. cout << "After push_front: ";
  58. for (int i = ; i < doubleDeque.size(); i++)
  59. cout << doubleDeque[i] << " ";
  60.  
  61. // deque/list特有:pop_front()删除队首元素
  62. doubleDeque.pop_front();
  63. // 顺序容器:pop_back()删除容器尾元素
  64. doubleDeque.pop_back();
  65. cout << "\nAfter pop: ";
  66. for (int i = ; i < doubleDeque.size(); i++)
  67. cout << doubleDeque[i] << " ";
  68.  
  69. return ;
  70. }

DequeDemo

  1. #include <iostream>
  2. #include <list>
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7. int values[] = {, , , };
  8. // 构造list,用迭代器[beg, end)间的元素初始化list
  9. list<int> intList(values, values + );
  10.  
  11. cout << "Initial contents in intList: ";
  12. list<int>::iterator p; // list的迭代器为双向迭代器
  13. for (p = intList.begin(); p != intList.end(); p++)
  14. cout << *p << " ";
  15.  
  16. // 顺序容器:assign(n, elem) 将n份元素拷贝赋值给容器
  17. intList.assign(, );
  18. cout << "\nAfter assign, intList: ";
  19. for (p = intList.begin(); p != intList.end(); p++)
  20. cout << *p << " ";
  21.  
  22. list<int>::iterator itr = intList.begin();
  23. itr++; // 迭代器指向第2个11: 11 ^11 11 11
  24. // 顺序容器:insert(position, elem) 将元素插入指定位置
  25. intList.insert(itr, ); // 11 555 ^11 11 11
  26. // 调用list的insert之后,迭代器不受影响,仍指向第2个11
  27. intList.insert(itr, ); // 11 555 666 ^11 11 11
  28. cout << "\nAfter insert, intList: ";
  29. for (p = intList.begin(); p != intList.end(); p++)
  30. cout << *p << " ";
  31.  
  32. list<int>::iterator beg = intList.begin();
  33. itr++;
  34. // 一级容器: erase[beg, end) 删除指定迭代器范围的元素
  35. intList.erase(beg, itr);
  36. // !!!警告!!! 被删除元素的迭代器均失效,其它元素迭代器仍有效
  37. cout << "\nAfter erase, intList: ";
  38. for (p = intList.begin(); p != intList.end(); p++)
  39. cout << *p << " ";
  40.  
  41. intList.clear();
  42. cout << "\nAfter clear, intList: ";
  43. cout << "Size is " << intList.size() << endl;
  44. cout << "Is empty? " <<
  45. (intList.empty() ? "true" : "false");
  46.  
  47. // deque/list特有:push_front(elem)将元素插入列表首部
  48. intList.push_front();
  49. intList.push_front();
  50. intList.push_front();
  51. cout << "\nAfter push, intList: ";
  52. for (p = intList.begin(); p != intList.end(); p++)
  53. cout << *p << " ";
  54.  
  55. // deque/list特有:pop_front()删除列表首元素
  56. intList.pop_front();
  57. // 顺序容器:pop_back()删除容器尾元素
  58. intList.pop_back();
  59. cout << "\nAfter pop functions, intList: ";
  60. for (p = intList.begin(); p != intList.end(); p++)
  61. cout << *p << " ";
  62.  
  63. int values1[] = {, , , };
  64. list<int> list1(values1, values1 + );
  65. // list特有:sort() 将元素按升序排列
  66. list1.sort();
  67. cout << "\nAfter sort, list1: ";
  68. for (p = list1.begin(); p != list1.end(); p++)
  69. cout << *p << " ";
  70.  
  71. list<int> list2(list1);
  72. // list特有:merge(l2) 假定当前list与list2都已排序,
  73. // 将list2合并至本表,list2变空
  74. list1.merge(list2);
  75. cout << "\nAfter merge, list1: ";
  76. for (p = list1.begin(); p != list1.end(); p++)
  77. cout << *p << " ";
  78. cout << "\nSize of list2 is " << list2.size();
  79.  
  80. // list特有:reverse()反转本列表
  81. list1.reverse();
  82. cout << "\nAfter reverse, list1: ";
  83. for (p = list1.begin(); p != list1.end(); p++)
  84. cout << *p << " ";
  85.  
  86. list1.push_back();
  87. list1.push_back();
  88. cout << "\nAfter push, list1: ";
  89. for (p = list1.begin(); p != list1.end(); p++)
  90. cout << *p << " ";
  91.  
  92. // list特有:remove(elem)删除表中与elem相等的元素
  93. list1.remove();
  94. cout << "\nAfter remove, list1: ";
  95. for (p = list1.begin(); p != list1.end(); p++)
  96. cout << *p << " ";
  97.  
  98. // 顺序容器:assign(n, elem) 将n份elem拷贝赋值给容器
  99. list2.assign(, );
  100. cout << "\nAfter assign, list2: ";
  101. for (p = list2.begin(); p != list2.end(); p++)
  102. cout << *p << " ";
  103.  
  104. p = list2.begin();
  105. p++;
  106. // list特有:splice(pos,li)将li中所有元素移至本表pos位置之前
  107. // 然后li变空
  108. list2.splice(p, list1);
  109. cout << "\nAfter splice, list2: ";
  110. for (p = list2.begin(); p != list2.end(); p++)
  111. cout << *p << " ";
  112. cout << "\nAfter splice, list1 size: "
  113. << list1.size();
  114.  
  115. return ;
  116. }

ListDemo

 
容器适配器(Container Adapters)

  Features:
    ①由顺序容器变化而来
    ②程序员可为适配器选择合适的顺序容器

4.栈(stack) 后进先出的值的排列 <stack>

  stack<ElementType> st;     //创建一个空栈st

  st.push(ElementType);      //在栈顶增加元素

  st.pop();             //移除栈顶元素(不会返回栈顶元素的值)

  st.top();              //返回栈顶元素

  st.empty();           //判断栈是否为空,空则返回true

  st.size();            //返回栈中元素数目

5.队列(queue) 先进先出的值的排列 <queue>

  queue<ElementType> q;    //创建一个空队列

  q.push(ElementType);      //将一个元素置入queue中

  q.pop();             //从queue中移除一个元素(不会返回队头元素值)

  q.front();                 //返回queue内的第一个元素(也就是第一个被置入的元素)

  q.back();            //返回queue中最后一个元素(也就是最后被插入的元素)

  q.empty();           //判断队列是否为空,空则返回true

  q.size();            //返回队列中元素数目。

  注意:pop()虽然会移除下一个元素,但是并不返回它,front()和back()返回下一个元素但并不移除该元素。

6.优先队列(priority_queue) 元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 <queue>

  priority_queue<ElementType> pq;     //创建一个数据越大,优先级越高的队列

  priority_queue<int, vector<int>, greater<int> > pq;  //创建一个数据越小,优先级越高的队列

  pq.push(ElementType);    //将一个元素置入priority_queue中

  pq.pop();           //从priority_queue中移除一个元素(不会返回队头元素值)

  pq.top();            //返回priority_queue中优先级最高的元素

  pq.empty();           //判断priority_queue是否为空,空则返回true

  pq.size();           //返回priority_queue中元素数目

  自定义优先级,重载比较符号

  重载默认的 < 符号

  1. struct node
  2. {
  3. friend bool operator< (node n1, node n2)
  4. {
  5. return n1.priority < n2.priority;
  6. }
  7. int priority;
  8. int value;
  9. };

  这时,需要为每个元素自定义一个优先级。

  注:重载>号会编译出错,因为标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。
  而且自定义类型的<操作符与>操作符并无直接联系

  1. #include<iostream>
  2. #include<functional>
  3. #include<queue>
  4. using Namespace stdnamespace std;
  5. struct node
  6. {
  7. friend bool operator< (node n1, node n2)
  8. {
  9. return n1.priority < n2.priority;
  10. }
  11. int priority;
  12. int value;
  13. };
  14. int main()
  15. {
  16. const int len = ;
  17. int i;
  18. int a[len] = {,,,,};
  19. //示例1
  20. priority_queue<int> qi;
  21. for(i = ; i < len; i++)
  22. qi.push(a[i]);
  23. for(i = ; i < len; i++)
  24. {
  25. cout<<qi.top()<<" ";
  26. qi.pop();
  27. }
  28. cout<<endl;
  29. //示例2
  30. priority_queue<int, vector<int>, greater<int> >qi2;
  31. for(i = ; i < len; i++)
  32. qi2.push(a[i]);
  33. for(i = ; i < len; i++)
  34. {
  35. cout<<qi2.top()<<" ";
  36. qi2.pop();
  37. }
  38. cout<<endl;
  39. //示例3
  40. priority_queue<node> qn;
  41. node b[len];
  42. b[].priority = ; b[].value = ;
  43. b[].priority = ; b[].value = ;
  44. b[].priority = ; b[].value = ;
  45. b[].priority = ; b[].value = ;
  46. b[].priority = ; b[].value = ;
  47.  
  48. for(i = ; i < len; i++)
  49. qn.push(b[i]);
  50. cout<<"优先级"<<'\t'<<"值"<<endl;
  51. for(i = ; i < len; i++)
  52. {
  53. cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;
  54. qn.pop();
  55. }
  56. return ;
  57. }

View Eg Code

  优先队列(priority_queue) from:http://www.cnblogs.com/void/archive/2012/02/01/2335224.html

关联式容器(Associative Containers)

  Features:
    ①使用“key”快速存取元素
    ②元素按规则排序
    ③默认用< 运算符排序

7.集合(set) 由节点组成的红黑树,每个节点都包含着一个元素,节点之间以某种作用于元素对的谓词排列,没有两个不同的元素能够拥有相同的次序 。快速查询元素,无重复关键字。<set>
8.多重集合(multiset) 允许存在两个次序相等的元素的集合。与set相同,但允许重复关键字<set>
9.映射(map) 由{键,值}对组成的集合,以某种作用于键对上的谓词排列。Key/value pair mapping(键值对映射)。不允许重复关键字,使用关键字快速查询元素 <map>
10.多重映射(multimap) 允许键对有相等的次序的映射。与map相同,但允许重复关键字 <map>
 
关联容器中的共同函数
函数 描述
find(key) 搜索容器中具有key的元素,返回指向该元素的迭代器
lower_bound(key) 搜索容器中具有key的第一个元素,返回指向该元素的迭代器
upper_bound(key) 搜索容器中具有key的最后一个元素,返回指向该元素之后位置的迭代器
count(key) 返回容器中具有key的元素的数目
 
 
 
 
 
 
 
 
  1. #include <iostream>
  2. #include <set>
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7. int values[] = {, , , , , };
  8. // 构造multiset,用迭代器[beg, end)间的元素初始化deque
  9. // 升序排列 1,2,2,3,5,7
  10. multiset<int> set1(values, values + );
  11. // 降序排列 7,5,3,2,2,1
  12. // multiset<int, greater<int> > set1(values, values + 6);
  13.  
  14. cout << "Initial contents in set1: ";
  15. multiset<int>::iterator p;
  16. for (p = set1.begin(); p != set1.end(); p++) // set支持双向迭代器
  17. cout << *p << " ";
  18.  
  19. set1.insert(); // 1,2,2,3,5,7,555
  20. set1.insert(); // 1,1,2,2,3,5,7,555
  21. cout << "\nAfter insert, set1: ";
  22. for (p = set1.begin(); p != set1.end(); p++)
  23. cout << *p << " ";
  24.  
  25. p = set1.lower_bound(); // p指向容器中第一个2
  26. cout << "\nValue of Lower bound of 2: " << *p;
  27. p = set1.upper_bound(); // p指向容器中最后一个2的后面
  28. cout << "\nValue of Upper bound of 2: " << *p;
  29.  
  30. p = set1.find();
  31. if (p == set1.end()) // 若迭代器指向set尾部,则未找到
  32. cout << "2 is not in set1" << endl;
  33. else
  34. cout << "\nThe number of 2: " << set1.count();
  35.  
  36. set1.erase(); // 将所有值为2的元素都删掉
  37. cout << "\nAfter erase, set1: ";
  38. for (p = set1.begin(); p != set1.end(); p++)
  39. cout << *p << " ";
  40.  
  41. return ;
  42. }

SetDemo

  1. #include <iostream>
  2. #include <map>
  3. #include <string>
  4. using namespace std;
  5.  
  6. int main()
  7. {
  8. map<int, string> map1;
  9. // 插入键值对
  10. map1.insert(map<int, string>::value_type(, "Zhang San"));
  11. map1.insert(map<int, string>::value_type(, "Li Si"));
  12. map1.insert(map<int, string>::value_type(, "Zhen Xiaosa"));
  13. map1.insert(map<int, string>::value_type(, "Hao Meili"));
  14.  
  15. cout << "Initial contents in map1:\n";
  16. map<int, string>::iterator p;
  17. for (p = map1.begin(); p != map1.end(); p++)
  18. cout << p->first << " " << p->second << endl;
  19. // 使用 first 访问 key; 使用 second 访问 value
  20.  
  21. cout << "Enter a key to serach for the name: ";
  22. int key;
  23. cin >> key;
  24. p = map1.find(key);
  25.  
  26. if (p == map1.end()) // 若迭代器指向map尾部,则未找到指定键
  27. cout << " Key " << key << " not found in map1";
  28. else
  29. cout << " " << p->first << " " << p->second << endl;
  30.  
  31. map1.erase();
  32. cout << "\nAfter erase 103, map1:\n";
  33. for (p = map1.begin(); p != map1.end(); p++)
  34. cout << p->first << " " << p->second << endl;
  35.  
  36. return ;
  37. }

MapDemo

STL之容器基本操作的更多相关文章

  1. 详解C++ STL map 容器

    详解C++ STL map 容器 本篇随笔简单讲解一下\(C++STL\)中的\(map\)容器的使用方法和使用技巧. map容器的概念 \(map\)的英语释义是"地图",但\( ...

  2. C++ STL vector容器学习

    STL(Standard Template Library)标准模板库是C++最重要的组成部分,它提供了一组表示容器.迭代器.函数对象和算法的模板.其中容器是存储类型相同的数据的结构(如vector, ...

  3. STL List容器

    转载http://www.cnblogs.com/fangyukuan/archive/2010/09/21/1832364.html 各个容器有很多的相似性.先学好一个,其它的就好办了.先从基础开始 ...

  4. STL之容器适配器queue的实现框架

    说明:本文仅供学习交流,转载请标明出处,欢迎转载! 上篇文章STL之容器适配器stack的实现框架已经介绍了STL是怎样借助基础容器实现一种经常使用的数据结构stack (栈),本文介绍下第二种STL ...

  5. STL的容器算法迭代器的设计理念

    1) STL的容器通过类模板技术,实现数据类型和容器模型的分离. 2) STL的迭代器技术实现了遍历容器的统一方法:也为STL的算法提供了统一性. 3) STL的函数对象实现了自定义数据类型的算法运算 ...

  6. c++复习:STL之容器

    1 STL的string 1 String概念 string是STL的字符串类型,通常用来表示字符串.而在使用string之前,字符串通常是用char*表示的.string与char*都可以用来表示字 ...

  7. stl之容器、迭代器、算法几者之间的关系

    转自:https://blog.csdn.net/bobodem/article/details/49386131 stl包括容器.迭代器和算法: 容器 用于管理一些相关的数据类型.每种容器都有它的优 ...

  8. STL Queue 容器

    STL Queue 容器 Queue简介         queue是队列容器,是一种“先进先出”的容器.         queue是简单地装饰deque容器而成为另外的一种容器.        # ...

  9. STL stack 容器

    STL stack 容器 Stack简介 stack是堆栈容器,是一种“先进后出”的容器.      stack是简单地装饰deque容器而成为另外的一种容器.      #include <s ...

随机推荐

  1. Integer cache

    View.findViewById采用深度遍历,找到第一个匹配的控件 Integer Cache public static void testIntegerCache() { Class cache ...

  2. 转载:Cocos2D-x 游戏接入 Windows 设备所需做的六件事

    原文地址:http://msopentech.com/zh-hans/blog/2014/05/09/cocos2d-x-%E6%B8%B8%E6%88%8F%E6%8E%A5%E5%85%A5-wi ...

  3. Xml语言

    一.XML是什么?作用是什么? l  XML ( eXtensible Markup Language )语言是一种可扩展的标记语言.其中的可扩展是相对HTML来说的.因为XML标签没有被预定义,需要 ...

  4. Node.js log4js日志记录

    这次需要给之前弄的文件服务器添加日志记录,一般每天产生的日志会特别多所以安装日期来划分是最好的,这里我用了express框架,为了适应express框架这里在log.js文件中写了use方法. //日 ...

  5. Flex 使用列表和表格

    Flex 设计了不同的控件来实现列表和表格,不仅能够将数据显示在表格和列表中,还可以实现对数据进行操纵,修改等更加强大的功能. 与列表和表格相关的控件如下所示: 列表控件(List Control): ...

  6. 慕课网-安卓工程师初养成-2-1 Java中的关键字

    来源:http://www.imooc.com/code/1176 Java 中常用关键字: 问:这么多,记不住啊......-_-|| 答:现在不需要你记住所有,混个眼熟即可,在学习的过程中,你会逐 ...

  7. IE SEESION共享的问题

    前几天,我们在开发工作流的过程中出现了一个比较奇怪的问题,原本看不到流程的人员,在登陆后却能够看到对应流程的待办任务,并且导致流程流向混乱!在调模式下调试程序发现(假设登陆两个用户)第二个登陆用户的信 ...

  8. 华为OJ平台——整形数组合并

    题目描述: 将两个整型数组按照升序合并,并且过滤掉重复数组元素 输入: 输入说明,按下列顺序输入: 1 输入第一个数组的个数 2 输入第一个数组的数值 3 输入第二个数组的个数 4 输入第二个数组的数 ...

  9. c#中如何做日期的三元判断(日期不为空赋值)

    <dx:ASPxDateEdit runat="server" ID="edTab4_protocoldate" Width="100%&quo ...

  10. 在Tomcat下部属项目三种方式:

    在Tomcat下部属项目三种方式:       1直接复制:       2. 通过配置虚拟路径的方式    直接修改配置文件 写到tomcat/conf/server.xml     找到<H ...