Day18java散列表、泛型

1.Set

1.1HashSet使用

/**
 * 散列表结构 可以理解为 数组中保存的是链表的首节点,用来保存k和v键值对操作
 * 
 * hash算法 : 是一种安全的加密机制,可以把不定长的数据转换为定长数据,并且不能保证其唯一性,又叫哈希冲突
 * 
 * 在java中 指的就是hashCode方法
 * 
 * 对一个对象生成多次hash值 , 值一定相同 , 多个对象也可能生成相同的hash值,叫哈希冲突
 * 
 * k不可重复 , v 可重复 
 * 
 * 添加过程 : 
 * 		1 根据要添加的key,调用的它的hashCode方法,生成hash值
 * 		2 通过一定的算法,根据hash值生成数组的下标
 * 		3 判断该下标中,是否有数据,如果没有数据就把该键值对映射关系保存到数组中
 * 		4 如果该下标中,有数据,则调用key的equals方法,和对应的所有数据进行比较,如果不相等,则添加到链表的尾部即可
 * 		5 如果对应的链表中,通过equals方法比较的时候,发现了相同的数据,那么 key不再添加 ,但是value值会替换原来的value值
 * 		通过添加过程得知,会自动调用该对象的hashCode和equals,所以在保存自定义类型的时候,需要注意方法覆写
 * 		在1.8中有个新改动,为了提高查询效率,引入了红黑树和扩容的优化
 * 			因为链表在查询性能上较差,所以每个数组中的链表个数如果大于等于7,则会把该链表转换为红黑树
 * 			数组默认初始化容量为16
 * 
 * 
 * 在java中 没有散列表的概念,把散列表封装为了HashMap和HashTable
 */

HashSet set = new HashSet();
		set.add(1);
		set.add("asd");
		set.remove("asd");
		System.out.println(set.size());
		set.isEmpty();
		for (Object object : set) {

		}

2.散列表

2.1概述
哈希表
2.2HashSet

以上两个截图可看出来,当我们使用HashSet的时候,其实就等于是再使用HashMap
添加数据的时候,虽然调用的是HashSet的add方法,但是本质还是调用map的put方法
Ps : 在map中,put是添加操作

而 map中 需要保存的是k和v映射关系,所以在set中有一个变量保存了value的值
所以我们再进行set添加的时候,只操作了map中的key,value值我们不再关心

3.Map

3.1概述

/*
 * Map是无序的，保存的是K-V键值对映射关系，其中K不能重复，V可重复
 *  HashMap : 底层是散列表
 * 
 * TreeMap : 底层是红黑树,元素必须按照一定的规则进行排序
 * 
 * 映射关系 : 比如 商品 和 购买数量 , 或者数据统计
 * 			"akshdkjhwqgheghgbsjkasdjaskhrjqw" 统计每个字符出现的个数 使用 HashMap进行存储,字符做K 次数做V
 */

3.2继承体系
3.3常用方法
3.4HashMap

		// 创建map
		HashMap map = new HashMap();
		// 添加 K-V
		map.put("A", "one");
		map.put("B", "two");
		map.put("C", "three");
		map.put(65,100);
		map.put('A', "2222");
		// key重复,不添加,value替换
		map.put("A", "2222");
		// 支持K和V都null,但是没有意义
		map.put(null,null);
		// 个数
		System.out.println(map.size());
		// get : 根据K 获取 V的值
		System.out.println(map.get("A"));
		// 判断是否包含某个key
		System.out.println(map.containsKey(65));
		// 判断是否包含某个value
		System.out.println(map.containsValue("one"));
		// 根据key删除 该映射关系,返回对应的value值
		map.remove(65);
		// 获取所有的value,并放到集合中返回
		Collection values = map.values();
		for (Object object : values) {
			System.out.println(object);
		}
		System.out.println("======");
		// keySet : 获取所有的key,封装到set对象中并返回
		Set keys = map.keySet();
		for (Object object : keys) {
			System.out.println(object +":"+map.get(object));
		}
		// 把map转换为set
		// Entry类中,保存了K和V两个变量,把map中的k和v转换为entry类的对象进行存储
		// 所以我们只需要保存entry对象,就等于保存了k和v
		Set set  = map.entrySet();
		for (Object object : set) {
			// C=three
			System.out.println(object);
			// 转换为entry类型
			Entry entry = (Entry) object;
			// 获取k和v
			System.out.println(entry.getKey()+" : "+entry.getValue());
		}

