数据结构之哈希表

最新推荐文章于 2024-02-02 17:41:03 发布

CSNZのBlog

最新推荐文章于 2024-02-02 17:41:03 发布

阅读量303

点赞数

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

本文链接：https://blog.csdn.net/csnz123123/article/details/118886228

版权

Java数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一：哈希表的简单介绍

哈希表在使用层面上可以理解为一种集合结构
如果只有key ，没有伴随数据value，可以使用 HashSet 结构
如果既有 key，又有伴随数据value，可以使用HashMap结构
有无伴随数据，是HashMap 和 HashSet 唯一的区别，底层的实际结构是一回事
使用哈希表增 ( put ) 、删 ( remove )、改 ( put )、查 ( get ) 的操作，可以认为时间复杂度为 O（1），但是常数时间比较大。
放入哈希表的东西，如果是基础类型 (Integer、String这些在哈希表中属基础类型)，内部按值传递，内存占用就是这个东西的内存大小
放入哈希表的东西，如果不是基础类型，内部按引用传递，内存占用就是这个东西的内存地址，一律按8字节(哈希表所引用的内存空间)

二：有序表的简单介绍

有序表在使用层面上可以理解为一种集合结构
如果只有key，没有伴随数据value，可以使用 TreeSet 结构
如果既有key，又有伴随数据value，可以使用TreeMap结构
有无伴随数据，是TreeSet 和 TreeMap唯一的区别，底层的实际结构是一回事
有序表和哈希表的区别是：有序表把key按照顺序组织起来，而哈希表完全不组织
红黑树，AVL树，size - balance - tree 和跳表等都属于有序表结构，只是底层具体实现不同
放入有序表的东西，如果是基础类型，内部按值传递，内存占用就是这个东西的大小
放入有序表的东西，如果不是基础类型，必须提供比较器，内部按引用传递，内存占用就是这个东西的内存地址
不管是什么底层具体实现，只要是有序表，都有以下固定的基本功能和固定的时间复杂度

一：java.util.Map<key,value>集合

集合的特点都是和其底层结构有关
Map集合的特点：
1；双列集合，一个元素包含两个值(一个key，一个value)
2：数据类型： key和value的数据类型可以相同也可以不相同
3：key是不允许重复的，而value则允许重复
4：key 与 value 是一一对应的

二：Map的三个常用子类

1、java.util.HashMap<k,v>集合 implements Map<k,v>接口

HashMap集合的特点：
1：底层结构是哈希表(查询速度快) 哈希表在JDK1.8前是数组+链表 1.8之后是数组+链表/红黑树
2：无序集合，存储和取出的顺序可能不一样
key为0~10他会自动排序详情见HashMapAutoSort
3：元素唯一注意：要是使用自定义对象需要重写hashCode和equals方法保证他的唯一性

HashMapAutoSort

package Map;
import java.util.HashMap;
public class HashMapAutoSort {
	public static void main(String[] args) {
		//当所有key的hash的最大值<数组的长度-1时HashMap可以将存入的元素按照key的hash从小到大排序
		HashMap<String,String>  map = new HashMap<>();
		map.put("6", "6");
		map.put("5", "5");
		map.put("4", "4");
		map.put("8", "8");
		map.put("7", "7");
		map.put("0", "0");
		map.put("10", "10");
//		map.put("11", "11");
//		map.put("12", "12");
		for (String key : map.keySet()) {
			String value = map.get(key);
			System.out.println(key+" --> "+ value);
		}
	}
}

2、java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合

Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。
此链接列表定义了迭代顺序
简单来讲：就是有序

LinkedHashMap的特点：
1：底层是哈希表+链表(保证了迭代的顺序)
2：有序集合，存储和取出元素的顺序是一致的

3、TreeMap

不仅是有序的，因为其底层的红黑树结构，它可以根据键值的大小进行排序。

三：Hashtable

java.util.Hashtable<k,v>集合 implements Map<k,v>接口
Hashtable底层是一个哈希表,是一个线程安全的集合,是单线程集合,速度慢.
HashMap 底层是一个哈希表，是一个线程不安全的集合，是多线程集合，速度快

