TreeSet和TreeMap

TreeSet

???TreeSet底层就是一个TreeMap（是一个简化版的TreeMap），当我们使用 TreeSet 的构造方法创建 TreeSet 对象，同时会创建一个TreeMap 对象，当你调用 add 方法向 TreeSet 添加元素，会在 add() 方法中调用 TreeMap 的 put(k,v) 方法。

????添加的元素不允许为null。

TreeSet的输出去重、默认升序排序。

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

/**
 * 例：放入Integer类型的元素到TreeSet中
 */
public class TestTreeSet {
	public static void main(String[] args) {
		Set<Integer> set = new TreeSet<>();
		set.add(10);
		set.add(1);
		set.add(100);
		// 打印的结果是已经排序的[1, 10, 100]，因为TreeSet本质就是一个TreeMap，1、10、100都作为TreeMap的Key，value是一个哑巴值
		// TreeMap集合中所有的值都是一个对象(哑巴)
		System.out.println(set);
	}
}

????注意：存储到TreeSet集合中的元素必须实现Comparable或者Comparator接口,否则抛出异常ClassCastException。

public class Student implements Comparable<Student> {

	private int id;
	private String stuName;
	private int age;

    public Student() {
		super();
	}
	public Student(int id, String stuName, int age) {
		super();
		this.id = id;
		this.stuName = stuName;
		this.age = age;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((stuName == null) ? 0 : stuName.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 (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (stuName == null) {
			if (other.stuName != null)
				return false;
		} else if (!stuName.equals(other.stuName))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", stuName=" + stuName + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Student o) {
		return this.getAge()-o.getAge();
	}
}

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

public class TestTreeSet2 {
	public static void main(String[] args) {
		Set<Student> set = new TreeSet<>();
		set.add(new Student(101,"Jerry", 16));
		set.add(new Student(103,"Jack", 14));
		set.add(new Student(105,"Jackson", 13));
		// Exception in thread "main" java.lang.ClassCastException: com.whsxt.day8.treeset.Student cannot be cast to java.lang.Comparable
		// 存储到TreeSet集合中的元素必须实现Comparable或者Comparator接口
		System.out.println(set);
	}
}

TreeMap

????概念：以红黑树的接口存储键值对。TreeMap是红黑二叉树的典型实现。

????特征：放入TreeMap集合中的元素都是按照指定规则进行排序的。

????key（键）不允许为null。

????TreeMap的输出默认以key（键）升序排序、去重。

?场景1：将key-value对放入TreeMap集合中

import java.util.Map;
import java.util.TreeMap;

/**
 * 输出结果：
 * 		1	abc
 * 		2	bgw
 * 		4	bbb
 * 		5	cdd
 * 		6	cds
 */
public class TestTreeMap {
	public static void main(String[] args) {
		Map<Integer, String> map = new TreeMap<>();
		map.put(1, "abc");
		map.put(4, "aaa");
		map.put(6, "cds");
		map.put(2, "bgw");
		map.put(5, "cdd");
		map.put(4, "bbb");
		for (Map.Entry<Integer, String> entry : map.entrySet()) {
			Integer key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + "\t" + value);
		}
	}
}

????注意：工作中TreeMap使用很少，因为数据结构复杂（以树的结构存储数据），存储TreeMap集合的元素是有序的（经过排序的），既然排序就会涉及比较，将新元素放入集合之前会先比较然后放入，所以耗时（效率低）。

? 场景2：将Student作为Key，String作为Value，放入TreeMap集合中。

???使用Comparable（内部比较器）实现。

public class Student implements Comparable<Student> {
	private int id;
	private String name;

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

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + "]";
	}

	@Override
	public int compareTo(Student o) {
		return this.getId() - o.getId();
	}
}

import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap2 {
	public static void main(String[] args) {
		Map<Student,String> map = new TreeMap<>();
		map.put(new Student(11,"Jackson"), "AAA");
		map.put(new Student(12,"Jack"), "AAA");
		System.out.println(map);
	}
}

? 使用Comparator（外部比较器）实现。

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap2 {
	public static void main(String[] args) {
		Map<Student,String> map = new TreeMap<>(new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				return o1.getId()-o2.getId();
			}
		});
		map.put(new Student(11,"Jackson"), "AAA");
		map.put(new Student(12,"Jack"), "AAA");
		System.out.println(map);
	}
}

