Java学习-第18天-CSDN博客

本文链接：https://blog.csdn.net/sec_90/article/details/122609560

package _01_Collection._03_Set;

import java.util.HashSet;
/**
 * 散列表结构 可以理解为 数组中保存的是链表的首节点,用来保存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
 * 
 * @author SEC90
 * @Date 2022年1月20日下午7:11:20
 */
public class HashSet_01 {
	@SuppressWarnings({ "rawtypes", "unchecked", "unused" })
	public static void main(String[] args) {
		HashSet set = new HashSet();
		set.add(1);
		set.add("asd");
		set.remove("asd");
		System.out.println(set.size());
		System.out.println(set.isEmpty());		
				for (Object object : set) {
			
		}
	}
}

package _02_Map;


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


/**
 * Map是无序的 并且保存的是K-V键值对映射关系,其中K不能重复,V可重复
 * 
 * HashMap : 底层是散列表
 * 
 * TreeMap : 底层是红黑数 元素必须安照一定的规则进行排序
 * 
 * 映射关系 : 比如商品和购买数量 或者数据统计 
 *  "ashfoiuholisknafgdf" 统计每个字符出现的次数 使用HashMap进行存储 字符做K 次数做V
 * 
 * @author SEC90
 * @Date 2022年1月20日下午2:11:53
 */
public class Map_01 {
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void main(String[] args) {
		HashMap map = new HashMap();
		map.put("A", "one");
		//key重复不添加 value替换
		map.put("A", "2222");
		map.put("B", "two");
		map.put("C", "three");
		map.put(65, 100);
		//char 不是引用数据类型,会转化为对应的包装类
		map.put('A', "1234");
		//支持K和V都为NULL,但是没有意义
		map.put(null, null);
		//个数
		System.out.println(map.size());
		//根据key 获取value
		System.out.println(map.get("A"));
		//判断是否包含某个key
		System.out.println(map.containsKey("A"));
		//判断是否包含某个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()
					);
		}
	}
}

package _02_Map;

import java.util.Properties;

public class Map_02 {
	public static void main(String[] args) {
		//特殊的map,k和v 都必须是字符串
		Properties properties = new Properties();
		//添加数据
		properties.setProperty("asd", "1243");
		//获取value
		properties.getProperty("asd");
	}
}

package _02_Map;

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



/**
 * TreeMap 保存的元素会按照一定规则排序 底层是红黑数
 * 
 * Comparable 和 Comparator
 * @author SEC90
 * @Date 2022年1月20日下午3:11:30
 */
public class Map_03_TreeMap {
	@SuppressWarnings({ "rawtypes", "unchecked" })
	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);
//		System.out.println(map.size());
		// /添加已有类型 且该类型实现了Comparable接口,Interger默认升序
		// 如果没有实现Comparable接口,或者我们想要降序,则需要Comparator
		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(24, "a");
		map.put(3, "a");
		System.out.println(map.size());
		System.out.println(map);
	}
}

@SuppressWarnings("rawtypes")
class Product implements Comparable {
	@SuppressWarnings("unused")
	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 product = (Product) o;
			if (this.price > product.price) {
					return 1;
			}else if (this.price < product.price) {
				return -1;
			}
		}
		return 0;
	}
}

package _02_Map;

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



/**
 * 泛型 : 在编译过程中检测数据类型是否匹配
 * 
 * 泛型 必须是引用类型,不能使用基本类型
 * 
 * 优点 : 统一了数据类型 ,减少了类型转换
 * 
 * 缺点 :只能保存同一种类型
 * @author SEC90
 * @Date 2022年1月20日下午3:22:40
 */
public class Map_04_Generic_01 {
	@SuppressWarnings({ "unchecked", "unused" })
	public static void main(String[] args) {
		@SuppressWarnings("rawtypes")
		//没有使用泛型
		List list =  new ArrayList();
		//添加声明类型都行
		list.add(new A());
		//取得时候拿到的是Object
		for (Object object : list){
			//需要进行判断和向下转型才行
			if(object instanceof A){
			A a = (A ) object;
			a.m1();
			}
		}
		//使用泛型 规定 该集合中只能保存A类型
		List<A> list2 = new ArrayList<A>();
		list2.add(new A());
		//添加其他报错,且是编译错误
		//list2.add(2);
		
		//使用的时候 ,拿到的直接就是A类型不会出啊先类型转换异常
		//因为只要能运行就一定有A
		for(A a : list2){
			a.m1();
		}
		//泛型 不能写基本类型 只能写引用类型
		//如果想要保存基本类型 ,则需要编写对应的包装类类型
		//List<int> list 3 = new ArrayList<int>();
		List<Integer> list3 = new ArrayList<Integer>();
		
		//如果 需要保存多种数据 则不需要使用 泛型
		//但是如果需要保存同一种类型数据,则一定要使用泛型,这样方便操作
		
		//set和map使用泛型
		Set<String> set = new HashSet<String>();
		Map<String, Integer> map = new HashMap<String, Integer>();
	}
}

class A{
	public void m1() {
		System.out.println("m1");
	}
}

package _02_Map;
/**
 * 定义泛型 使用大写字母A-Z表示,写什么都一样,都只是占位符而已,只不过 某些字符也有一些特殊的含义
 * 		E: Element 一般表示元素,而集合中的数据 我们叫元素,所以在集合中出现的泛型一般使用E表示
 * 		K: key 表示键
 * 		V: value 表示值 K和V一般在散列表中出现
 * 		T: Type 表示一个java类型
 * 		N: 表示Number
 * 		?: 表示不确定的类型
 * 
 * 如果规定了泛型但是使用的地方没有指定泛型,则默认为Object 类型
 * @author SEC90
 * @Date 2022年1月20日下午3:42:42
 */
public class Map_04_Generic_02 {
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void main(String[] args) {
		//不指定类型,默认Object
		MyClass myClass = new MyClass();
		myClass.m1(1);
		myClass.m1("asdadas");
		//指定类型
		MyClass<String> x = new MyClass<String>();
		x.m1("sadad");
//		x.m1(123);
	}
}
//自定义类型,T就是占位符
class MyClass<T>{
	public void  m1(T o) {
		System.out.println(o);
	}
}

package _02_Map;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

/**
 * Map以Value进行排序
 * 
 * Map 是没有办法按照value排序的 因为源码中写死了 使用key进行排序
 * 
 * 所以只能保存到List数组中进行排序
 * @author SEC90
 * @Date 2022年1月20日下午4:18:45
 */
public class Map_05 {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {
		Map<String, Integer> map = new TreeMap<String, Integer>();
		map.put("b",11);
		map.put("a",21);
		map.put("c",145);
		map.put("d",41);
		map.put("e",15);
		System.out.println(map);
		//把map封装到entry中并保存到set中
		Set set = map.entrySet();
		//把set保存到list中,通过ArrayList的有参构造可以直接把set转换为list
		List<Entry<String, Integer>> list = new ArrayList<Entry<String, Integer>>(set);
		//排序
		Collections.sort(list,new Comparator<Entry<String, Integer>>() {
			@Override
			public int compare(Entry<String, Integer> o1,
					Entry<String, Integer> o2) {
				return o1.getValue()-o2.getValue();
			}
		});
		System.out.println(list);
	}
}