JavaSE进阶23 -Map集合常用方法、Map集合遍历方式、哈希表数据结构、重写hasCode()和equals()、Hashtable集合、自定义类型实现Comparable接口

最新推荐文章于 2024-06-14 15:02:13 发布

L-FHy

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量124

点赞数 1

分类专栏： JavaSE 文章标签：数据结构 java

本文链接：https://blog.csdn.net/weixin_43636084/article/details/122916882

版权

JavaSE 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

演示HashSet集合、TreeSet集合

package com.bjpowernode.javase.collection.set;

import java.util.HashSet;
import java.util.Set;

/*
HashSet集合：
	无序不可重复
 */
public class HashSetTest01 {
	
	public static void main(String[] args) {
		
		// 演示一下HashSet集合特点
		Set<String> strs = new HashSet<>();
		
		// 添加元素
		strs.add("hello3");
		strs.add("hello4");
		strs.add("hello1");
		strs.add("hello2");
		strs.add("hello3");
		strs.add("hello3");
		strs.add("hello3");
		strs.add("hello3");
		
		// 遍历(foreach)
		/*
		 hello1
		 hello4
		 hello2
		 hello3
		 1、无序：存储时顺序和取出时顺序不同。
		 2、不可重复。
		 3、放到HashSet集合中的元素实际上是放到HashMap集合的key部分了。
		 */
		for(String s : strs) {
			System.out.println(s);
		}

	}

}

package com.bjpowernode.javase.collection.set;

import java.util.Set;
import java.util.TreeSet;

/**
TreeSet集合存储元素的特点：
	1、无序不可重复的，但是存储的元素可以自动按照大小顺序排序；
	称为：可排序集合。
	
	2、这里的无序指的是存进去的顺序和取出来的顺序不同，并且没有下标。
 */
public class TreeSetTest01 {

	public static void main(String[] args) {
		
		//创建集合对象
		Set<String> strs = new TreeSet<>();
		
		//添加元素
		strs.add("A");
		strs.add("B");
		strs.add("Z");
		strs.add("Y");
		strs.add("Z");
		strs.add("K");
		strs.add("M");
		
		//遍历(foreach)
		/*
	 	A
		B
		K
		M
		Y
		Z
		从小到大自动排序
		 */
		for(String s : strs) {
			System.out.println(s);
		}
		
	}

}

Map接口常用方法

package com.bjpowernode.javase.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/*
java.util.Map接口中常用的方法：
	1、Map和Collection没有继承关系。
	2、Map集合以key和value的方式存储数据：键值对
		key和value都是引用数据类型。
		key和value都是存储对象的内存地址。
		key起到主导的地位，value是key的一个附属品。
	3、Map接口中常用方法：
		V put(K key, V value) 向Map集合中添加键值对
		V get(Object key) 通过key获取value
		void clear() 清空Map集合
		boolean containsKey(Object key) 判断Map中是否包含某个key
		boolean containValue(Object value) 判断Map中是否包含某个value
		boolean	isEmpty() 判断Map集合中元素个数是否为0
		Set<K>	keySet() 获取Map集合中所有的key（所有的键是一个Set集合）
		V remove(Object key) 通过key删除键值对
		int	size() 获取Map集合中键值对的个数
		Collection<V> values() 获取Map集合中所有的value，返回一个Collection
		
		Set<Map.Entry<K,V>>	entrySet() 
			将Map集合转换成Set集合
			假设现在有一个Map集合，如下所示：
				map1集合
				key     value
			----------------------
				 1       zhangsan
				 2       lisi
				 3       wangwu
				 4       zhaoliu
				 
			 Set set = map1.entrySet(); 
			 set集合
			 1=zhangsan  【注意:Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是Map.Entry<K,V>】
			 2=lisi      【Map.entry和String一样，都是一种类型的名字，只不过：Map.entry是静态内部类，是Map中的静态内部类】
			 3=wangwu
			 4=zhaoliu    -----> 这个东西是什么？Map.Entry（Map中的静态内部类）  --> 解释看MyClass.java文件
		
 */
public class MapTest01 {