? 外部比较器使用Lambda表达式实现。

import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap2 {
	public static void main(String[] args) {
		Map<Student,String> map = new TreeMap<>((o1,o2)->o1.getId()-o2.getId());
		map.put(new Student(22,"Jackson"), "AAA");
		map.put(new Student(18,"Jack"), "AAA");
		System.out.println(map);
	}
}

???注意：TreeMap中的Key，必须实现Comparable接口或者实现Comparator接口，否则会抛出ClassCastException。

其他集合

LinkedHashSet

????LinkedHashSet是有序的，不会自动进行排序，如果想让放入Set集合的元素是有序的，可以使用LinkedHashSet。

????添加的元素允许为null，元素不允许重复。

import java.util.LinkedHashSet;
import java.util.Set;

/**
 * 放入集合中的元素是有序的
 */
public class TestLinkedHashSet {
	public static void main(String[] args) {
		Set<String> set = new LinkedHashSet<>();
		set.add("Tom");
		set.add("Adam");
		set.add("Bob");
		set.add("Merry");
		set.add("Tomas");
		set.add("Bob");
		set.add(null);
		System.out.println(set);	// [Tom, Adam, Bob, Merry, Tomas, null]
	}
}

? HashSet和LinkedHashSet做200W的压力测试，HashSet性能略高于LinkedHashSet

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

import org.junit.Test;

public class TestSet {

	private final static int SIZE=2000000;

	private Set<Integer> linkSet = new LinkedHashSet<>();
	private Set<Integer> set = new HashSet<>();

	/**
	 * add()方法200W次		耗时121ms
	 */
	@Test
	public void testAddLinkedHashSet() {
		for(int i=0;i<SIZE;i++) {
			linkSet.add(i);
		}
		System.out.println(linkSet.size());
	}

	/**
	 * add()方法200W次		耗时101ms
	 */
	@Test
	public void testAddHashSet() {
		for(int i=0;i<SIZE;i++) {
			set.add(i);
		}
		System.out.println(set.size());
	}
}

LinkedHashMap

????LinkedHashMap是有序的，不会自动进行排序，如果你想让key-value(键值对)在集合中有序，可以使用LinkedHashMap。

????添加的 key-value 允许为null，key不允许重复。

? 场景：使用LinkedHashMap存储key-value对

import java.util.LinkedHashMap;
import java.util.Map;

public class TestLinkedHashMap {
	public static void main(String[] args) {
		Map<String, String> map = new LinkedHashMap<>();
		map.put("北京", "china");
		map.put("上海", "china");
		map.put("天津", "china");
		map.put("长沙", "china");
		map.put("北京", "china");
		map.put(null, null);
		System.out.println(map);	// {北京=china, 上海=china, 天津=china, 长沙=china, null=null}
	}
}

? 压力测试put(k,v)方法200W,HashMap效率略高于LinkedHashMap

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

import org.junit.Test;

public class TestMap {

	private final static int SIZE=2000000;

	private Map<Integer,Integer> linkMap = new LinkedHashMap<>();
	private Map<Integer,Integer> map = new HashMap<>();

	/**
	 * put(k,v)方法200W	耗时109ms
	 */
	@Test
	public void putHashMap() {
		for(int i=0; i<SIZE; i++) {
			map.put(i,i);
		}
		System.out.println(map.size());
	}

	/**
	 * put(k,v)方法200W	耗时120ms
	 */
	@Test
	public void putLinkedHashMap() {
		for(int i=0; i<SIZE; i++) {
			linkMap.put(i,i);
		}
		System.out.println("LinkedHashMap size=" + linkMap.size());
	}
}

Vector

???Vector 类实现了可扩展的对象数组。

????SinceJDK1.0，是ArrayList的前身，从JDK1.2开始Vector就废弃了(不使用了)，ArrayList取而代之。

????Vector是线程安全的，效率低；ArrayList非线程安全。

???Vector扩容机制是原始容量的2倍，ArrayList是原始容量的1.5倍。

import java.util.List;
import java.util.Vector;

