java集合框架--List、Set、Map

 

1.List：有序的 collection（也称为序列）。此接口可以对列表中每个元素的插入位置进行精确地控制。可以根据元素的在列表中的位置访问元素，并搜索列表中的元素。列表允许重复的元素。



   ArrayList: 



   特点：有序的、线性的、无固定大小的、有下标的、先进先出



   简单操作应用：

public static void main(String args[]) {

1. // 创建一个队列对象
2. java.util.ArrayList<String> list = new java.util.ArrayList<String>();
3. // 装入10个数据
4. ; i < 10; i++) {
5. String s = "元素" + i;
6. //加元素
7. list.add(s);
8. }
9. // 遍历1
10. ; i < list.size(); i++) {
11. // 根据下标取出一个元素
12. String str = list.get(i);
13. System.out.print(str+"\t");
14. }
15. System.out.println();
16. //遍历2
17. //得到队列的迭代器对象
18. java.util.Iterator<String> iter = list.iterator();
19. //判断是否有数据可以迭代
20. while(iter.hasNext()){
21. //取出一个元素
22. String str = iter.next();
23. System.out.print(str+"\t");
24. }
25. System.out.println();
26. //遍历3
27. for(String str:list){
28. System.out.print(str+"\t");
29. }

2.Set:是简单的集合，它的对象不按特定方式排序，只是简单的把对象加入集合中。不能有重复对象。

HashSet:

特点：无序的，长度可变的，不可重复的

简单的操作应用：

public static void main(String args[]) {

1. // 创建一个容器对象
2. java.util.HashSet<String> sets = new java.util.HashSet<String>();
3. // 装入10个元素
4. ; i < 10; i++) {
5. String s = "元素a" + i;
6. sets.add(s);
7. }
8. //检验若输入加入重复的元素，在集合中的是原来的还是新加入的（结果表明是原来的）
9. boolean b = sets.add("新来的");
10. boolean b1 = sets.add("新来的");
11. System.out.println(b + "<>" + b1);
12. // 遍历1
13. // 得到迭代器对象
14. java.util.Iterator<String> iter = sets.iterator();
15. while (iter.hasNext()) {
16. String str = iter.next();
17. System.out.print(str + "\t");
18. }
19. System.out.println();
20. //遍历2
21. for(String str:sets){
22. System.out.print(str+"\t");
23. }

3.Map:Map中存入的对象是一对一对的，即每个对象和它的一个名字（键：key）关联在一起，一个键（key）只能对应一个值（value）,反则不然。

HashMap:

特点：无序的、不可重复的

简单的操作应用：

public static void main(String args[]) {

1. // 创建一个映射对象
2. java.util.HashMap<Integer, String> maps = new java.util.HashMap<Integer, String>();
3. // 装入键值对
4. ; i < 20; i++) {
5. ;
6. String name = "学生" + i;
7. // 装入一个键值对
8. maps.put(num, name);
9. }
10. //增加一个键值对，加入K相同的键值对，则会替换已经存在的键值对
11. , "新学生");
12. , "新学生");
13. , "又来一个");
14. //遍历
15. //得到K的Set集合
16. java.util.Set<Integer> set = maps.keySet();
17. //遍历K的集合，得到set的迭代器
18. java.util.Iterator<Integer> iter = set.iterator();
19. while(iter.hasNext()){
20. //取出一个key
21. int num = iter.next();
22. //根据key得到对应的Value
23. String name = maps.get(num);
24. System.out.println(num+"\t"+name);
25. }

两个应用：

1.package hpw.collection;

1. /**
2. * 任意的一个数组，重复排序
3. *
4. * @author
5. *
6. */
7. public class Task1 {
8. public static void main(String args[]) {
9. // 创建一个数组
10. , 345, 467, 45, 786, 133, 456, 89, 45,
11. , 786, 467, 123, 456 };
12. int[] temp = RemoveRepeat(array);
13. // 出去重复后，打印数组
14. ; i < temp.length; i++) {
15. System.out.print(temp[i] + "\t");
16. }
17. System.out.println();
18. int[] newarray = sort(temp);
19. // 排序后，打印数组
20. ; i < newarray.length; i++) {
21. System.out.print(newarray[i] + "\t");
22. }
23. }
24. /**
25. * 去除数组中重复的元素
26. *
27. * @param base
28. *            ：要去除的数组
29. * @return：去除重复后的数组
30. */
31. public static int[] RemoveRepeat(int[] base) {
32. // 创建一个集合
33. java.util.HashSet<Integer> sets = new java.util.HashSet<Integer>();
34. // 遍历数组，将元素装入集合
35. ; i < base.length; i++) {
36. int temp = base[i];
37. // 将元素装入集合
38. sets.add(temp);
39. }
40. //创建一个新的数组
41. int[] newarry=new int[sets.size()];
42. // 得到迭代器
43. java.util.Iterator<Integer> ite = sets.iterator();
44. // 遍历集合，将元素装入队列
45. ; ite.hasNext(); i++) {
46. newarry[i] = ite.next();
47. }
48. return newarry;
49. }
50. /**
51. * 将数组排序
52. *
53. * @param base
54. *            ：原数组
55. * @return:排序后的数组
56. */
57. //冒泡排序
58. public static int[] sort(int[] base){
59. ;i<base.length;i++){
60. ;j<base.length;j++){
61. if(base[i]>base[j]){
62. int temp=base[i];
63. base[i]=base[j];
64. base[j]=temp;
65. }
66. }
67. }
68. return base;
69. }
70. }

2.package hpw.collection;

1. import java.util.HashMap;
2. /**
3. * 统计重复
4. * @author lenovo
5. *
6. */
7. public class Task2 {
8. public static void main(String args[]){
9. // 创建一个数组
10. , 345, 467, 45, 786, 133, 456, 89, 45,
11. , 786, 467, 123, 456,45 };
12. //创建一个映射
13. java.util.HashMap<Integer, Integer> map=new java.util.HashMap<Integer, Integer>();
14. //统计
15. map=count(array);
16. //打印
17. print(map);
18. }
19. /**
20. * 统计出现的次数
21. * @param base：原数组
22. * @return：java.util.HashMap<Integer：数组元素, Integer：出现的次数>
23. */
24. public static java.util.HashMap<Integer, Integer> count(int[] base){
25. //创建一个映射
26. java.util.HashMap<Integer, Integer> maps=new java.util.HashMap<Integer, Integer>();
27. //遍历数组，出现重复，value+1
28. ;i<base.length;i++){
29. //判断是否出现重复
30. if(maps.containsKey(base[i])){
31. ;
32. maps.put(base[i], value);
33. }else{
34. );
35. }
36. }
37. return maps;
38. }
39. /**
40. * 打印队列
41. * @param map
42. */
43. public static void print(HashMap<Integer, Integer> map){
44. //创建一个集合，得到K的元素
45. java.util.Set<Integer> set=map.keySet();
46. //遍历集合，获得迭代器
47. java.util.Iterator<Integer> ite=set.iterator();
48. while(ite.hasNext()){
49. //去除key
50. int key=ite.next();
51. //得到相应的value
52. int value=map.get(key);
53. System.out.println(key+"\t"+value);
54. }
55. }
56. }