	public static void main(String[] args) {
		
		// 创建Map集合对象,使用泛型
		Map<Integer, String> map = new HashMap<>();
		
		map.put(1, "zhangsan");  //1 在这里进行了自动装箱：new Integer(1)
		map.put(2, "lisi");
		map.put(3, "wangwu");
		map.put(4, "zhaoliu");
		
		// 通过key获取value
		String value = map.get(2);
		System.out.println(value);
		
		// 获取键值对的数量
		System.out.println("键值对的数量：" + map.size());
		
		// 通过key删除key-value
		map.remove(2);
		System.out.println("键值对的数量：" + map.size());
		
		// 判断是否包含某个key
		// contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法。
		System.out.println(map.containsKey(4));// true
		// 判断是否包含某个value
		System.out.println(map.containsValue("wangwu"));// true
		
		// 获取所有的value
		Collection<String> values = map.values();
		for(String s : values) {
			System.out.println(s);
		}
		
		// 清空Map集合
		map.clear();
		System.out.println("键值对的数量：" + map.size());
		
		// 判断是否为空
		System.out.println(map.isEmpty());//true
	}

}

遍历Map集合的两种方式

package com.bjpowernode.javase.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
Map集合的遍历。【非常重要！】
	第二种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。
	这种方式比较适合于大数据量。
 */
public class MapTest02 {

	public static void main(String[] args) {
		
		// 第一种方式：获取所有的key，通过遍历key，来遍历value
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "zhangsan");  
		map.put(2, "lisi");
		map.put(3, "wangwu");
		map.put(4, "zhaoliu");
		// 遍历Map集合
		// 获取所有的key，所有的key是一个Set集合
		Set<Integer> keys = map.keySet();
		// 遍历key，通过key获取value
		// 迭代器可以
//		Iterator<Integer> it = keys.iterator();
//		while(it.hasNext()) {
//			// 提取其中一个key
//			Integer key = it.next();
//			// 通过key获取value
//			String value = map.get(key);
//			System.out.println(key + "=" + value);
//			
//		}
		// foreach也可以
		for(Integer key : keys) {
			String value = map.get(key);
			System.out.println(key + "=" + value);
		}
		
		// 第二种方式：Set<Map.Entry<K,V>>	entrySet() 
		// 以上这个方式是把Map集合直接全部转换成Set集合
		// Set集合元素的类型是：Map.Entry
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		// 遍历Set集合，每一次取出一个Node
		// 迭代器
//		Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
//		while(it2.hasNext()) {
//			Map.Entry<Integer, String> node = it2.next();
//			Integer key = node.getKey();
//			String value = node.getValue();
//			System.out.println(key + "=" + value);
//		}
		// foreach
		for(Map.Entry<Integer, String> node : set) {
			Integer key = node.getKey();
			String value = node.getValue();
			System.out.println(key + "=" + value);			
		}
		
	}

}

第二种方式内存图解：

哈希表数据结构

在这里插入图片描述

同时重写hashCode()和equals()方法

package com.bjpowernode.javase.map;

import java.util.List;
import java.util.HashMap;
import java.util.*;

