java、Set集合和Map集合

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

\----------- [android培训][android]、[java培训][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实例：

import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class ComparableDemo {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		创建一个Set集合的引用指向HashSet的对象
    		Set se = new HashSet();
    		//实例化1
    		Person p1 = new Person("ZhangSan", 23, "male");
    		//实例化2
    		Person p2 = new Person("LiSi", 32, "female");
    		//实例化3
    		Person p3 = new Person("WangWu", 28, "male");
    		//实例化4
    		Person p4 = new Person("ZhaoLiu", 23, "female");
    		//实例化5
    		Person p5 = new Person("ZhangSan", 23, "male");
    		//将实例化对象添加进集合中
    		se.add(p1);
    		se.add(p2);
    		se.add(p3);
    		se.add(p4);
    		se.add(p5);
    		//迭代集合中的元素
    		Iterator<Person> it = se.iterator();
    		//判断集合中是否存在元素
    		while (it.hasNext()) {
    			//迭代下一个元素
    			Person per = it.next();
    			//打印元素
    			System.out.println(per);
    		}
    	}
    }
    package SetDemo;
    
    //创建一个实体类
    public class Person {
    	private String name;
    	private int age;
    	private String sex;
    
    	public Person(String name, int age, String sex) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    	}
    
    	public Person() {
    		super();
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getSex() {
    		return sex;
    	}
    
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    
    	// 重写Object的tostring方法
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    	}
    
    	// Object的hashCode方法
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + age;
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		result = prime * result + ((sex == null) ? 0 : sex.hashCode());
    		return result;
    	}
    
    	// 重写Objet的equasl方法
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) {
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		if (sex == null) {
    			if (other.sex != null)
    				return false;
    		} else if (!sex.equals(other.sex))
    			return false;
    		return true;
    	}
    
    }
    结果为:
    Person [name=WangWu, age=28, sex=male]
    Person [name=LiSi, age=32, sex=female]
    Person [name=ZhaoLiu, age=23, sex=female]
    Person [name=ZhangSan, age=23, sex=male]

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

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

public class ComparableDemo {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// 创建一个Set集合的引用指向LinkedHashSet的对象
    		Set se = new LinkedHashSet();
    		// 实例化1
    		Person p1 = new Person("ZhangSan", 23, "male");
    		// 实例化2
    		Person p2 = new Person("LiSi", 32, "female");
    		// 实例化3
    		Person p3 = new Person("WangWu", 28, "male");
    		// 实例化4
    		Person p4 = new Person("ZhaoLiu", 23, "female");
    		// 实例化5
    		Person p5 = new Person("ZhangSan", 23, "male");
    		// 将实例化对象添加进集合中
    		se.add(p1);
    		se.add(p2);
    		se.add(p3);
    		se.add(p4);
    		se.add(p5);
    		// 迭代集合中的元素
    		Iterator<Person> it = se.iterator();
    		// 判断集合中是否存在元素
    		while (it.hasNext()) {
    			// 迭代下一个元素
    			Person per = it.next();
    			// 打印元素
    			System.out.println(per);
    		}
    	}
    }
    结果为:
    Person [name=ZhangSan, age=23, sex=male]
    Person [name=LiSi, age=32, sex=female]
    Person [name=WangWu, age=28, sex=male]
    Person [name=ZhaoLiu, age=23, sex=female]

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

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

TreeSet实例：

import java.util.Comparator;
    import java.util.Iterator;
    import java.util.Set;
    import java.util.TreeSet;
    
    public class ComparableDemo {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		Comparator<Person> my = new Mycompare();
    		// 创建一个Set集合的引用
    		Set<Person> se = new TreeSet<Person>(my);
    		// 实例化1
    		Person p1 = new Person("ZhangSan", 23, "male");
    		// 实例化2
    		Person p2 = new Person("LiSi", 32, "female");
    		// 实例化3
    		Person p3 = new Person("WangWu", 28, "male");
    		// 实例化4
    		Person p4 = new Person("ZhaoLiu", 23, "female");
    		// 实例化5
    		Person p5 = new Person("ZhangSan", 23, "male");
    		// 将实例化对象添加进集合中
    		se.add(p1);
    		se.add(p2);
    		se.add(p3);
    		se.add(p4);
    		se.add(p5);
    		// 迭代集合中的元素
    		Iterator<Person> it = se.iterator();
    		// 判断集合中是否存在元素
    		while (it.hasNext()) {
    			// 迭代下一个元素
    			Person per = it.next();
    			// 打印元素
    			System.out.println(per);
    		}
    	}
    }
    
    class Mycompare implements Comparator<Person> {
    	@Override
    	public int compare(Person o1, Person o2) {
    		// 从年龄开始比较
    		int age = o1.getAge() - o2.getAge();
    		if (age != 0) {
    			return age;
    		}
    		// 如果年龄相等，从性别比较
    		String o1sex = o1.getSex();
    		String o2sex = o2.getSex();
    		// 如果o1性别为男
    		if (o1sex.equals("male")) {
    			// 和如果o2性别为女，返回1，男大
    			if (o2sex.equals("female")) {
    				return -1;
    			}
    		} else {
    			// 否则o2的性别为男时，o2比o1大
    			if (o2sex.equals("male")) {
    				return 1;
    			}
    
    		}
    
    		return o1.getName().compareTo(o2.getName());
    	}
    }
    结果:
    Person [name=ZhangSan, age=23, sex=male]
    Person [name=ZhaoLiu, age=23, sex=female]
    Person [name=WangWu, age=28, sex=male]
    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实例：

