笔记29 | Java的容器类

地址

前人栽树：http://blog.csdn.net/aqi00/article/details/50419268

后人乘凉：http://blog.csdn.net/xiangyong_1521/article/details/78456133

目录

• 集合(Set/HashSet)

• 队列(ArrayList)

• 链表(LinkedList)

• 向量(Vector)

• 堆栈(Stack)

• 映射(Map/HashMap)

• 哈希表(Hashtable)

• 容器的遍历操作

• 附

---

---

1.集合(Set/HashSet)简介

集合中的元素是没有顺序的，而且不可以重复。这意味着，集合只能遍历而无法通过索引访问指定元素，并且如果重复添加相同值将不会增大集合。因为Set只是接口，所以实际用的是它的一个派生类HashSet。集合的常用方法如下：

add : 添加元素

clear : 清空容器

contains : 判断容器中是否存在该元素

iterator : 获取第一个元素的指针

isEmpty : 判断容器是否为空

remove : 删除元素

size : 获取容器大小

---

2.队列(ArrayList)

队列与集合恰恰相反，队列中的元素是有顺序的，而且允许重复，所以队列可以使用索引来访问指定元素（类似数组的下标）。队列的常用方法包括上面集合列出的几个，下面列出有变更或者添加的方法：

add : 提供了两个方法。默认在队列末尾添加元素；如果指定了索引位置，则在指定位置末尾添加元素

get : 获取指定位置的元素

indexOf : 获取指定元素的第一个索引位置

lastIndexOf : 获取指定元素的最后一个索引位置

remove : 提供了两个方法。除了删除元素之外，还可以删除指定位置的元素

set : 替换指定位置的元素

subList : 截取从开始位置到结束位置之间的子队列

---

3.链表(LinkedList)

链表又称双端队列（类似C++的deque），如其名字所言，每个元素都有由三块区域组成，一块指向前一个元素，一块指向后一个元素，最后一块才是保存的对象。所以对于需要快速操作首尾元素，应该使用链表，如果需要快速操作随机元素，应该使用队列。链表的常用方法包括上面队列列出的几个，下面列出添加的方法

addFirst/addLast : 添加到开头/添加到末尾

getFirst/getLast : 获取首元素/获取末元素

removeFirst/removeLast : 删除首元素/删除末元素

offer/offerFirst/offerLast : 以deque方式添加元素，与之相对的是，add是以list方式添加元素

peek/peekFirst/peekLast : 获取但不移除此队列的首尾元素，默认获取首元素

poll/pollFirst/pollLast : 获取并移除此队列的首尾元素，默认获取并移除首元素

pop : 出栈第一个元素，即以stack方式删除元素

push : 入栈指定元素，即以stack方式添加元素我们看到，链表实现了好几种添加和删除方法，它们的区别总结如下：以列表方式（list）操作元素：add添加，remove删除

以双端队列方式（deque）操作元素：offer添加，poll删除

以堆栈方式（stack）操作元素：push添加，pop删除

---

4.向量(Vector)

向量非常类似队列，但队列是异步的，而向量是同步的。具体的说，当一个向量的指针Iterator正在使用时，另一个线程改变了向量的状态（比如添加或删除了一些元素），这时调用指针的方法将抛出异常(ConcurrentModificationException)。向量的常用方法与队列是一样的，虽然看源码会发现其他几个名字带element的函数，可是这几个函数的用法等同于队列的对应函数，所以就不一一列举了。

---

5.堆栈(Stack)

堆栈是从向量派生而来，它实现一个后进先出的堆栈。堆栈的常用方法比向量多了三个，分别是

peek（获取首元素）、

pop（出栈）、

push（入栈），

看起来Stack类似一个堆栈方式的链表。

---

6.映射(Map/HashMap)

映射保存的是键值对（即key—value）的映射关系，一个映射中不能包含相同的key，每个key只能映射一个value。但Map只是接口，实际中常用的是它的一个派生类HashMap。类似的，队列、链表、向量都是派生自List接口。映射的常用方法如下：

clear : 清空容器

containsKey : 判断容器中是否存在该键（key）的元素

containsValue : 判断容器中是否存在该值（value）的元素

get : 根据指定键获得元素的值

isEmpty : 判断容器是否为空

keySet : 获取容器中键的集合

put : 设置键值对的映射关系。如原来没有该键，则添加元素；如果原来存在该键，则替换元素

remove : 删除指定键对应的元素

size : 获取容器的大小

values : 获取容器中值的集合

---

7.哈希表(Hashtable)

哈希表也是从Map派生而来，与HashMap不同，HashMap是异步的，而HashTable是同步的。因为同步需要花费机器时间，所以HashTable的执行效率要低于HashMap，向量和队列的情况与之类似。哈希表的常用方法与映射是一样的，就不一一列举了。

---

8.容器的遍历操作

8.1.a. ArrayList

1.        ArrayList<Integer> i = new ArrayList<Integer>();

