java、Set集合和Map集合

Bertha 。 2022-03-31 18:58 540阅读 0赞

-————— android培训、java培训、java学习型技术博客、期待与您交流！ ——————

一、Set集合
1、什么是Set集合？
Set是Collection的一种，即Set是Collection的子接口。
2、Set有什么特性：
1.它不要求顺序，无重复元素
2.没索引
3、Set有五种实现类:
1.HashSet 2.TreeSet 3.LinkedHashSet
4、HashSet TreeSet LinkedHashSet它们分别有什么特征？
HashSet特征：
1.它的底层是用hash表数据结构，线程不同步，无序，高效。
2.HashSet集合保证了元素的唯一性:通过元素的HasCode方法和equals方法完成的。
3.当元素的HashCode值相同时，才继续判断元素的equals值是否是否为true。如果为true，那么视为相同元素，不存储。如果为false，那么存储。
4.如果HashCode不同，那么不比较equas方法，直接存储，从而直接提高对象比较的速度。
HashCode实例：

  1. import java.util.HashSet;
  2. import java.util.Iterator;
  3. import java.util.Set;
  5. public class ComparableDemo {
  7.     /**
  8.      * @param args
  9.      */
  10.     public static void main(String[] args) {
  11.         创建一个Set集合的引用指向HashSet的对象
  12.         Set se = new HashSet();
  13.         //实例化1
  14.         Person p1 = new Person("ZhangSan", 23, "male");
  15.         //实例化2
  16.         Person p2 = new Person("LiSi", 32, "female");
  17.         //实例化3
  18.         Person p3 = new Person("WangWu", 28, "male");
  19.         //实例化4
  20.         Person p4 = new Person("ZhaoLiu", 23, "female");
  21.         //实例化5
  22.         Person p5 = new Person("ZhangSan", 23, "male");
  23.         //将实例化对象添加进集合中
  24.         se.add(p1);
  25.         se.add(p2);
  26.         se.add(p3);
  27.         se.add(p4);
  28.         se.add(p5);
  29.         //迭代集合中的元素
  30.         Iterator<Person> it = se.iterator();
  31.         //判断集合中是否存在元素
  32.         while (it.hasNext()) {
  33.             //迭代下一个元素
  34.             Person per = it.next();
  35.             //打印元素
  36.             System.out.println(per);
  37.         }
  38.     }
  39. }
  40. package SetDemo;
  42. //创建一个实体类
  43. public class Person {
  44.     private String name;
  45.     private int age;
  46.     private String sex;
  48.     public Person(String name, int age, String sex) {
  49.         super();
  50.         this.name = name;
  51.         this.age = age;
  52.         this.sex = sex;
  53.     }
  55.     public Person() {
  56.         super();
  57.     }
  59.     public String getName() {
  60.         return name;
  61.     }
  63.     public void setName(String name) {
  64.         this.name = name;
  65.     }
  67.     public int getAge() {
  68.         return age;
  69.     }
  71.     public void setAge(int age) {
  72.         this.age = age;
  73.     }
  75.     public String getSex() {
  76.         return sex;
  77.     }
  79.     public void setSex(String sex) {
  80.         this.sex = sex;
  81.     }
  83.     // 重写Object的tostring方法
  84.     @Override
  85.     public String toString() {
  86.         return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
  87.     }
  89.     // Object的hashCode方法
  90.     @Override
  91.     public int hashCode() {
  92.         final int prime = 31;
  93.         int result = 1;
  94.         result = prime * result + age;
  95.         result = prime * result + ((name == null) ? 0 : name.hashCode());
  96.         result = prime * result + ((sex == null) ? 0 : sex.hashCode());
  97.         return result;
  98.     }
  100.     // 重写Objet的equasl方法
  101.     @Override
  102.     public boolean equals(Object obj) {
  103.         if (this == obj)
  104.             return true;
  105.         if (obj == null)
  106.             return false;
  107.         if (getClass() != obj.getClass())
  108.             return false;
  109.         Person other = (Person) obj;
  110.         if (age != other.age)
  111.             return false;
  112.         if (name == null) {
  113.             if (other.name != null)
  114.                 return false;
  115.         } else if (!name.equals(other.name))
  116.             return false;
  117.         if (sex == null) {
  118.             if (other.sex != null)
  119.                 return false;
  120.         } else if (!sex.equals(other.sex))
  121.             return false;
  122.         return true;
  123.     }
  125. }
  126. 结果为:
  127. Person [name=WangWu, age=28, sex=male]
  128. Person [name=LiSi, age=32, sex=female]
  129. Person [name=ZhaoLiu, age=23, sex=female]
  130. Person [name=ZhangSan, age=23, sex=male]