import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    
    public class MapDemo {
    
    	/*
    	 * 统计候选人票数是一个道理 所有投票人把自己心中的人选提交上来。
    	 * 
    	 * 张三把所有选票上的名字读一次，即循环遍历所有选票，并获取名字。 李四听到张三念一个，就在纸上找这个名字是否已经存在，如果存在，那么把票数+1
    	 * 如果不存在，那么把这个名字写上，在票数上写1。
    	 */
    	public static void main(String[] args) {
    		// 创建后候选人
    		String s1 = "ZhanSan LiSi LiSi ZhanSan WangWu LiSi LiSi ZhanSan 张国荣";
    		// 将返回的map创建成一个新的map集合
    		Map<String, Integer> mp = fun(s1);
    		// 将map集合转换为Set集合
    		Set<Map.Entry<String, Integer>> entryset = mp.entrySet();
    		// 遍历map集合
    		for (Entry<String, Integer> s2 : entryset) {
    			// 获取键
    			String key = s2.getKey();
    			// 获取值
    			Integer vlaue = s2.getValue();
    			// 将键和值打印
    			System.out.println(key + "::" + vlaue);
    		}
    	}
    
    	public static Map fun(String s1) {
    		// 创建一个Map集合Map<String(候选人名字), Integer(票数)>
    		Map<String, Integer> mp = new HashMap<String, Integer>();
    		// 把参数字符串分隔成字符串数组；String[] names=s.split(" ");
    		String[] names = s1.split(" ");
    		// 循环遍历这个names
    		for (int i = 0; i < names.length; i++) {
    			int tokce = 1;
    			// 判断mp中是否包含这个名字
    			if (mp.containsKey(names[i])) {
    				// 如果存在，获取票数(获取值)，给值+1
    				tokce = mp.get(names[i]) + 1;
    			}
    			mp.put(names[i], tokce);
    
    		}
    		return mp;
    
    	}
    }
    结果为:
    WangWu::1
    张国荣::1
    ZhanSan::3
    LiSi::4

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

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

import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class MapDemo2 {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// 创建一个大map中泛型左边类型的小map
    		Map<String, String> gmsz = new LinkedHashMap<String, String>();
    		// 创建大map中泛型的右边类型的小map
    		Map<String, String> hjfw = new LinkedHashMap<String, String>();
    		// 创建大map
    		Map<String, Map<String, String>> mj = new LinkedHashMap<String, Map<String, String>>();
    		// 向左边类型map添加元素
    		gmsz.put("光明左使", "杨逍");
    		gmsz.put("光明右使", "范遥");
    		// 往右边类型map添加元素
    		hjfw.put("紫衫龙王", "黛绮丝");
    		hjfw.put("白眉鹰王", "殷天正");
    		hjfw.put("金毛狮王", "谢逊");
    		hjfw.put("青翼蝠王", "韦一笑");
    		mj.put("光明使者", gmsz);
    		mj.put("护教法王", hjfw);
    		// 将大的map转换成set集合
    		Set<String> keyset = mj.keySet();
    
    		/*
    		 * Iterator<String> it = keyset.iterator();
    		 * 
    		 * while (it.hasNext()) { String s1 = it.next(); Map<String, String> key
    		 * = mj.get(s1); System.out.println(key); }
    		 */
    		// 使用高级for迭代set集合
    		for (String st : keyset) {
    			// 通过map的get方法获取键，返回右边小map的集合类型
    			Map<String, String> st2 = mj.get(st);
    			//将其打印
    			System.out.println(st2);
    		}
    
    	}
    
    }
    结果:
    {光明左使=杨逍, 光明右使=范遥}
    {紫衫龙王=黛绮丝, 白眉鹰王=殷天正, 金毛狮王=谢逊, 青翼蝠王=韦一笑}

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

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

[android]: http://edu.csdn.net/heima/
[java]: http://edu.csdn.net/heima