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

2022-09-26 21:11:14

 

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. }
上一篇：【XMPP】XMPP类型


下一篇：Django之模型管理器filter处理问题