public class TestVector {
	public static void main(String[] args) {
		// Vector也实现了List接口
		// Vector扩容机制是：原始容量的2倍
		List<Integer> list = new Vector<>();
		for(int i=0;i<20;i++) {
			list.add(i);
		}
		list.add(10);
	}
}

?

? 场景：100W压力，测试ArrayList和Vector，目的：谁的效率高。

? ArrayList执行效率比Vector高，因为ArrayList没有synchronized关键字。

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.junit.Test;

public class TestList {

	private final static int SIZE=1000000;

	private List<Integer> list = new ArrayList<>();
	private List<Integer> vector = new Vector<>();

	/**
	 * add()方法100W		耗时13ms
	 */
	@Test
	public void testAddArrayList() {
		for(int i=0; i<SIZE; i++) {
			list.add(i);
		}
		System.out.println("ArrayList size=" + list.size());
	}

	/**
	 * add()方法100W		23ms
	 */
	@Test
	public void testAddVector() {
		for(int i=0; i<SIZE;i++) {
			vector.add(i);
		}
		System.out.println("Vector size=" + vector.size());
	}
}

HashTable

????SinceJDK1.0，是HashMap的前身，也是使用键值对存储数据。

???Hashtable类和HashMap用法几乎一模一样，只是HashTable的方法中添加了synchronizeed（同步），效率低。

???Hashtable不允许 key 或 value 为null。

?

? 为什么会被淘汰？

????1. 是一个线程安全的键值对集合，put元素到HashTable效率相对较低。

???2. 不允许有null值，否则就会抛出空指针异常。

????3. 默认容量是11，所以扩容相对较频繁。容量会出现莫名其妙的bug，最好设置为2的次幂。

Properties

? SinceJDK1.0，继承了Hashtable 类，以使用键值对存储数据，

???put(key, value)：由于没有指定泛型，所以key-value可以存放任意类型，但不允许为空。

????get(key)：根据key（键）来获对应取值，查找不到返回null。

????Properties 类的详细使用：https://blog.csdn.net/yjltx1234csdn/article/details/93769032

相关面试题

如何将ArrayList变为线程安全

???使用Collections中synchronizedList()实现。

package com.whsxt.day8.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestArrayList {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		// 将ArrayList由非线程安全变为线程安全
		List<Integer> syncList = Collections.synchronizedList(list);
		// syncList就是一个线程安全的ArrayList
		System.out.println(syncList);
	}
}

ArrayList和LinkedList区别

ArrayList LinkedList
本质是一个数组，适合查找 本质是一个链表，适合插入，添加，删除
构造方法有一个int类型的参数，表示数组的长度 构造方法没有int类型的参数
遍历元素效率高，删除首部和中间元素效率低 删除首部和中间元素效率高，遍历元素效率低

? ArrayList和LinkedList区别：https://www.cnblogs.com/yonyong/p/9323588.html

ArrayList和Vector区别

ArrayList Vector
非线程安全的，性能好 方法都是同步的(Synchronized)，线程安全的，性能差
初始容量为10，扩容机制，原始容量的1.5倍 初始容量为10，扩容机制，原始容量的2倍
第一次add方法被调用的时候指定容量 创建对象指定容量
SinceJDK1.2 SinceJDK1.0

????ArrayList和Vector区别：https://www.cnblogs.com/guweiwei/p/6632341.html

HashTable和HashMap区别

HashMap HashTable
非线程安全 方法都是同步的(Synchronized)，线程安全，速度慢
加载因子为0.75，默认容量16 加载因子为0.75，默认容量11
扩容增量：原容量的 1 倍 扩容增量：2*原数组长度+1
允许 key-value 为null 不允许 key-value 为null
sinceJDK1.2 sinceJDK1.0

????一般情况下，HashMap能够比Hashtable工作的更好、更快，主要得益于它的散列算法，以及没有同步。应用程序一般在更高的层面上实 现了保护机制，而不是依赖于这些底层数据结构的同步，因此，HashMap能够在大多应用中满足需要。推荐使用HashMap，如果需要同步，可以使用同 步工具类将其转换成支持同步的HashMap。

????HashMap实现同步：Collections.synchronizedMap()