总结:hasHSet，底层是哈希表的数据结构，使用了HasCode和equals方法保证了元素的唯一性。

LinkedHashSet特征：
1.LinkedHashSet是HashSet的子类，底层也是使用了哈希表的数据结构。
2.它的数据是有序的，只不过它迭代的顺序是添加的顺序，因为它底层用链表来记录添加元素的顺序。迭代时，再使用添加时顺序迭代。
LinkedHashSet实例：

  1. public class ComparableDemo {
  3.     /**
  4.      * @param args
  5.      */
  6.     public static void main(String[] args) {
  7.         // 创建一个Set集合的引用指向LinkedHashSet的对象
  8.         Set se = new LinkedHashSet();
  9.         // 实例化1
  10.         Person p1 = new Person("ZhangSan", 23, "male");
  11.         // 实例化2
  12.         Person p2 = new Person("LiSi", 32, "female");
  13.         // 实例化3
  14.         Person p3 = new Person("WangWu", 28, "male");
  15.         // 实例化4
  16.         Person p4 = new Person("ZhaoLiu", 23, "female");
  17.         // 实例化5
  18.         Person p5 = new Person("ZhangSan", 23, "male");
  19.         // 将实例化对象添加进集合中
  20.         se.add(p1);
  21.         se.add(p2);
  22.         se.add(p3);
  23.         se.add(p4);
  24.         se.add(p5);
  25.         // 迭代集合中的元素
  26.         Iterator<Person> it = se.iterator();
  27.         // 判断集合中是否存在元素
  28.         while (it.hasNext()) {
  29.             // 迭代下一个元素
  30.             Person per = it.next();
  31.             // 打印元素
  32.             System.out.println(per);
  33.         }
  34.     }
  35. }
  36. 结果为:
  37. Person [name=ZhangSan, age=23, sex=male]
  38. Person [name=LiSi, age=32, sex=female]
  39. Person [name=WangWu, age=28, sex=male]
  40. Person [name=ZhaoLiu, age=23, sex=female]

总结：LinkedHashSet集合是有序的，它结果的顺序是你添加元素的顺序，因为它底层用链表记录了添加元素的顺序。

TreeSet特征：
1.它的元素是有序的，无重复元素。它的线程是不安全的
2.它底层使用了二叉树的数据结构。
3.二叉树的原理：
1.它添加的第一个元素时根节点。
2.再添加第二个元素时，与根节点进行比较，如果比根节点大，那么就放在根节点的右侧的子节点位置，如果比根节点小，那么就放在根节点的左侧子节点的位置，如果相等，那么就添加失败。
3.添加第三个元素时，先与根节点进行比较，如果比根小，再与根的左侧比较，比它小放在它的左侧子节点，比它大放在它的右侧子节点。相等的话，添加失败。
如果比根答，再与根的右侧比较，比它大放在它的右侧子节点，比它小放在它的左侧子节点。相等的话，添加失败。
4.遍历二叉树的原则：先遍历左，然后当前，最后是右。
5.TreeSet有序的原则：(1)TreeSet有比较器，那么使用比较器来比较元素 (2)TreeSet没有比较器，实现Comparable接口，让它具有自然顺序。

