java_day _18_总结

散列表
散列表结构可以理解为数组中保存的是链表的首节点，用来保存k和v键值对操作
hash算法:是一种安全的加密机制，可以把不定长的数据转换为定长数据,并且不能保证其唯一性
k不可重复，V可重复
在java中指的就是hashCode方法对一个对象生成多次hash值,值一-定相同，多个对象也可能生成相同的hash值
添加过程:
1根据要添加的key,调用的它的hashCode方法生成hash值
2通过一定的算法,根据hash值生成数组的下标
3判断该下标中,是否有数据,如果没有数据就把该键值对映射关系保存到数组中.
4如果该下标中,有数据则调用key的equals方法和对应的所有数据进行比较
5如果对应的链表中，通过equals方法比较的时候，发现了相同的数据，那么key不再添加,
但是value值会替换原来的value值通过添加过程得知，会自动调用该对象的hashCode和equals,
所以在保存自定义类型的时候，需要注意方法覆写

基本方法：

public static void main(String[] args) {
		// 元素添加类型必须一致
		Set set = new HashSet();
		// 添加
		set.add(5);
		set.add(4);
		set.add(8);
		set.add(9);
		set.add(1);
		// 不可重复，重复不添加
		set.add(7);
		// 移除值
		set.remove(1);
		// 按照每一位的值排序
		set.add(3);
		// 排序
		System.out.print(set);
		// 遍历
		for (Object object : set) {

		}

泛型: :在编译过程中检测数据类型是否匹配
统一了数据类型。出来的时候自动转换
只能引用类型，不能基本类型
只能保存一种
定义泛型,使用大写字母A- Z表示写什么都一样都只是占位符而已，只不过某些字符也有一些特殊的含义
E : Element -般代表元素,而集合中的数据我们叫元素,所以在集合中出现的泛型一般使用E表示
K: Key表示键
V : value表示值K和V- -般在散列表中出现(Map)
T : Type表示一个java类型
 

public class fanXing_ {
	public static void main(String[] args) {
		// 不加，传出来不知道啥类型，所以要转化才能调用其类的方法
		List list = new ArrayList();
		list.add(new A());
		// 输出不知道啥类 要Object
		for (Object object : list) {
			// 类型转换
			A a = (A) object;
			a.m1();
		}

		// 泛型
		List<A> list2 = new ArrayList<A>();
		// 输入你就得是所规定的类
		list2.add(new A());
		// 输出也就是规定的不要转换
		for (A a1 : list2) {
			a1.m1();
		}
	}

}

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

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

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);
	}

Map是无序的，保存是看K V键值对，k不可以重复，v可以
Hashmap :底层是散列表
Treemap:底 层红黑树，必须按照一定规则排序
 

public static void main(String[] args) {
		// 创建map
		HashMap map = new HashMap();
		// 添加
		map.put("A", "ome");
		map.put("J", "1");
		map.put("G", "o");
		map.put("f", "e");
		// 长度
		System.out.print(map.size());
		// 传入K获取V   
		map.get("A");
		// 判断是否有某值
		map.containsKey("A");
		map.containsValue("1");
		// 删除
		map.remove("a");
		// 把值放到values中，并放到集合
		Collection values = map.values();
		for (Object object : values) {

		}
		// 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) {
			System.out.print(object);
			Entry entry = (Entry) object;
			System.out.print(entry.getKey() + ":" + entry.getValue());
		}

	}

 TreeMap:保存的元素会按照一定规则自动（K）进行排序,底层是红黑树
  Comparable和Comparator 按照k排序

public class Map_02 {
	public static void main(String[] args) {
		// 添加自定义类型,并且 Product中 实现了Comparable接口
		TreeMap map = new TreeMap();
		map.put(new Product("苹果", 5.1), 10);
		map.put(new Product("香蕉", 5.9), 1);
		System.out.println(map);

		System.out.println(map.size());

		// 添加已有类型,且该类型实现了Comparable接口,Integer默认升序
		// 如果 该类型没有实现Comparable接口,或者 我们想要降序,则需要使用Comparator
		TreeMap map1 = new TreeMap(new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				return i2 - i1;
			}
		});
		map1.put(11, "a");
		map1.put(2, "a");
		map1.put(23, "a");
		map1.put(3, "a");
		System.out.println(map1.size());
		System.out.println(map1);
	}
}

class Product implements Comparable {

	private String name;
	private double price;

	public Product(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}

	public String toString() {
		return this.name;
	}

	@Override
	public int compareTo(Object o) {
		// this是要添加的元素
		// o是集合中的元素
		if (o instanceof Product) {
			Product u = (Product) o;
			// 升序
			// return this.age - u.age;
			// 降序
			if (u.price - this.price > 0) {
				return 1;
			} else {
				return -1;
			}
		}
		// 该方法 返回 0 说明重复,不添加
		// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
		// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
		return -1;
	}
}