Java基础——Day18——泛型，collections，set，map

Day 18

一、泛型（掌握）

• 参数化数据类型
• 创建类的时候无法确定属性的数据类型，创建对象的时候根据实际需求确定数据类型

package com.qf.test;

import java.util.ArrayList;

public class Demo05 {
	public static void main(String[] args) {
		Student<String,String> stu01 = new Student<String,String>("10010", "张三", 23);
		
		Student<Integer,String> stu02 = new Student<Integer,String>(10011, "李四", 24);
	}
}

class Student<T, K>{
	T id;
	String name;
	int age;
	K gender;
	
	public Student() {
		super();
	}

	public Student(T id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

二、集合工具类Collections（掌握）

• 操作集合的一个工具类
• 提供了翻转，添加，排序，查找等方法

package com.qf.test;

import java.util.ArrayList;
import java.util.Collections;

public class Demo06 {
	public static void main(String[] args) {
		// Collections工具类
		/**
		 * addAll
		 * shuffle
		 * sort
		 * swap
		 * reverse
		 */
		
		ArrayList<String> list = new ArrayList<String>();
		
		// 向指定集合中添加元素
		Collections.addAll(list, "张三","周毅","吴老二","正三");
		
		System.out.println(list);
		
		// 随机排序集合元素
		Collections.shuffle(list);
		System.out.println(list);
		
		ArrayList<String> names = new ArrayList<String>();
		names.add("Tom");
		names.add("Jerry");
		names.add("Poly");
		names.add("Kitty");
		System.out.println(names);
		
		// 排序
		Collections.sort(names);
		System.out.println(names);
		
		Collections.swap(names, 0, names.size()-1);
		System.out.println(names);
		
		// 翻转集合
		Collections.reverse(names);
		System.out.println(names);
		
		for (int i = 0; i < names.size()/2; i++) {
			Collections.swap(names, i, names.size()-i-1);
		}
		System.out.println(names);
	}
}

三、Set集合

• 一个不包含重复元素的 collection。
• 更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。
• 正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

四、HashSet（重点掌握）

4.1 定义

• 此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。
• 它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
• 此类允许使用 null 元素。

4.2 创建对象

HashSet() 
          构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 
HashSet(Collection<? extends E> c) 
          构造一个包含指定 collection 中的元素的新 set。 

package com.qf.set;

import java.util.ArrayList;
import java.util.HashSet;

public class Demo01 {
	public static void main(String[] args) {
		// 阈值 16*0.75
		/**
		 * 	HashSet() 
			          构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 
			HashSet(Collection<? extends E> c) 
			          构造一个包含指定 collection 中的元素的新 set。 
		 */
		// 无序不重复
		HashSet<String> set = new HashSet<String>();
		set.add("赤脚大仙");
		set.add("赤脚大仙");
		set.add("土地公");
		set.add("太上老君");
		set.add("卷帘大将");
		set.add("卷帘大将");
		
		System.out.println(set);
		
		ArrayList<String> list = new ArrayList<String>();
		list.add("司马懿");
		list.add("司马昭");
		list.add("司马炎");
		list.add("司马师");
		list.add("司马光");
		list.add("司马光");
		list.add("司马光");
		System.out.println(list);
		
		HashSet<String> names = new HashSet<String>(list);
		System.out.println(names);
		
		list = new ArrayList<String>(names);
		System.out.println(list);
	}
}

4.3 HashSet去重原理

• 认为重复的条件
  • e1.equals(e2)的结束是true
  • 重写之后计算得到的hashCode值一致
• HashSet添加元素的原理
  • 调用了HashMap的put方法
  • put(e,v)
  • e是我们传入的元素
  • v是统一的值：一个静态常量对象

4.4 常用方法

package com.qf.set;

import java.util.HashSet;

public class Demo03 {
	public static void main(String[] args) {
		HashSet<String> set01 = new HashSet<String>();
		set01.add("马超");
		set01.add("马良");
		set01.add("马岱");
		set01.add("马谡");
		set01.add("马云");
		set01.add("马化腾");
		set01.add("马赛克");
		System.out.println(set01);
	
		// 删除的方法
		System.out.println(set01.remove("马赛克"));
		System.out.println(set01.remove("马赛克"));
		
		// 查看元素个数
		System.out.println(set01.size());
		
		System.out.println(set01.contains("马赛克"));
		System.out.println(set01.contains("马化腾"));
		
		
	}
	
}

4.5 遍历set集合

• 没有下标，无法使用for‘或者while遍历
• 可以使用foreach或者iterator遍历

package com.qf.set;

import java.util.HashSet;
import java.util.Iterator;

public class Demo04 {
	public static void main(String[] args) {
		HashSet<String> set01 = new HashSet<String>();
		set01.add("马超");
		set01.add("马良");
		set01.add("马岱");
		set01.add("马谡");
		set01.add("马云");
		set01.add("马化腾");
		set01.add("马赛克");
		System.out.println(set01);
		
		// 遍历：没有下标，可以使用foreach遍历
		System.out.println("==========foreach===========");
		for (String name : set01) {
			System.out.println(name);
		}
		
		System.out.println("==========iterator===========");
		Iterator<String> it = set01.iterator();
		while (it.hasNext()) {
			String name = it.next();
			System.out.println(name);
		}
	}
}

五、LinkedHashSet（掌握）

• 继承自HashSet
• 但是自己维护了一个链表，记录前一个和后一个元素的信息
• 能保证插入的顺序和迭代的顺序一致

package com.qf.set;

import java.util.LinkedHashSet;

public class Demo05 {
	public static void main(String[] args) {
		LinkedHashSet<String> set = new LinkedHashSet<String>();
		set.add("张默");
		set.add("高虎");
		set.add("宁财神");
		set.add("柯震东");
		set.add("宋冬野");
		set.add("房祖名");
		set.add("宁财神");
		System.out.println(set);
	}
}

六、TreeSet（掌握）

6.1 定义

• set接口的一个实现类
• 集合中的元素能按照自然顺序进行排序
• 集合中的对象需要具有可比较性或者传入比较器

6.2 创建对象

package com.qf.set;

import java.util.TreeSet;

public class Demo06 {
	public static void main(String[] args) {
		// TreeSet集合中的元素默认按照自然顺序排列
		TreeSet<String> set01 = new TreeSet<String>();
		set01.add("Jack");
		set01.add("Rose");
		set01.add("Tom");
		set01.add("Tony");
		set01.add("Mark");
		set01.add("Jack");
		set01.add("Rose");
		set01.add("Tom");
		set01.add("Tony");
		set01.add("Mark");
		
		System.out.println(set01);
		
		TreeSet<Integer> set02 = new TreeSet<Integer>();
		set02.add(110);
		set02.add(11);
		set02.add(220);
		set02.add(78);
		set02.add(110);
		set02.add(11);
		set02.add(220);
		set02.add(78);
		
		System.out.println(set02);
		
		
		TreeSet<Stu> stus = new TreeSet<Stu>();
		stus.add(new Stu("zhangsan", 23));
		stus.add(new Stu("lisi", 22));
		stus.add(new Stu("wangwu", 18));
		stus.add(new Stu("zhaoliu", 26));
		stus.add(new Stu("tianqi", 29));
		
		System.out.println(stus);
	}
}

class Stu{
	String name;
	int age;
	
	public Stu(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Stu [name=" + name + ", age=" + age + "]";
	}
	
}

6.3 定义对象的比较器

• 创建TreeSet时候传入比较器
• 有名字的比较器

package com.qf.set;

import java.util.Comparator;
import java.util.TreeSet;

public class Demo07 {
	public static void main(String[] args) {
		// 创建一个比较器,自定义比较的规则
		Comparator<Students> comparator = new Comparator<Students>() {
			@Override
			public int compare(Students s1, Students s2) {
				int ret = s1.age - s2.age;
				if (ret == 0) {
					ret = s1.name.compareTo(s2.name);
				}
				return -ret;
			}
		};
		
		TreeSet<Students> stus = new TreeSet<Students>(comparator);
		
		stus.add(new Students("zhangsan", 23));
		stus.add(new Students("lisi", 25));
		stus.add(new Students("wangwu", 22));
		stus.add(new Students("zhaoliu", 28));
		stus.add(new Students("tianqi", 28));
		
		System.out.println(stus);
	}
}

class Students{
	String name;
	int age;
	
	public Students(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Students [name=" + name + ", age=" + age + "]";
	}
	
}

• 匿名比较器对象

package com.qf.set;

import java.util.Comparator;
import java.util.TreeSet;

public class Demo09 {
	public static void main(String[] args) {
		// 创建TreeSet对象，传入比较器Comparator匿名对象
		TreeSet<Students> stus = new TreeSet<Students>(new Comparator<Students>() {
			@Override
			public int compare(Students s1, Students s2) {
				int ret = s1.age - s2.age;
				return ret == 0 ? s1.name.compareTo(s2.name) : ret;
			}
		});
		
		stus.add(new Students("zhangsan", 23));
		stus.add(new Students("lisi", 25));
		stus.add(new Students("wangwu", 22));
		stus.add(new Students("zhaoliu", 28));
		stus.add(new Students("tianqi", 28));
		
		System.out.println(stus);
	}
}

• 对象的类实现Comparable接口

package com.qf.set;

import java.util.TreeSet;

public class Demo08 {
	public static void main(String[] args) {
		TreeSet<Person> persons = new TreeSet<Person>();
		persons.add(new Person("zhangsan", 23));
		persons.add(new Person("lisisi", 29));
		persons.add(new Person("wangwu", 33));
		persons.add(new Person("zhaoliu", 13));
		persons.add(new Person("tianqi", 23));
		System.out.println(persons);
	}
}

/**
 * Person类
 * 	实现Comparable接口，重写compareTo方法，自定义比较的规则
 * @author Dushine2008
 *
 */
class Person implements Comparable<Person>{
	String name;
	int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public int compareTo(Person o) {
		return this.age - o.age == 0 ? this.name.compareTo(o.name) : this.age - o.age;
	}
	
}

七、Map（掌握）

7.1 定义

• 双列集合的顶层接口
• 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

7.2 常见实现类

• HashMap
• HashTable
• Properties
• TreeMap
• … …

八、HashMap（重点掌握）

8.1 定义

• 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
• 此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

8.2 创建对象

package com.qf.map;

import java.util.HashMap;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 	HashMap() 
			          构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 
			HashMap(int initialCapacity) 
			          构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 
			HashMap(int initialCapacity, float loadFactor) 
			          构造一个带指定初始容量和加载因子的空 HashMap。 
			HashMap(Map<? extends K,? extends V> m) 
			          构造一个映射关系与指定 Map 相同的新 HashMap。 
		 */
		
		HashMap<String, String> map = new HashMap<String, String>();
		System.out.println(map);
		map.put("zhangsan", "法外狂徒张三");
		map.put("zhangsan", "法外狂徒");
		System.out.println(map);
		
		map.put("lisi", "法外狂徒张三的搭档");
		System.out.println(map);
		
	}
}