3.5TreeMap

package day_01;

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

/*
 *  * TreeMap 保存的元素会按照一定规则进行排序,底层是红黑树
 * 
 * Comparable 和 Comparator
 */
public class Map_03_TreeMap {
	public static void main(String[]args){
		//添加自定义类型，并且product 中实现了Comparable接口
		TreeMap map = new TreeMap();
		map.put(new Product("苹果",5.3), 10);
		map.put(new Product("香蕉",5.6), 10);
		System.out.println(map.size());
		
		// 添加已有类型,且该类型实现了Comparable接口,Integer默认升序
		// 如果 该类型没有实现Comparable接口,或者 我们想要降序,则需要使用Comparator
		// map = new TreeMap();
		map = new TreeMap(new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				return i2 - i1;
			}
		});
		map.put(11, "a");
		map.put(2, "a");
		map.put(23, "a");
		map.put(3, "a");
		System.out.println(map.size());
		System.out.println(map);
	}
		
		
	
}
class Product implements Comparable{
	private String name;
	private double price;
	
	public Product(String name,double price){
		super();
		this.name = name;
		this.price = price;
	}
	
	@Override
	public int compareTo(Object o){
		if (o instanceof Product) {
			Product p = (Product) o;
			if (this.price > p.price) {
				return 1;
			} else if (this.price < p.price) {
				return -1;
			}
		}
		return 0;
	}

}

4.泛型

/**

• 泛型 : 在编译过程中检测数据类型是否匹配
• 泛型 必须是引用类型,不能使用基本类型
• 优点 : 统一了数据类型,减少了类型转换
• 缺点 : 只能保存同一种类型
  */
  4.2使用

package day_01;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.Set;

/**
 * 泛型 : 在编译过程中检测数据类型是否匹配
 * 
 * 泛型 必须是引用类型,不能使用基本类型
 * 
 * 优点 : 统一了数据类型,减少了类型转换
 * 
 * 缺点 : 只能保存同一种类型
 */
public class Map_04_Generic_01 {
	public static void main(String[]args){
		//没有使用泛型
		List list = new ArrayList();
		//什么也能放
		list.add(new A());
		list.add(1);
		//取的时候，拿到的是object
		for(Object object:list){
			//使用需要进行判断和向下转型
			if(object instanceof C){
				C a = (C)object;
				a.m1();
			}
		}
		
		//使用泛型  规定  该集合中 只能保存A类型
		List<C> list2 = new ArrayList<C>();
		list2.add(new C());
		//添加其他的 报错，而且是编译器报错
		//list2.add(2);
		
		//使用的时候，拿到的就直接是A类型，不会出现类型转换异常
		//因为只要能运行，里面一定是A
		for(C a:list2){
			a.m1();
		}
		

		// 泛型 不能写基本类型,只能写引用类型
		// 如果想要保存基本类型,则需要编写对应的包装类类型
		// List<int> list3 = new ArrayList<int>();
		List<Integer> list4 = new ArrayList<Integer>();
		
		// 如果 需要保存多种数据,则不需要使用泛型
		// 但是如果需要保存同一种类型的数据,则一定要使用泛型,这样方便操作
		
		// set和map使用泛型
		Set<String> set = new HashSet<String>();
		Map<String, Integer> map = new HashMap<String, Integer>();
	}
}

class C {
	public void m1(){
		System.out.println("m1执行了");
	}
}

4.3注意

4.4自定义泛型

/**

• 定义泛型,使用大写字母A-Z表示,写什么都一样,都只是占位符而已,只不过 某些字符也有一些特殊的含义

•  E : Element 一般代表元素,而集合中的数据 我们叫元素,所以在集合中出现的泛型一般使用E表示
  

•  K : Key 表示键
  

•  V : value 表示值 K和V一般在散列表中出现(Map)
  

•  T : Type 表示一个java类型
  

•  N : 表示Number
  

•  ? : 表示不确定的类型
  

• 如果规定了泛型,但是使用的地方没有指定泛型,则默认为Object类型
  */
  

5.题

/**

• Map以Value进行排序
• Map是没有办法按照value排序的,因为源码中写死了 是用key进行比较
• 所以 只能保存到List中进行排序

*/