哈希表和有序表

哈希表

1、哈希表本质其实就是集合结构，哈希表有HashMap和HashSet，HashSet中只有key，HashMap中key对应value，并且key都不可以重复，所以可以理解为本质上都是集合结构。
2、哈希表的增删改查操作的时间复杂度接近O(1)，但是常数项比较大
3、哈希表中只能存放java对基础类型的封装类，不能存放基础数据类型
4、存入哈希表中的值，如果是基本数据类型，则拷贝一份放入数据结构中，基础数据实际多大放入表中就有多大，而引用数据类型是将内存地址放入其中，大小只是内存地址大小
5、常用方法：add、remove、isEmpty、size、contains等

简单应用

import java.util.HashMap;
import java.util.HashSet;

public class 哈希表的简单应用 {

	public static void main(String[] args) {
		HashSet<Integer> set = new HashSet<>();
		
		// 增
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		set.add(5);
		set.add(6);
		
		// 是否为null
		boolean isEmpty = set.isEmpty();
		System.out.println(isEmpty);
		
		// 集合的大小
		int size = set.size();
		System.out.println(size);
		
		// 删
		boolean remove = set.remove(3);
		System.out.println(remove);
		
		// 查-是否有这个值
		boolean contains = set.contains(5);
		System.out.println(contains);
		
		
		HashMap<Integer,String> map = new HashMap<>();
		
		map.put(1,"第一个数字");
		map.put(2,"第二个数字");
		map.put(3,"第三个数字");
		map.put(4,"第四个数字");
		map.put(5,"第五个数字");
		
		// 返回值是value类型
		String get = map.get(3);
		
		boolean containsKey = map.containsKey(3);
		boolean containsValue = map.containsValue("第二个数字");
		
		boolean isempty = map.isEmpty();
		
		int Size = map.size();
		
		// 返回值是value类型
		String Remove = map.remove(5);
		
		
	}

}

有序表

1、有序表本质其实就是集合结构，有序表有TreeSet和TreeMap，TreeSet中只有key，TreeMap中key对应value，并且key都不可以重复，所以可以理解为本质上都是集合结构。
2、有序表和哈希表的区别是，有序表把key按照顺序组织起来，哈希表完全不组织，时间复杂度为O(logN)，比哈希表差一点
3、哈希表中只能存放java对基础类型的封装类，不能存放基础数据类型
4、存入哈希表中的值，如果是基本数据类型，则拷贝一份放入数据结构中，基础数据实际多大放入表中就有多大，而引用数据类型是将内存地址放入其中，大小只是内存地址大小
5、放入有序表中的东西，如果不是基础数据类型，必须提供比较器
6、常用方法：add、remove、isEmpty、size、contains等

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

public class 有序表的简单应用 {

	public static void main(String[] args) {
		
		TreeSet<Integer> set = new TreeSet<>();
		
		set.add(4);
		set.add(2);
		set.add(9);
		set.add(7);
		set.add(1);
		
		// 取第一个值
		Integer first = set.first();
		System.out.println(first);
		
		// 取最后一个值
		Integer last = set.last();
		System.out.println(last);
		
		// 取第一个值，弹出
		Integer pollFirst = set.pollFirst();
		System.out.println(pollFirst);
		
		// 取最后一个值，弹出
		Integer pollLast = set.pollLast();
		System.out.println(pollLast);
		
		
		TreeMap<Node,Integer> map = new TreeMap<>(new NodeComparator());
		Node node1 = new Node(4,"第四个值");
		Node node2 = new Node(2,"第二个值");
		Node node3 = new Node(9,"第九个值");
		Node node4 = new Node(7,"第七个值");
		Node node5 = new Node(1,"第一个值");
		
		map.put(node1,1);
		map.put(node2,2);
		map.put(node3,3);
		map.put(node4,4);
		map.put(node5,5);
		
		// 排序在最前面的key
	    Node node11 = map.firstKey();
	    System.out.println(node11.value);
	    
	    // 排序在最后面的key
	    Node node22 = map.lastKey();
	    System.out.println(node22.value);
	    
	    // 返回这个key的前一个，如果是map中的值则返回自己
	    Node node33 = map.floorKey(new Node(8,"第八个值"));
	    System.out.println(node33.value);
	    
	    Node node44 = map.ceilingKey(new Node(8,"第八个值"));
	    System.out.println(node44.value);
		
	}

}
class Node{
	int key;
	String value;
	
	public Node(int key,String value) {
		this.key = key;
		this.value = value;
	}
}

class NodeComparator implements  Comparator<Node>{

	@Override
	public int compare(Node o1, Node o2) {
		
		return o1.key-o2.key;
	}
	
}