8.3 HashMap增删改方法

• put
• remove

package com.qf.map;

import java.util.HashMap;

public class Demo02 {
	public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		// 增加元素
		map.put(10010, "李白，唐朝诗人，浪漫主义豪放派诗人，被后人成为诗仙。");
		map.put(10011, "杜甫，唐朝诗人，现实主义诗人，被后人成为诗圣。");
		map.put(10012, "李贺，唐朝诗人，浪漫主义诗人，被后人成为诗鬼。");
		map.put(10013, "李清照，宋朝诗人，浪漫主义诗人，被后人成为诗鬼。");
		
		System.out.println(map);
		
		// 修改元素
		map.put(10013, "宋朝词人，婉约派词人，有很多诗词传世。");
		System.out.println(map);
		
		// 删除元素
		System.out.println(map.remove(10012));
		System.out.println(map.remove(10012));
		
		System.out.println(map.remove(10013, "宋朝词人，婉约派词人，有很多诗词传世。"));
		
	}
}

8.4 HashMap查询数据方法

• keySet
• values
• get
• containsKey
• containsValue
• size

package com.qf.map;

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

public class Demo03 {
	public static void main(String[] args) {
		HashMap<String, String> map = new HashMap<String, String>();
		map.put("悯农", "锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦。");
		map.put("静夜思", "床前明月光，疑是地上霜。举头望明月，低头思故乡。");
		map.put("望庐山瀑布", "日照香炉生紫烟光，遥看瀑布挂前川。飞流直下三千尺，疑是银河落九天。");
		
		// 查询所有的键
		Set<String> keys = map.keySet();
		System.out.println(keys);
		
		// 查询所有的值
		Collection<String> values = map.values();
		System.out.println(values);
		
		// 查询所有的键值对
		Set<Entry<String,String>> entrys = map.entrySet();
		System.out.println(entrys);
		
		// 查询元素是否存在map中
		System.out.println(map.containsKey("锄禾"));
		System.out.println(map.containsKey("悯农"));
		
		System.out.println(map.containsValue("锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦。"));
		
		// 查询map集合键值对的个数
		System.out.println(map.size());
		
		// 根据键查询键对应的值
		System.out.println(map.get("静夜思"));
		System.out.println(map.get("静夜思000"));
		
	}
}