TreeSet实例： 

  1. import java.util.Comparator;
  2. import java.util.Iterator;
  3. import java.util.Set;
  4. import java.util.TreeSet;
  6. public class ComparableDemo {
  8.     /**
  9.      * @param args
  10.      */
  11.     public static void main(String[] args) {
  12.         Comparator<Person> my = new Mycompare();
  13.         // 创建一个Set集合的引用
  14.         Set<Person> se = new TreeSet<Person>(my);
  15.         // 实例化1
  16.         Person p1 = new Person("ZhangSan", 23, "male");
  17.         // 实例化2
  18.         Person p2 = new Person("LiSi", 32, "female");
  19.         // 实例化3
  20.         Person p3 = new Person("WangWu", 28, "male");
  21.         // 实例化4
  22.         Person p4 = new Person("ZhaoLiu", 23, "female");
  23.         // 实例化5
  24.         Person p5 = new Person("ZhangSan", 23, "male");
  25.         // 将实例化对象添加进集合中
  26.         se.add(p1);
  27.         se.add(p2);
  28.         se.add(p3);
  29.         se.add(p4);
  30.         se.add(p5);
  31.         // 迭代集合中的元素
  32.         Iterator<Person> it = se.iterator();
  33.         // 判断集合中是否存在元素
  34.         while (it.hasNext()) {
  35.             // 迭代下一个元素
  36.             Person per = it.next();
  37.             // 打印元素
  38.             System.out.println(per);
  39.         }
  40.     }
  41. }
  43. class Mycompare implements Comparator<Person> {
  44.     @Override
  45.     public int compare(Person o1, Person o2) {
  46.         // 从年龄开始比较
  47.         int age = o1.getAge() - o2.getAge();
  48.         if (age != 0) {
  49.             return age;
  50.         }
  51.         // 如果年龄相等，从性别比较
  52.         String o1sex = o1.getSex();
  53.         String o2sex = o2.getSex();
  54.         // 如果o1性别为男
  55.         if (o1sex.equals("male")) {
  56.             // 和如果o2性别为女，返回1，男大
  57.             if (o2sex.equals("female")) {
  58.                 return -1;
  59.             }
  60.         } else {
  61.             // 否则o2的性别为男时，o2比o1大
  62.             if (o2sex.equals("male")) {
  63.                 return 1;
  64.             }
  66.         }
  68.         return o1.getName().compareTo(o2.getName());
  69.     }
  70. }
  71. 结果:
  72. Person [name=ZhangSan, age=23, sex=male]
  73. Person [name=ZhaoLiu, age=23, sex=female]
  74. Person [name=WangWu, age=28, sex=male]
  75. Person [name=LiSi, age=32, sex=female]

总结:在进行比较时，如果判断元素不唯一，比如，同姓名，同年龄，才视为同一个人。在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。

二、Map集合
1、什么是Map集合？
Map是双列集合，它是以Entry属性的键值对(Key.Value)的对象存在的。
2、Map有什么特性？
1.它是双列集合，Key键不能重复，Value值可以重复。
3、Map有五种实现类。
他们分别是:HashMap、TreeMap、HashTable、properties、LinkedHashMap、
HashMap特征：
1.它的底层是用哈希表的数据结构
2.因为它的底层使用的是哈希表，所以它必须重写HashCode和equals方法。
3.线程不同步的。可以存储null键，null值
HashMap实例：

  1. import java.util.HashMap;
  2. import java.util.Map;
  3. import java.util.Map.Entry;
  4. import java.util.Set;
  6. public class MapDemo {
  8.     /*
  9.      * 统计候选人票数是一个道理 所有投票人把自己心中的人选提交上来。
  10.      * 
  11.      * 张三把所有选票上的名字读一次，即循环遍历所有选票，并获取名字。 李四听到张三念一个，就在纸上找这个名字是否已经存在，如果存在，那么把票数+1
  12.      * 如果不存在，那么把这个名字写上，在票数上写1。
  13.      */
  14.     public static void main(String[] args) {
  15.         // 创建后候选人
  16.         String s1 = "ZhanSan LiSi LiSi ZhanSan WangWu LiSi LiSi ZhanSan 张国荣";
  17.         // 将返回的map创建成一个新的map集合
  18.         Map<String, Integer> mp = fun(s1);
  19.         // 将map集合转换为Set集合
  20.         Set<Map.Entry<String, Integer>> entryset = mp.entrySet();
  21.         // 遍历map集合
  22.         for (Entry<String, Integer> s2 : entryset) {
  23.             // 获取键
  24.             String key = s2.getKey();
  25.             // 获取值
  26.             Integer vlaue = s2.getValue();
  27.             // 将键和值打印
  28.             System.out.println(key + "::" + vlaue);
  29.         }
  30.     }
  32.     public static Map fun(String s1) {
  33.         // 创建一个Map集合Map<String(候选人名字), Integer(票数)>
  34.         Map<String, Integer> mp = new HashMap<String, Integer>();
  35.         // 把参数字符串分隔成字符串数组；String[] names=s.split(" ");
  36.         String[] names = s1.split(" ");
  37.         // 循环遍历这个names
  38.         for (int i = 0; i < names.length; i++) {
  39.             int tokce = 1;
  40.             // 判断mp中是否包含这个名字
  41.             if (mp.containsKey(names[i])) {
  42.                 // 如果存在，获取票数(获取值)，给值+1
  43.                 tokce = mp.get(names[i]) + 1;
  44.             }
  45.             mp.put(names[i], tokce);
  47.         }
  48.         return mp;
  50.     }
  51. }
  52. 结果为:
  53. WangWu::1
  54. 张国荣::1
  55. ZhanSan::3
  56. LiSi::4