2.        i.add( 1);

3.        i.add( 2);

4.        i.add( 3);

5.        i.add( 4);

6.        i.add( 5);

7.        i.add( 6);

8.        i.add( 7);

9.        i.add( 8);

11.        //循环遍历  

12.        for (Integer ii : i) {

13.            Log.i("md", "循环遍历: "+ii);

14.        }

16.        //索引遍历  

17.        for (int iq=0; iq<i.size(); iq++) {  

18.            Log.i("md", "索引遍历  :"+String.format("array[%d]=%s", iq, i.get(iq)));

19.        }

8.1.b.  logcat

1. 01-01 01:55:49.909: I/md(6335): 循环遍历: 1

2. 01-01 01:55:49.909: I/md(6335): 循环遍历: 2

3. 01-01 01:55:49.909: I/md(6335): 循环遍历: 3

4. 01-01 01:55:49.909: I/md(6335): 循环遍历: 4

5. 01-01 01:55:49.909: I/md(6335): 循环遍历: 5

6. 01-01 01:55:49.912: I/md(6335): 循环遍历: 6

7. 01-01 01:55:49.912: I/md(6335): 循环遍历: 7

8. 01-01 01:55:49.912: I/md(6335): 循环遍历: 8

9. 01-01 01:55:50.050: I/md(6335): 索引遍历  :array[0]=1

10. 01-01 01:55:50.051: I/md(6335): 索引遍历  :array[1]=2

11. 01-01 01:55:50.054: I/md(6335): 索引遍历  :array[2]=3

12. 01-01 01:55:50.055: I/md(6335): 索引遍历  :array[3]=4

13. 01-01 01:55:50.057: I/md(6335): 索引遍历  :array[4]=5

14. 01-01 01:55:50.060: I/md(6335): 索引遍历  :array[5]=6

15. 01-01 01:55:50.061: I/md(6335): 索引遍历  :array[6]=7

16. 01-01 01:55:50.062: I/md(6335): 索引遍历  :array[7]=8

8.2.a. LinkedList

1.        LinkedList<Integer> i = new LinkedList<Integer>();

2.        for (int j = 0; j < 10; j++) {

3.            i.add(j);

4.        }

5.        Log.i("md", "增加前:"+i);

6.        i.add(0,520);

7.        i.add(3,7788);

8.        i.add(6,333);

9.        Log.i("md", "增加后:"+i);

8.2.b. logcat

1. 01-01 01:58:36.133: I/md(6395): 增加前:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2. 01-01 01:58:36.133: I/md(6395): 增加后:[520, 0, 1, 7788, 2, 3, 333, 4, 5, 6, 7, 8, 9]

8.3.a HashMap

1. HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

2.        for (int i = 0; i < 10; i++) {

3.            map.put(i, i+10);

4.        }

5.        Log.i("md", "增加前:"+map);

6.        map.put(51, 520);

7.        Log.i("md", "增加后:"+map);

9.        Set<Integer> key_set = map.keySet();  

10.        for (Integer item_key : key_set) {  

11.            Log.i("md","item_key="+item_key+", item_value="+map.get(item_key));

12.        }  

8.3.b. logcat

1. 01-01 02:00:27.676: I/md(6477): 增加前:{0=10, 1=11, 2=12, 3=13, 4=14, 5=15, 6=16, 7=17, 8=18, 9=19}

2. 01-01 02:00:27.678: I/md(6477): 增加后:{51=520, 0=10, 1=11, 2=12, 3=13, 4=14, 5=15, 6=16, 7=17, 8=18, 9=19}

3. 01-01 02:00:27.680: I/md(6477): item_key=51, item_value=520

4. 01-01 02:00:27.680: I/md(6477): item_key=0, item_value=10

5. 01-01 02:00:27.681: I/md(6477): item_key=1, item_value=11

6. 01-01 02:00:27.682: I/md(6477): item_key=2, item_value=12

7. 01-01 02:00:27.682: I/md(6477): item_key=3, item_value=13

8. 01-01 02:00:27.683: I/md(6477): item_key=4, item_value=14

9. 01-01 02:00:27.683: I/md(6477): item_key=5, item_value=15

10. 01-01 02:00:27.684: I/md(6477): item_key=6, item_value=16

11. 01-01 02:00:27.685: I/md(6477): item_key=7, item_value=17

12. 01-01 02:00:27.686: I/md(6477): item_key=8, item_value=18

13. 01-01 02:00:27.687: I/md(6477): item_key=9, item_value=19

---

附

笔记28 | 学习一个简单好用的下拉刷新、上拉加载控件

笔记27 | WindowManager实现悬浮窗口总结

笔记26 | 总结Android的获取系统时间的几种方法

笔记25 | 通过自定义VIEW实现一个圆盘转动UI

笔记24 | 一个中间打开界面的动画

结束

---

---

转载于:https://www.cnblogs.com/xiangevan/p/10751689.html