HashMap集合(之前所学的所有集合)：可以存储null值，null键
Hashtable集合：不可以存储null值，null键

Hashtable和Vector集合一样,在jdk1.2后被HashMap,ArrayList取代了
Hashtable的子类Properties依然活跃，Properties集合是唯一一个和IO流相结合的集合

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

public class HashtableDemo {
	public static void main(String[] args) {
		
		// HashMap 演示存储null值，null键
		HashMap<String,String> map = new HashMap<>();
		map.put(null, "我待会 会被替换");
		map.put("剩下我和另一个兄弟", null);
		map.put(null,null);
		//使用keySet()方法遍历
		Set<String> keySet = map.keySet();
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()) {
			String next = it.next();
			System.out.println(next+" --> "+map.get(next));
		}
		
		System.out.println("**********************");
		Hashtable<String,String> table = new Hashtable<>();
		table.put(null, null);	//错误写法 会报java.lang.NullPointerException
		System.out.println(table);
	}
}

四：java.util.Set<key,value>集合

1、java.util.Set接口 extends Collection接口

Set接口的特点：
1：不允许存储重复的元素
2：无索引，没有带索引的方法，不能使用普通的for循环遍历

2、java.util.HashSet集合 implements Set接口

HashSet特点：
1：不允许存储重复的元素
2：无索引，没有带索引的方法，不能使用普通的for循环遍历
3：是一个无序的集合，存储元素和取出元素的顺序有可能不一致
4：底层是一个哈希表结构(查询的速度非常的快)

3：java.util.LinedHashSet集合 extends HashSet集合

LinkedHashSet集合特点：
底层是一个哈希表 ( 数组+链表/红黑树 )+链表：这条多的链表用来记录元素的存储位置，保证元素有序

4：TreeSet集合

"无序的(无索引)，并且没有重复元素"的集合
使用元素的自然顺序对元素进行排序
或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
底层使用二叉树实现内部使用TreeMap的SortedSet
特点：
1：自动去除重复元素
2：自动升序排序（如果是自定义类的话,该自定义的类必须实现Comparable接口,并实现ComparaTo方法）

方法：
lower、floor、ceiling 和 higher
分别返回小于、小于等于、大于等于、大于给定元素的元素，如果不存在这样的元素，则返回 null。

package Collection.Set;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Integer> treeset = new TreeSet<>();
		//add() -->将指定的元素添加到此 set（如果该元素尚未存在于 set 中）
		treeset.add(10);
		treeset.add(2);
		treeset.add(1);
		treeset.add(1);
		//使用TreeSet会对元素默认升序排序
		System.out.println(treeset);
		System.out.println("*******ceiling()方法*********");
		//ceiling() --> 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null
		System.out.println("集合中>=2的最小元素："+treeset.ceiling(2));
		System.out.println("集合中>=3的最小元素："+treeset.ceiling(3));
		System.out.println("集合中>10的元素："+treeset.higher(10));
		System.out.println("********clone()浅拷贝方法********");
		//clone() --> 返回 TreeSet 实例的浅表副本
		Object cloneSet = treeset.clone();
		System.out.println("treeset：" +treeset);
		System.out.println("cloneSet："+cloneSet);
		System.out.println("*******first()*********");
		//返回此 set 中当前第一个（最低）元素
		System.out.println(treeset.first());
		System.out.println("*******last()*********");
		//返回此 set 中当前最后一个（最高）元素
		System.out.println(treeset.last());
		System.out.println("******headSet(E toElement) ******");
		//返回此 set 的部分视图，其元素严格小于 toElement。
		System.out.println(treeset.headSet(20));
		System.out.println("******isEmpty()******");
//		如果此 set 不包含任何元素，则返回 true
		System.out.println("是否为空："+treeset.isEmpty());
		//迭代遍历
		System.out.println("treeset迭代遍历");
		Iterator<Integer> it = treeset.iterator();
		while(it.hasNext()) {
			System.out.print(it.next()+" ");
		}
		
		System.out.println("\n获取treeset集合中的元素个数："+treeset.size());
	}

	
}