总结:Map自身没有遍历的方法，必须将其转换为Set集合然后遍历，转换的方法有两种：keySet();entrySet()

TreeMap特征：
1.它的底层是用二叉树结构
2.有序！使用键类型的自然顺序，或者TreeMap的比较器排序；
多重Map集合实例:

  1. import java.util.LinkedHashMap;
  2. import java.util.Map;
  3. import java.util.Set;
  5. public class MapDemo2 {
  7.     /**
  8.      * @param args
  9.      */
  10.     public static void main(String[] args) {
  11.         // 创建一个大map中泛型左边类型的小map
  12.         Map<String, String> gmsz = new LinkedHashMap<String, String>();
  13.         // 创建大map中泛型的右边类型的小map
  14.         Map<String, String> hjfw = new LinkedHashMap<String, String>();
  15.         // 创建大map
  16.         Map<String, Map<String, String>> mj = new LinkedHashMap<String, Map<String, String>>();
  17.         // 向左边类型map添加元素
  18.         gmsz.put("光明左使", "杨逍");
  19.         gmsz.put("光明右使", "范遥");
  20.         // 往右边类型map添加元素
  21.         hjfw.put("紫衫龙王", "黛绮丝");
  22.         hjfw.put("白眉鹰王", "殷天正");
  23.         hjfw.put("金毛狮王", "谢逊");
  24.         hjfw.put("青翼蝠王", "韦一笑");
  25.         mj.put("光明使者", gmsz);
  26.         mj.put("护教法王", hjfw);
  27.         // 将大的map转换成set集合
  28.         Set<String> keyset = mj.keySet();
  30.         /*
  31.          * Iterator<String> it = keyset.iterator();
  32.          * 
  33.          * while (it.hasNext()) { String s1 = it.next(); Map<String, String> key
  34.          * = mj.get(s1); System.out.println(key); }
  35.          */
  36.         // 使用高级for迭代set集合
  37.         for (String st : keyset) {
  38.             // 通过map的get方法获取键，返回右边小map的集合类型
  39.             Map<String, String> st2 = mj.get(st);
  40.             //将其打印
  41.             System.out.println(st2);
  42.         }
  44.     }
  46. }
  47. 结果:
  48. {光明左使=杨逍, 光明右使=范遥}
  49. {紫衫龙王=黛绮丝, 白眉鹰王=殷天正, 金毛狮王=谢逊, 青翼蝠王=韦一笑}

总结:Map集合主要是以键值对的形式存在，Entry就是键值对对象，Map结果都是以{}表示的，和list、set的不同。遍历Set的两种方法。KeySet和entrySet。KeySet中遍历的返回的是Value值的类型，entrySet中遍历返回的是Entry对象的返回值类型

-————— android培训、java培训、java学习型技术博客、期待与您交流！ ——————

发表评论

表情：
评论列表 （有 0 条评论，540人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Map集合

    【前言】 1.Map 用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里key,另外一组值用于保存Map里的value，key和value都可以

    ゞ 浴缸里的玫瑰ゞ 浴缸里的玫瑰/ 0 赞/ 415 阅读