/*
HashMap集合：
	1、HashMap集合底层是哈希表/散列表的数据结构。
	2、哈希表是一个怎样的数据结构？
		哈希表是一个数组和单向链表的结合体。
		数组：在查询方面效率很高，随机增删方面效率很低。
		单向链表：在随机增删方面效率较高，在查询方面效率很低。
		哈希表将以上的两种数据结构融合在一起，充分发挥它们各自的优点。
	3、HashMap集合底层代码：
	public class HashMap{
	
		// HashMap底层实际上是一个数组。（一维数组）
		Node<K,V>[] table;
		
		// 静态内部类HashMap.Node
		static class Node<K,V> implements Map.Entry<K,V>{
			final int hash;//哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标）
	        final K key; //存储到Map集合中的key
	        V value; //存储到Map集合中的value
	        Node<K,V> next; //下一个结点的内存地址 
	     }
	}
	哈希表/散列表：一维数组，这个数组中有一个元素是一个单向链表。（数组和链表的结合体。）
	4、重要掌握的是：
		map.put(k,v)
		v=map.get(k)
		以上这两个方法的实现原理，是必须掌握的。
	5、HashMap集合的key部分特点：
		无序，不可重复。
		为什么无序？因为不一定挂在哪个单向链表上。
		不可重复是怎么保证的？equals方法来保证HashMap集合的key不可重复。
		如果key重复了，value会覆盖。
		
		放在HashMap集合key部分的元素其实就是放到HashSet集合中了。
		所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。
	6、哈希表HashMap使用不当时无法发挥性能！
		假设将所有hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了
		纯单向链表。这种情况我们称为：散列分布不均匀。
		什么是散列分布均匀？
			假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的，
			是散列分布均匀的。
		假设将所有的hashCode(0方法返回值都设定为不一样的值，可以吗，有什么问题/
			不行，因为这样的话导致底层哈希表就成为一维数组了，没有链表的概念了。
			也是散列分布不均匀的。
		散列分布均匀需要你重写hashCode()方法时有一定的技巧。
	7、重点：放到HashMap集合key部分的元素，以及放在HashSet集合中的元素，需要同时重写hashCode和equals方法。
	8、HashMap集合的默认初始化容量是16，默认加载因子是0.75.
		这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。
		
		重点：记住，HashMap集合初始化容量必须是2的倍数，这也是官方推荐的。
		这是因为达到散列均匀，为了提高HashMap集合的存放效率，所必须的。
 */
public class HashMapTest01 {

	public static void main(String[] args) {
		// 测试HashMap集合key部分的元素特点
		// Integer是key，它的hasCode和equals都重写了。
		Map<Integer, String> map = new HashMap<>();
		map.put(1111, "zhangsan");
		map.put(6666, "lisi");
		map.put(7777, "wangwu");
		map.put(2222, "zhaoliu");
		map.put(2222, "king");//key重复的时候value会覆盖。
		
		System.out.println(map.size());//4
		
		// 遍历Map集合
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		// 验证结果：HashMap集合key部分元素：无序不可重复
		for(Map.Entry<Integer, String> entry : set) {
			System.out.println(entry.getKey() + "=" + entry.getValue());
		}
		
	}

}

package com.bjpowernode.javase.map;

import java.util.*;

/*
1、向Map集合中存，以及从Map集合中取，都是先调用key的hasCode方法，然后再调用equals方法！
equals方法有可能调用，也有可能不调用。
	拿put(k,v)举例，什么时候equals不会调用？
		k.hasCode()方法返回哈希值，
		哈希值经过哈希算法转换成数组下标，
		数组下标位置上如果为null，equals不需要执行。
	拿get(k)举例，什么时候equals不会调用？
		k.hasCode()方法返回哈希值，
		哈希值经过哈希算法转换成数组下标，
		
		数组下标位置上如果为null，equals不需要执行。	
2、注意：如果一个类的equals()方法重写了，那么hasCode()方法必须重写。
并且equals方法返回如果是true，hashCode()方法返回的值必须是一样。	
equals方法返回true表示两个对象相同，在同一个单向链表上比较。
所以hashCode()方法的返回值也应该相同。

3、hasCode()方法和equals()方法不用再研究了，直接使用IDEA工具生成，但是这两个方法需要同时生成。

4、终极结论：
	放在HashMap的key部分，以及放在HashSet集合中的元素，需要同时重写hasCode方法和equals方法。
	
5、对于哈希表数据结构来说：
	如果o1和o2的hash值相同，一定是放到同一个单向链表上。
	当然如果o1和o2的hash值不同，但由于哈希算法执行结束之后转换的数组下标可能相同，此时会发生“哈希碰撞”。
 */
public class HashMapTest02 {

	public static void main(String[] args) {
		
		Student s1 = new Student("zhangsan");
		Student s2 = new Student("zhangsan");
		
		// 重写equals之前是false
		//System.out.println(s1.equals(s2));//false
		
		// 重写equals之后是true
		System.out.println(s1.equals(s2));//true
		
		System.out.println("s1的hasCode:" + s1.hashCode());// 366712642（重写hasCode()之后，-1432604525）
		System.out.println("s2的hasCode:" + s2.hashCode());// 1829164700(重写hasCode()之后，-1432604525）
		
		// s1.equals(s2)结果已经是true了，表示s1和s2是一样的。相同的，那么往HashSet集合放的话，
		// 按说只能放进去1个。(HashSet集合特点：无序不可重复。)
		Set<Student> set = new HashSet<>();
		set.add(s1);
		set.add(s2);
		System.out.println(set.size());// 这个结果按说应该是1，但是结果是2，显然不符合HashSet集合存储特点。
	}

}