????HashMap默认容量为何是16：16是2^4，可以提高查询效率，另外，32=16<<1。

????length 的值为 2 的整数次幂，**h & (length - 1)**相当于对 length 取模。这样提高了效率也使得数据分布更加均匀。

????为什么会更加均匀？ length的值为偶数，length - 1 为奇数，则二进制位的最后以为为1，这样保证了 h & (length - 1) 的二进制数最后一位可能为1，也可能为0。如果为length为奇数，那么就会浪费一半的空间。

ArrayList和HashMap有哪些共性

????他们内部都以一个数组。

???都有get()方法。

???ArrayList实际上也是以键值对的形式存储数据，只不过ArrayList的key只能是整数类型，HashMap的key可以使任意类型，但是必须要覆盖hashCode()和equals()方法。

HashMap和HashSet有哪些共性和联系？

???HashSet本质就是一个HashMap，也就是说HashSet有一个HashMap的属性，每当创建一个HashSet对象，在它的构造方法中就会创建一个HashMap对象。

???加载因子为0.75：即当 元素个数超过容量长度的0.75倍 时，进行扩容。

???扩容增量：原容量的 1 倍。（如 HashSet的容量为16，一次扩容后是容量为32）

????HashSet实际上也是使用键值对形式存储数据，key必须唯一，值可以重复(哑巴值）。

? 都以Key对象产生的hashCode来排序的。

String str1="Tom";
String str2= new String("Tom");
set.add(str1);
set.add(str2);
// 实际大小是1，因为str1和str2有着相同的hashCode

TreeMap和TreeSet存储机制（重点）

????他们都是树形结构，以红黑树的形式存储数据。

????红黑树：是一个平衡的二叉树。

????二叉树特征：每个节点最多只能有两个子节点，左边的子节点叫做左子树，右边的节点叫做右子树，左子树的值永远都小于该节点，右子树的值永远都大于该节点。

????平衡：自己被右孩子代替了，然后自己变成左孩子，叫做左旋转。

?????? 自己被左孩子代替了，然后自己变成右孩子，叫做右旋转。

????变色 ：二叉树由红色节点和黑色节点构成。

????红黑树原则：

??????1. 根节点必须是黑色节点

??????2. 子节点可以是红色也可以是黑色

???????3. 一旦某个节点是红色，那么它下面的子节点必须是黑色

??????4. 叶子必须是黑色，叶子节点下面不能再有子节点

???????5. 某个节点到叶子节点的所有路径包含相同数量的黑色节点

???小结：有红必有黑，红红不相连(父节点是红色，所有的子节点必须是黑色)。

???????根节点的左边永远都小于根节点，右边永远都大于根节点。

????目的：方便比较（方便查找），查找的次数不能大于树的深度

? 场景：创建一个TreeSet集合，向集合中添加55，56，57，58，59 删除57，最后添加60，目的理解元素在TreeSet中如何存储(表示)。

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

/**
 * black ---> true
 * red   ---> false
 */
public class TestTreeSet3 {
	public static void main(String[] args) {
		Set<Integer> set = new TreeSet<>();
		set.add(55);
		set.add(56);
		set.add(57);
		set.add(58);
		set.remove(57);
		set.add(59);
		set.add(60);
		System.out.println(set);
	}
}

ArrayList案例

????定义一个ArrayList集合，里面有若干个Student对象[id,name,age,成绩,爱好]，要求从集合中找到成绩大于90，并且年龄大于16的学生分数，此外还要对分数进行排序[93,92,91]

public class Student {

	private int id;
	private String stuName;
	private int stuAge;
	private int score;
	private String stuHobby;

    public Student() {}
	public Student(int id, String stuName, int stuAge, int score, String stuHobby) {
		this.id = id;
		this.stuName = stuName;
		this.stuAge = stuAge;
		this.score = score;
		this.stuHobby = stuHobby;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public int getStuAge() {
		return stuAge;
	}
	public void setStuAge(int stuAge) {
		this.stuAge = stuAge;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	public String getStuHobby() {
		return stuHobby;
	}
	public void setStuHobby(String stuHobby) {
		this.stuHobby = stuHobby;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result + score;
		result = prime * result + stuAge;
		result = prime * result + ((stuHobby == null) ? 0 : stuHobby.hashCode());
		result = prime * result + ((stuName == null) ? 0 : stuName.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 (id != other.id)
			return false;
		if (score != other.score)
			return false;
		if (stuAge != other.stuAge)
			return false;
		if (stuHobby == null) {
			if (other.stuHobby != null)
				return false;
		} else if (!stuHobby.equals(other.stuHobby))
			return false;
		if (stuName == null) {
			if (other.stuName != null)
				return false;
		} else if (!stuName.equals(other.stuName))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", stuName=" + stuName + ", stuAge=" + stuAge + ", score=" + score + ", stuHobby=" + stuHobby + "]";
	}  

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 定义一个ArrayList集合，里面有若干个Student对象[id,name,age,成绩,爱好]，
 * 要求从集合中找到大于90的成绩，
 * 并且年龄大于16的学生，只找出最大的3个，不能重复。此外还要对分数进行排序[99,98,97]
 *
 * 1. 遍历集合中的所有Student对象，过滤掉年龄小于16的学生，放入新集合
 * 2. 提取成绩，将提取的结果放入一个新的集合中[89,91,88,87,91....]
 * 3. 过滤掉重复的分数
 * 4. 只限制3个成绩
 * 5. 成绩排序
 */
public class TestStudent {
	private static List<Student> list = new ArrayList<>();
	static{
		list.add(new Student(101,"黄欣", 18, 89,"Football"));
		list.add(new Student(21,"张衡", 16, 91,"Basketball"));
		list.add(new Student(31,"陈亮", 17, 88,"Pinpong"));
		list.add(new Student(11,"李阳", 19, 91,"Tennis"));
		list.add(new Student(61,"唐科资", 20, 91,"Swimming"));
		list.add(new Student(81,"邹涛", 22, 99,"HightJump"));
		list.add(new Student(51,"陈勇", 21, 98,"Running"));
		list.add(new Student(81,"郑行", 22, 97,"HightJump"));
		list.add(new Student(51,"胡黎", 15, 78,"Running"));
		list.add(new Student(51,"关洪颜", 15, 93,"Running"));
	}

	public static void main(String[] args) {
		//过滤掉<=16的学生信息,保留>16的学生信息，将过滤结果放入新集合中
		List<Student> stuList =new ArrayList<>();
		for (Student student : list) {
			if(student.getStuAge()>16) {
				stuList.add(student);
			}
		}
		//提取成绩
		List<Integer> scoreList = new ArrayList<>();
		for (Student stu : stuList) {
			scoreList.add(stu.getScore());
		}
		System.out.println(scoreList);
		//去掉重复的成绩
		distinct(scoreList);
		System.out.println(scoreList);
		//排序
		Collections.sort(scoreList,Collections.reverseOrder());
		System.out.println(scoreList);
		//限制3个
		scoreList = scoreList.subList(0,3);
		System.out.println(scoreList);
	}

	/**
	 * 去重
	 * @param scoreList
	 */
	private static <E> void distinct(List<E> scoreList) {
		Set<E> set = new HashSet<>();
		set.addAll(scoreList);
		scoreList.clear();
		scoreList.addAll(set);
	}
}

原文地址：https://www.cnblogs.com/lyang-a/p/12569170.html

时间： 2025-01-17 15:20:56

TreeSet和TreeMap的相关文章

Java 集合类 TreeSet、TreeMap

TreeMap和TreeSet的异同: 相同点: TreeMap和TreeSet都是有序的集合,也就是说他们存储的值都是拍好序的. TreeMap和TreeSet都是非同步集合,因此他们不能在多线程之间共享,不过可以使用方法Collections.synchroinzedMap()来实现同步 运行速度都要比Hash集合慢,他们内部对元素的操作时间复杂度为O(logN),而HashMap/HashSet则为O(1). 不同点: 最主要的区别就是TreeSet和TreeMap非别实现Set和Map接

TreeSet和TreeMap的输出

如果加入TreeSet和TreeMap的元素没有实现comprable中的compareTo()方法,那么会报错"treeset cannot be cast to java.lang.Comparable". 因此需要对元素类型实现comparable借口,并实现compareTo()方法,即告诉TreeSet和TreeMap你要怎么排列,它才能进行排序. 基础类: package niukewang; import java.util.Objects; public class s

第40讲：Set、Map、TreeSet、TreeMap操作代码实战

今天来看下set map的操作,让我们从代码出发 val data = mutable.Set.empty[Int] data ++= List(1,2,3)//在空set上加入列表 data += 4//在set上加入新元素 data --= List(2,3) println(data) //Set(1, 4)data += 1println(data)//Set(1, 4),说明Set元素不能重复data.clear() println(data)//Set() 我们可以看出,Set和Li

深入源码分析TreeSet和TreeMap

类似于前面介绍的HashMap和HashSet之间的关系,HashSet底层依赖于HashMap实现,而TreeSet底层则采用一个NavigableMap来保存TreeSet集合的元素.但实际上,由于NavigableMap只是一个接口,因底层依然是使用TreeMap来包含Set集合中的所有元素. 我们观察TreeSet的部分源码: package java.util; public class TreeSet<E> extends AbstractSet<E> implemen

TreeSet与TreeMap浅解

TreeSet与TreeMap的关系: 1.TreeSet 实际上就是用TreeMap来组织数据的,因为在TreeSet中保存了一个NavigableMap<e,Object>接口实例变量,而该接口的实现类就是TreeMap 2.TreeSet与TreeMap都是用二叉树的数据结构来存储数据 3.TreeSet和TreeMap中保存的数据除了Integer和String等有默认顺序的类型外的自定义类型都需要实现Comparable接口并重写compareTo()方法. TreeSet和Tree

线程暂停的方法、基本数据类型包装类、十进制单精度浮点数（32位）存入内存中、TreeSet和TreeMap

使线程暂停执行的方法? 1.Thread类的sleep()方法使线程进入阻塞状态,睡眠指定的时间段. 2.Object类的wait()方法使线程放弃对象锁,进入等锁池,直到获得对象锁后才继续往下执行 3.Thread类的yield()方法平时比较少用,使线程进入就绪状态而不是阻塞状态,也就是说下一个执行的线程可能还是这个线程,当然也可能让给了其他的线程,那么这个线程就暂停了. 4.Java5后的使用Lock接口也可以实现类似于对象锁的功能,优点是比较灵活.可以知道线程获得锁了没有等,比较大的缺点

Java集合Set、Map、HashSet、HashMap、TreeSet、TreeMap等

1.Set和Map的关系: Set代表一种集合元素无序.不可重复的集合,Map代表一种由多个key-value对组成的集合. Set的集合继承体系: Map关系集合 Map集合的key特征:所有key不能重复,key之间没有顺序.Map集合的所有key将具有set集合的特征. 对Set做改造可将Set改造成Map集合: 2.HashSet和HashMap的区别和联系:    对于HashSet,系统采用Hash算法决定集合元素的存储位置:对于HashMap,系统将value当成key的附属物,系

TreeSet与TreeMap的源码分析 JDK7

TreeSet存储原则是:不可重复,有序的. public TreeSet() { this(new TreeMap<E,Object>()); } public TreeSet(Comparator<? super E> comparator) { this(new TreeMap<>(comparator)); } 上面是TreeSet常用的两个构造函数. 底层实现也就是TreeMap. TreeSet(NavigableMap<E,Object> m)

Scala 深入浅出实战经典 第40讲：Set、Map、TreeSet、TreeMap操作代码实战

王家林亲授<DT大数据梦工厂>大数据实战视频 Scala 深入浅出实战经典(1-64讲)完整视频.PPT.代码下载:百度云盘:http://pan.baidu.com/s/1c0noOt6 腾讯微云:http://url.cn/TnGbdC 360云盘:http://yunpan.cn/cQ4c2UALDjSKy 访问密码 45e2 技术爱好者尤其是大数据爱好者 可以加DT大数据梦工厂的qq群 DT大数据梦工厂① :462923555 DT大数据梦工厂②:437123764 DT大数据梦工厂③

TreeSet与TreeMap排序

1.TreeSet原理: /* * TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法 *  * Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序) *  * 如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口 *   在类上implement Comparable  *   重写compareTo()方法 *   在方法内定义比较算法, 根据大小关系, 返回正数负数或零 *