• Java集合类--List集合,Set集合,Map集合


            集合可以看作一个容器,Java中提供了不同的集合类,这些类具有不同的存储对象的方式,同时提供了相应的方法,以便用户对集合进行遍历、添加、删除、查找指定的对象。

    1.集合类概述:

            集合类类似于数组,与数组不同的是,数组的长度是固定的,集合的长度是可变的数组用来存放基本类型数据,集合用来存放对象的引用。

    1.1 常用集合:

            1.1.1 List集合

            List集合继承了Collection接口

            1.1.2 Set集合

            List集合继承了Collection接口

            1.1.3 Map集合

    2.Collection接口

            Collection接口是集合类层次结构中的根接口,Collection接口通常不能直接使用,但该接口提供了添加元素,删除元素,管理数据的方法。因为Set和List集合都继承了Collection接口,所以Set集合和List集合都具备这些增删改查方法。

    Collection接口的常用方法
    方法功能描述
    add(E e)将指定的对象添加到该集合中
    remove(Object obj)将指定的对象从该集合中移除
    isEmpty()返回boolean值,用于判断该集合是否为空
    iterator()返回在此Collection元素上进行迭代的迭代器,用于遍历集合中的对象
    size()返回int型值,获取该集合中的元素个数
    1. package setclass;
    2. import java.util.*; //导入java.util包,所有使用集合的实例都要添加该语句
    3. public class Muster {
    4. public static void main(String[] args) {
    5. Collection list = new ArrayList<>(); // 实例化集合类对象
    6. list.add("a"); //向集合中添加数据
    7. list.add("b");
    8. list.add("c");
    9. Iterator it = list.iterator(); //创建list这个集合的迭代器
    10. while (it.hasNext()) { //判断是否有下一个元素
    11. String str = (String) it.next(); //迭代器.next()方法用于获取下一个元素
    12. System.out.println(str);
    13. }
    14. }
    15. }
    16. 输出:
    17. a
    18. b
    19. c

            iterator的next()方法返回的是Object对象。

    3.List集合

            List集合包含List接口及List接口的所有实现类。List集合允许元素重复,类似Java数组,可通过索引访问List集合中的元素。

    3.1 List接口

            List接口因为继承了Collection接口,所以具备Collection接口的所有方法,除此之外,List接口还额外实现了2种非常重要的方法:

            3.1.1 get(int index):获取指定索引位置元素

            3.1.2 set(int index, object obj):修改集合中指定索引位置处的元素为object;

    3.2 List接口的实现类

            3.2.1 ArrayList

            优点:

            ArrayList类实现了可变数组,允许保存所有元素,包括null,并可以根据索引位置对集合进行快速的随机访问;

            缺点:

            向指定的索引位置插入对象或者删除对象的速度较慢。

             ArrayList类实现List接口的语法:
            List list = new ArrayList<>();

            E可以是Java合法的数据类型,如String;

            3.2.2 LinkedList

            优点:

            LinkedList类采用链表结构保存对象。便于向集合中插入/删除对象,这种LinkedList类效率较高;

            缺点:

            对于根据索引位置随机访问集合中的对象,LinkedList类实现List集合的效率较低;

            LinkedList类实现List接口的语法:
            List list = new LinkedList<>();

            E可以是Java合法的数据类型,如String;

    1. package setclass;
    2. import java.util.ArrayList;
    3. import java.util.Iterator;
    4. import java.util.List;
    5. public class Gather {
    6. public static void main(String[] args) {
    7. List list = new ArrayList<>(); //创建集合对象
    8. list.add("a");
    9. list.add("b");
    10. list.add("c");
    11. int i = (int) (Math.random() * list.size()); //根据结合长度获取0~2之间的随机数
    12. System.out.println("随机获得集合中的元素:" + list.get(i));
    13. list.remove(2); //将索引为2的位置的元素从集合中移除
    14. System.out.println("将索引为2位置的元素移除后,集合的元素有:");
    15. Iterator it = list.iterator();
    16. int j = 0;
    17. while (j < list.size()) {
    18. System.out.println(list.get(j));
    19. j++;
    20. }
    21. }
    22. }
    23. 输出:
    24. 随机获得集合中的元素:c
    25. 将索引为2位置的元素移除后,集合的元素有:
    26. a
    27. b

    4.Set集合

            Set集合对象不按特定的方式排序,只是简单地将对象加入集合中,但是Set集合中不能有重复对象;Set集合由Set接口和实现Set接口的实现类组成。Set接口也继承了Collection类,所以实现Set接口的集合类也包含Collection相关的方法。

    4.1 Set接口

            Set接口常用的实现类有HashSet和TreeSet。

    4.2 Set接口的实现类

            4.2.1 HashSet

            HashSet类实现Set接口,由哈希表(实际上就是一个HashMap实例)支持,不保证Set集合的迭代顺序,此类允许使用null元素。

            4.2.2 TreeSet

            TreeSet不仅实现了Set接口,还实现了java.utl.SortedSet接口,因此TreeSet实现的Set集合在遍历时按照自然顺序递增排序,也开一按照指定比较器递增排序。

    TreeSet类增加的方法
    方法功能描述
    first()返回此Set集合中第一个(最低)元素
    last()返回此Set集合中最后一个(最高)元素
    comparator()返回对此Set集合中元素进行排序的比较器,如果此Set使用自然排序,则返回null
    headSet(E toElement)返回一个新的Set集合,新集合是toElement(不包含)之前的所有对象
    tailSet(E fromElement)返回一个新的Set集合,新集合是fromElement(包含)之后的所有对象
    subSet(E fromElement, E toElement)返回一个新的Set集合,新集合是fromElementn(包含)到toElement(不包含)之间的所有对象
    1. package setclass;
    2. import java.util.Iterator;
    3. import java.util.TreeSet;
    4. public class updateStu implements Comparable { //创建类,实现Comparator接口
    5. String name;
    6. long id;
    7. public updateStu(String name, int id) { //构造方法
    8. this.name = name;
    9. this.id = id;
    10. }
    11. public int compareTo(Object o) {
    12. updateStu up_stu = (updateStu) o;
    13. int result = id > up_stu.id ? 1 : (id == up_stu.id ? 0 : -1); //对比两个对象id大小
    14. return result;
    15. }
    16. public String getName() {
    17. return name;
    18. }
    19. public void setName(String name) {
    20. this.name = name;
    21. }
    22. public long getId() {
    23. return id;
    24. }
    25. public void setId(long id) {
    26. this.id = id;
    27. }
    28. public static void main(String[] args) {
    29. updateStu stu1 = new updateStu("春田1", 101);
    30. updateStu stu2 = new updateStu("春田2", 102);
    31. updateStu stu3 = new updateStu("春田3", 103);
    32. updateStu stu4 = new updateStu("春田4", 104);
    33. TreeSet tree = new TreeSet<>();
    34. tree.add(stu1);
    35. tree.add(stu2);
    36. tree.add(stu3);
    37. tree.add(stu4);
    38. Iterator it = tree.iterator(); //Set集合中所有对象的迭代器
    39. System.out.println("TreeSet集合中的所有元素:");
    40. while (it.hasNext()) {
    41. updateStu up_stu = (updateStu) it.next();
    42. System.out.println(up_stu.getId() + " " + up_stu.getName());
    43. }
    44. it = tree.headSet(stu3).iterator(); //截取stu2对象之前的所有对象集合
    45. System.out.println("截取前面的部分集合:");
    46. while (it.hasNext()) {
    47. updateStu up_stu = (updateStu) it.next();
    48. System.out.println(up_stu.getId() + " " + up_stu.getName());
    49. }
    50. it = tree.subSet(stu1, stu3).iterator();
    51. System.out.println("截取中间部分的集合:");
    52. while (it.hasNext()) {
    53. updateStu up_stu3 = (updateStu) it.next();
    54. System.out.println(up_stu3.getId() + " " + up_stu3.getName());
    55. }
    56. }
    57. }
    58. 输出:
    59. TreeSet集合中的所有元素:
    60. 101 春田1
    61. 102 春田2
    62. 103 春田3
    63. 104 春田4
    64. 截取前面的部分集合:
    65. 101 春田1
    66. 102 春田2
    67. 截取中间部分的集合:
    68. 101 春田1
    69. 102 春田2
    70.         存入TreeSet类实现的Set集合必须实现Comparable接口,该接口中的CompareTo(Object o)方法比较此对象与指定对象的顺序,如果该对象小于,等于或大于指定对象,则分别返回负整数,0,正整数。

      5.Map集合

              Map集合提供的是key-value的映射关系,Map中不能包含相同的key,可以有相同的value,Map集合包含Map接口以及Map接口的所有实现类。

              Map结合中允许值对象时null,而且允许多个。

      5.1 Map接口

      Map接口中的常用方法
      方法功能描述
      put(K key, V value)向集合中添加指定的key-value的映射关系
      get(Object key)获取key的对象,如果存在指定的key对象,则返回该key对象的值,否则返回null
      containsKey(Object key)如果此集合包含指定key的映射关系,则返回true,否则返回false
      containsValue(Object key)如果此集合包含指定value的映射关系,则返回true,否则返回false
      keySet()返回此集合中所有key对象形成的Set集合
      valueSet()返回该集合中所有值对象形成的Collection集合
      1. package mapclass;
      2. import java.util.*;
      3. public class UpdateStu {
      4. public static void main(String[] args) {
      5. Map map = new HashMap<>(); //创建map实例
      6. map.put("01", "春田1");
      7. map.put("02", "春田2");
      8. Set set = map.keySet(); //构建所有key对象的集合
      9. Iterator it = set.iterator(); //构建集合迭代器
      10. System.out.println("key集合中的元素:");
      11. while (it.hasNext()) {
      12. String stu = it.next();
      13. System.out.println(stu);
      14. }
      15. Collection coll = map.values(); //构建Map集合中所有values值的集合
      16. it = coll.iterator();
      17. System.out.println("value集合中的元素:");
      18. while (it.hasNext()) {
      19. String stu = it.next();
      20. System.out.println(stu);
      21. }
      22. }
      23. }
      24. 输出:
      25. key集合中的元素:
      26. 01
      27. 02
      28. value集合中的元素:
      29. 春田1
      30. 春田2

      5.2 Map接口的实现类

              Map接口的实现类有HashMap和TreeMap。

              5.2.1 HashMap

              HashMap类是基于hash表的Map接口实现,HashMap通过哈希码对其内部的映射关系进行快速查找,并允许使用null键和null值,但是必须保证键的唯一性。

              优点:

              HashMap类实现的Map集合添加和删除映射关系效率更高;

              缺点:   

              此类不保证映射的顺序;

              5.2.2 TreeMap

              TreeMap类不仅实现了Map接口,还实现了java.util.SortedMap接口,因此,集合中的映射关系具有顺序。

              优点:

              集合中的映射关系具有顺序;

              缺点:

              在添加、删除、定位映射关系时,效率较低,且不允许键为null;

      1. package mapclass;
      2. public class Emp {
      3. private String e_id;
      4. private String e_name;
      5. public Emp(String e_id, String e_name) {
      6. this.e_id = e_id;
      7. this.e_name = e_name;
      8. }
      9. public String getE_id() {
      10. return e_id;
      11. }
      12. public void setE_id(String id) {
      13. this.e_id = id;
      14. }
      15. public String getE_name() {
      16. return e_name;
      17. }
      18. public void setE_name(String name) {
      19. this.e_name = name;
      20. }
      21. }
      1. package mapclass;
      2. import java.util.*;
      3. public class MapText {
      4. public static void main(String[] args) {
      5. Map map = new HashMap<>(); //由HashMap实现的Map对象
      6. Emp emp = new Emp("105", "春田1"); //创建Mmp对象
      7. Emp emp1 = new Emp("103", "春田2");
      8. Emp emp2 = new Emp("101", "春田3");
      9. Emp emp3 = new Emp("102", "春田4");
      10. Emp emp4 = new Emp("104", "春田5");
      11. map.put(emp.getE_id(), emp.getE_name()); //将对象添加到集合中
      12. map.put(emp1.getE_id(), emp1.getE_name());
      13. map.put(emp2.getE_id(), emp2.getE_name());
      14. map.put(emp3.getE_id(), emp3.getE_name());
      15. map.put(emp4.getE_id(), emp4.getE_name());
      16. Set key_set = map.keySet(); //获取Map集合中的所有Key对象集合
      17. Iterator it = key_set.iterator(); //获取keyset集合对象迭代器
      18. while (it.hasNext()) {
      19. String key_str = (String) it.next();
      20. String name = (String) map.get(key_str); //通过key获取Map对象value
      21. System.out.println(key_str + " " + name);
      22. }
      23. TreeMap tree_map = new TreeMap<>(); //创建TreeMap集合对象
      24. tree_map.putAll(map); //将集合对象map添加到TreeMap集合对象中
      25. Iterator iter = tree_map.keySet().iterator();
      26. System.out.println("TreeMap类实现的Map集合,键对象升序:");
      27. while (iter.hasNext()) {
      28. String key_treemap_str = (String) iter.next();
      29. String name = tree_map.get(key_treemap_str);
      30. System.out.println(key_treemap_str + " " + name);
      31. }
      32. }
      33. }
      34. 输出:
      35. 101 春田3
      36. 102 春田4
      37. 103 春田2
      38. 104 春田5
      39. 105 春田1
      40. TreeMap类实现的Map集合,键对象升序:
      41. 101 春田3
      42. 102 春田4
      43. 103 春田2
      44. 104 春田5
      45. 105 春田1

    71. 相关阅读:
      计算机毕业设计-基于SSM的学生考勤管理系统
      Docker安装RabbitMQ
      JavaWeb面经
      Selenium —— 网页frame与多窗口处理!
      搞定蓝牙——第五篇(SMP)
      3D可视化智慧园区建模监控系统,数字化解决方案
      Hbase(一)入门
      10 个Python 自动化脚本的摸鱼神器 ,你确定你不学习一下?
      苍穹外卖数据可视化
      SD中的VAE,你不能不懂
    72. 原文地址:https://blog.csdn.net/qq_40132294/article/details/133996857