class Student{
	private String name;

	public Student() {
		super();
	}

	public Student(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}


	// Override - equals
//	public boolean equals(Object obj) {
//		if (this == obj)
//			return true;
//		if (obj == null || !(obj instanceof Student))
//			return false;
//		Student other = (Student) obj;
//		return this.name.equals(other.name);
//	}
	
}


class Product{
	
	private int no;
	private String name;
	
	public Product() {
		super();
	}
	public Product(int no, String name) {
		super();
		this.no = no;
		this.name = name;
	}
	
	// 重写hasCode + equals
	// 假设业务要求：商品编号相同，并且商品名字相同，表示同一个商品。系统生成时no和name都要选中。
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + no;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Product other = (Product) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (no != other.no)
			return false;
		return true;
	}
	
}

HashMap的key和value可以为null吗？

package com.bjpowernode.javase.map;

import java.util.HashMap;
import java.util.Map;

/*
HashMap集合key部分允许null吗？
	允许
	但是要注意HashMap的key null值只能有一个。（面试题可能问）
 */
public class HashMapTest03 {

	public static void main(String[] args) {
		
		Map map = new HashMap();
		
		// HashMap集合允许key为null
		map.put(null, null);
		System.out.println(map.size());//1
		
		// key重复的话value覆盖
		map.put(null, 100);
		System.out.println(map.size());//1
		
		// 通过key获取value
		System.out.println(map.get(null));//100
		
	}

}

Hashtable（与HashMap的不同）

package com.bjpowernode.javase.map;

import java.util.Hashtable;
import java.util.Map;

/*
Hashtable的key可以为null吗？
	Hashtable的key和value都是不能为null的。
	HashMap的key和value都是可以为null的。
	
Hashtable方法都带有synchronized，线程安全的。
线程安全有其他的方案，这个Hashtable对线程的处理
导致效率较低，使用较少了。

Hashtable和HashMap一样，底层都是哈希表数据结构。
Hashtable的初始化容量是11，默认加载因子是0.75f
Hashtable的扩容是：原容量*2 + 1
 */
public class HashtableTest01 {

	public static void main(String[] args) {
		
		Map map = new Hashtable();
		
		//map.put(111, null);//java.lang.NullPointerException
		//map.put(null, "abc");//java.lang.NullPointerException
	}

}

Properties

package com.bjpowernode.javase.map;

import java.util.Properties;

/*
目前只需要掌握Properties属性类对象的相关方法即可。
Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型
Propertie被称作属性类对象。
Properties是线程安全的。
 */
public class PropertiesTest01 {

	public static void main(String[] args) {
		
		// 创建一个Properties属性类对象
		Properties pro = new Properties();
		/*
		 需要掌握Properties的两个方法：一个存，一个取
		 	Object	setProperty(String key, String value) 
		 	String	getProperty(String key)
		 */
		pro.setProperty("a", "A");
		pro.setProperty("b", "B");
		pro.setProperty("c", "C");
		pro.setProperty("d", "D");
		
		System.out.println(pro.getProperty("a"));//A
		System.out.println(pro.getProperty("b"));//B
		System.out.println(pro.getProperty("c"));//C
		System.out.println(pro.getProperty("d"));//D
		System.out.println(pro.getProperty("e"));//null
		
	}

}

演示TreeSet对String、Integer是可排序的

package com.bjpowernode.javase.map;

import java.util.TreeSet;

/*
1、TreeSet集合底层实际上是一个TreeMap
2、TreeMap集合底层是一个二叉树
3、放到TreeSet集合中的元素，等同于放到TreeMap集合的key部分了。
4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序。
称为：可排序集合。


 */
public class TreeSetTest01 {
	