8.5 遍历map集合（重点重点掌握）

• 通过key遍历
• 通过entry遍历

package com.qf.map;

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

public class Demo03 {
	public static void main(String[] args) {
		HashMap<String, String> map = new HashMap<String, String>();
		map.put("悯农", "锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦。");
		map.put("静夜思", "床前明月光，疑是地上霜。举头望明月，低头思故乡。");
		map.put("望庐山瀑布", "日照香炉生紫烟光，遥看瀑布挂前川。飞流直下三千尺，疑是银河落九天。");
		
		// 查询所有的键
		Set<String> keys = map.keySet();
		System.out.println(keys);
		
		// 查询所有的键值对
		Set<Entry<String,String>> entrys = map.entrySet();
		System.out.println(entrys);
		
		// 通过键遍历map集合
		System.out.println("===============foreach遍历key==============");
		for (String key : keys) {
			System.out.println(key + "=====" + map.get(key));
		}
		
		System.out.println("===============iterator遍历key==============");
		Iterator<String> it = keys.iterator();
		while (it.hasNext()) {
			String key = it.next();
			System.out.println(key + "<<<>>>" + map.get(key));
		}
		
		// 通过键值对遍历集合
		System.out.println("===============foreach遍历entry==============");
		for (Entry<String, String> entry : entrys) {
			System.out.println(entry.getKey() + "=========" + entry.getValue());
		}
		
		System.out.println("===============iterator遍历entry==============");
		Iterator<Entry<String,String>> its = entrys.iterator();
		while(its.hasNext()) {
			Entry<String,String> entry = its.next();
			System.out.println(entry.getKey() + "------------" + entry.getValue());
		}
	}
}