day19 集合（二）

1. Map接口

1.1 HashMap

1.1.1 常用方法

put()

remove()

get()

size()

clear()

replace()

package com.qfedu.test1;

import java.util.HashMap;

/**
 * 	Map
 * 	HashMap
 * 
 * 	put()
 * 	remove()
 * 	get()
 * 	size()
 * 	clear()
 * 	replace()
 * @author WHD
 *
 */
public class TestHashMap {
	public static void main(String[] args) {
		HashMap<String,String> map = new HashMap<String,String>();
		
		map.put("CN", "中国");
		map.put("US", "美国");
		map.put("RU", "俄罗斯");
		map.put("KR", "棒子");
		map.put("JP", "小日本");
		
		System.out.println(map.size());
		
		map.replace("JP", "鬼子");
		
		System.out.println(map.get("JP"));
		
		System.out.println("删除了：" + map.remove("JP"));
		
		System.out.println(map.size());
		
		
		map.clear();
		
		System.out.println(map.isEmpty());
		
	}
}

1.1.2 遍历

1.获取所有的键

2.获取所有的值

3.获取所有的键和值的组合

4.获取所有键的迭代器

5.获取所有值的迭代器

6.获取所有的键和值的组合的迭代器

package com.qfedu.test1;

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

/**
 * 	HashMap集合遍历
 * 
 * 	1.获取所有的键
 * 	2.获取所有的值
 * 	3.获取所有的键和值的组合
 * 
 * 	4.获取所有键的迭代器
 * 	5.获取所有值的迭代器
 * 	6.获取所有的键和值的组合的迭代器
 * @author WHD
 *
 */
public class TestHashMap1 {
	public static void main(String[] args) {
		HashMap<String,String> map = new HashMap<String,String>();
		map.put("CN", "中国");
		map.put("US", "美国");
		map.put("RU", "俄罗斯");
		map.put("KR", "棒子");
		map.put("JP", "小日本");
		
		// 方式 1
		Set<String> keySet = map.keySet();
		for(String key : keySet) {
			System.out.println(key + "====" + map.get(key));
		}
		System.out.println("-------------------------------------");
		
		// 方式2 
		Collection<String> values = map.values();
		for(String v : values) {
			System.out.println(v);
		}
		System.out.println("-------------------------------------");
		// 方式3 
		Set<Entry<String, String>> entrySet = map.entrySet();
		for(Entry<String,String> entry : entrySet) {
			System.out.println(entry.getKey() + "===" + entry.getValue());
		}
		System.out.println("-------------------------------------");
		// 方式4
		Iterator<String> it1 = map.keySet().iterator();
		while(it1.hasNext()) {
			String key = it1.next();
			System.out.println(key + "====" +map.get(key));
		}
		System.out.println("-------------------------------------");
		// 方式5
		Iterator<String> it2 = map.values().iterator();
		while(it2.hasNext()) {
			System.out.println(it2.next());
		}
		System.out.println("-------------------------------------");
		// 方式6
		Iterator<Entry<String, String>> it3 = map.entrySet().iterator();
		
		while(it3.hasNext()) {
			Entry<String,String> entry = it3.next();
			System.out.println(entry.getKey() + "===" + entry.getValue());
			// System.out.println(it3.next());
		}
		
		
		
	}
}

1.1.3 数据结构

回顾之前所学习的数据结构

ArrayList：数组 因为有下标 所以查询快 修改快 删除、增加慢

LinkedList：双向链表 因为没有下标 (有序，有序号) 所以 删除、增加快 ，查询快 修改慢

HashMap数据结构：

JDK1.7 数组 + 单向链表

JDK1.8 数组 + 单向链表 + 红黑树

HashMap存放元素过程：根据key所计算出来的hash值，决定当前元素在数组的位置，

如果当前位置没有元素，则直接存放

如果当前位置有元素，则向下延伸为单向链表，如果单向链表的长度超过8，将转换为红黑树

后续链表以后的元素减少到6以下，再将红黑树转换为单向链表

扩容当数组的使用率达到75% 并且集合中的元素个数大于64 扩容2倍

1.2 Hashtable

HashMap 与Hashtable区别？

Hashtable线程安全 初始数组长度11 扩容2倍 + 1

HashMap线程不安全 初始数组长度16 扩容2倍

2. 泛型

泛型：用于规范集合，或者接口，类中的数据类型

泛型书写位置：

类

接口上

形参

返回值

泛型通用的字母：

T Type 类型

E Element 元素

R Return 返回值

P Parameter 参数

K Key 键

V Value 值

package com.qfedu.test4;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

/**
 * 	泛型：用于规范集合，或者接口，类中的数据类型
 * 
 * 	泛型书写位置：
 * 		类
 * 		接口上
 * 		形参
 * 		返回值
 * 
 * 	泛型通用的字母：
 * 	T	Type		类型
 * 	E	Element		元素
 * 	R	Return		返回值
 * 	P	Parameter	参数
 * 	K	Key			键
 * 	V	Value		值
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		A<String> a = new A<String>();
		
		a.m1("abc");
		a.m2();
		
		A<Integer> a1 = new A<Integer>();
		a1.m1(20);
		a1.m2();
		
		
		A<Boolean> a2 = new A<Boolean>();
		a2.m1(false);
		a2.m2();
		
		
		B1 b1 = new B1();
		b1.m1("a");
		B2 b2 = new B2();
		b2.m1(3.14F);
	}
}
class Pet{}

class Dog extends Pet{}

class Penguin extends Pet{}


class TestPet{
	public static void m1(List<? extends Pet> list) {
		
	}
	
	
	public static void m2(Set<? super Dog> set) {
		
	}
	
	
	public static void main(String[] args) {
		ArrayList<Dog> list1 = new ArrayList<Dog>();
		ArrayList<Penguin> list2 = new ArrayList<Penguin>();
		LinkedList<Pet> list3 = new LinkedList<Pet>();
		m1(list1);
		m1(list2);
		m1(list3);
		
		Set<Dog> set1 = new HashSet<Dog>();
		Set<Pet> set2 = new HashSet<Pet>();
		m2(set1);
		m2(set2);
		
	}
	
}

interface C<P,R>{
	R m1(P p);
}

class C1 implements C<String,Integer>{

	@Override
	public Integer m1(String p) {
		return null;
	}
	
}

class C2 implements C<Double,Character>{

	@Override
	public Character m1(Double p) {
		return null;
	}
	
}

class A<T>{
	void m1(T t) {
		System.out.println(t);
	}
	
	
	T m2() {
		return null;
	}
	
	public static <T> void m3(T t) {
		List<T> list = new ArrayList<T>();
	}
	
}

interface B<E>{
	E m1(E e);
}

class B1 implements B<String>{

	@Override
	public String m1(String e) {
		return null;
	}
	
}

class B2 implements B<Float>{

	@Override
	public Float m1(Float e) {
		return null;
	}
	
}

请雅清同学过目！