	public static void main(String[] args) {
		
		TreeSet<String> ts = new TreeSet();
		ts.add("zhangsan");
		ts.add("wangwu");
		ts.add("lisi");
		ts.add("zhaoliu");
		
		// 遍历
		for(String s : ts) {
			// 按照字典顺序，升序
			System.out.println(s);
		}
		
		TreeSet<Integer> ts2 = new TreeSet();
		ts2.add(100);
		ts2.add(600);
		ts2.add(400);
		ts2.add(300);
		
		// 遍历
		for(Integer s : ts2) {
			// 升序
			System.out.println(s);
		}
	}
}


/*
数据库中有很多数据：
	userid    name   birth
	-------------------------
	1         zs     1980-11-11
	2         ls     1980-10-11
	3         ww     1981-11-11
	4         zl     1979-11-11

	编写程序从数据库当中取出数据，在页面展示用户信息的时候按照生日升序或者降序。
	这个时候可以使用TreeSet集合，因为TreeSet集合放进去，拿出来就是有顺序的。

*/

TreeSet无法对自定义类型排序

package com.bjpowernode.javase.map;

import java.util.TreeSet;

/*
对自定义的类型，TreeSet可以排序吗？
	以下程序中对于Person类型，无法排序，因为没有指定Person对象之间的比较规则。
	谁大谁小没有说明。
	
	以下程序运行的时候出现了这个异常：
		 java.lang.ClassCastException: 
		 	com.bjpowernode.javase.map.Person 
		 	cannot be cast to java.lang.Comparable
	出现这个异常的原因是：
		Person类没有实现java.lang.Comparable接口。
		 
 */
public class TreeSetTest02 {

	public static void main(String[] args) {
		Person p1 = new Person(32);
		Person p2 = new Person(20);
		Person p3 = new Person(30);
		Person p4 = new Person(25);
		
		System.out.println(p1);
		
		// 创建TreeSet集合对象
		TreeSet<Person> ts = new TreeSet<>();
		ts.add(p1);
		ts.add(p2);
		ts.add(p3);
		ts.add(p4);
		
		//遍历
		for(Person p : ts) {
			System.out.println(p);
		}
		
	}

}

class Person{
	int age;

	public Person(int age) {
		super();
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [age=" + age + "]";
	}	
}

自定义类型实现Comparable接口

package com.bjpowernode.javase.map;

import java.util.TreeSet;
import java.util.HashSet;

public class TreeSetTest03 {

	public static void main(String[] args) {
		Customer c1 = new Customer(32);
		Customer c2 = new Customer(20);
		Customer c3 = new Customer(30);
		Customer c4 = new Customer(25);
		
		// 创建TreeSet集合对象
		TreeSet<Customer> ts = new TreeSet<>();
		ts.add(c1);
		ts.add(c2);
		ts.add(c3);
		ts.add(c4);
		
		//遍历
		for(Customer c : ts) {
			System.out.println(c);
		}

	}

}

// 放在TreeSet集合中的元素需要实现java.lang.Comparable
// 并且实现compareTo方法。equals可以不写。

class Customer implements Comparable<Customer>{
	private int age;
	
	public Customer(int age) {
		this.age = age;
	}
	
	// 需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较。
	// k.comparable(t.key)。
	// 拿着参数k和集合中的每一个k进行比较，返回值可能是>0 =0 <0。
	// 比较规则最终还是由程序员指定的，例如按照年龄升序，或者按照年龄降序。
	@Override
	public int compareTo(Customer c) {// c1.compareTo(c2)
		// this是c1
		// c是c2
		// c1和c2比较的时候，就是this和c比较
//		int age1 = this.age;
//		int age2 = c.age;
//		if(age1 == age2) {
//			return 0;
//		}else if(age1 > age2) {
//			return 1;
//		}else{
//			return -1;
//		}
		
		// 优化：升序
		//return this.age - c.age;
		// 降序
		return c.age - this.age;
	}

	@Override
	public String toString() {
		return "Customer [age=" + age + "]";
	}
	
	
}

package com.bjpowernode.javase.map;

import java.util.TreeSet;

/*
	先按照年龄升序，如果年龄一样的再按照姓名升序。
 */
public class TreeSetTest04 {

	public static void main(String[] args) {
		
		TreeSet<Vip> ts = new TreeSet<>();
		ts.add(new Vip("zhangsi", 20));
		ts.add(new Vip("zhangsan", 20));
		ts.add(new Vip("king", 18));
		ts.add(new Vip("soft", 17));
		for(Vip vip : ts) {
			System.out.println(vip);
		}
	}

}
class Vip implements Comparable<Vip>{
	String name;
	int age;
	
	public Vip(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Vip [name=" + name + ", age=" + age + "]";
	}
	
	/*
	 CompareTo方法的返回值很重要：
	 	返回0表示相同，value会覆盖。
	 	返回>0，会继续在右子树上找。
	 	返回<0，会继续在左子树上找。
	 */
	@Override
	public int compareTo(Vip v) {
		if(this.age == v.age) {
			// 年龄相同时按照名字排序
			// 名字是String类型，可以直接比，调用compareTo进行比对
			return this.name.compareTo(v.name);
		}else {
			return this.age - v.age;
		}
	}
}

自平衡二叉树数据结构

TreeSet/TreeMap是自平衡二叉树，遵循左小右大原则存放。（注意：存放是要依靠左小右大原则，所以这个存放的时候要进行比较。）
遍历二叉树的时候有三种方法：
- 前序遍历：根左右
- 中序遍历：左根右
- 后序遍历：左右根
- 注意：前中后说的是“根”的位置
  - 根在前面是前序，根在中间是中序，根在后面是后序。
TreeSet集合/TreeMap集合采用的是：中序遍历方式：左根右。
- Iterator迭代器采用的是中序遍历方式：左根右。

实现比较器接口

package com.bjpowernode.javase.map;

import java.util.Comparator;
import java.util.TreeSet;

/*
TreeSet集合中元素可排序的第二种方式：使用比较器的方式。
最终的结论：
	放到TreeSet或者TreeMap集合key部分的元素要想做到排序，包括两种方式：
		第一种：放在集合中的元素实现java.lang.Comparable接口。
		第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。
Comparable和Comparator怎么选择呢？
	当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
	如果比较规则有多个，并且需要多个比较规则之间进行切换的时候，建议使用Comparator接口。
 */
public class TreeSetTest05 {

	public static void main(String[] args) {
		
		// 创建TreeSet集合的时候，需要使用这个比较器。
		// TreeSet<WuGui> wuGuis = new TreeSet<>();// 这样不行，没有通过构造方法传递一个比较器进去。
		
		// 给构造方法传递一个比较器
		//TreeSet<WuGui> wuGuis = new TreeSet<>(new WuGuiComparator());
		
		// 大家可以使用匿名内部类的方式（这个类没有名字。直接new接口。）
		TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() {

			@Override
			public int compare(WuGui o1, WuGui o2) {
				
				return o1.age - o2.age;
			}
			
		});
		
		
		wuGuis.add(new WuGui(1000));
		wuGuis.add(new WuGui(800));
		wuGuis.add(new WuGui(810));
		
		for(WuGui wuGui : wuGuis) {
			System.out.println(wuGui);
		}
	}

}

// 乌龟
class WuGui{
	
	int age;
	
	public WuGui(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "小乌龟[age" + "=" + age + "]";
	}
	
}

// 单独在这里编写一个比较器
// 比较器实现java.util.Comparator接口。（Comparable是java.lang包下的。Comparator是java.util包下的。）
//class WuGuiComparator implements Comparator<WuGui>{
//
//	@Override
//	public int compare(WuGui o1, WuGui o2) {
//		// 指定比较规则
//		// 按照年龄排序
//		return o1.age - o2.age;
//	}
//	
//}

L-FHy

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE进阶23 -Map集合常用方法、Map集合遍历方式、哈希表数据结构、重写hasCode()和equals()、Hashtable集合、自定义类型实现Comparable接口

演示HashSet集合、TreeSet集合package com.bjpowernode.javase.collection.set;import java.util.HashSet;import java.util.Set;/*HashSet集合：无序不可重复 */public class HashSetTest01 { public static void main(String[] args) { // 演示一下HashSet集合特点 Set<Strin
复制链接

扫一扫