Day18_集合第四天

1、Map集合成员方法(掌握)

增加功能
V put(K key, V value)	当key在集合中不存在时，添加元素；当key在集合存在时候，替换元素
删除功能
void clear	清除所有键值对数据
V remove(Object key)	根据指定的键删除键值对
判断功能
boolean containsKey(Object key)	判断指定的键是否在集合中存在
boolean containsValue(Object value)	判断指定的值是否在集合中存在
boolean isEmpty	判断集合是否为空
获取功能
Set<Map.Entry<K,V>> entrySet()	键值对对象的集合
Object get(Object key)	根据键获取值
Set<K> keySet()	所有键的集合
Collection<V> values()	所有值的集合
长度
int size()	获取长度

2、Map集合的两种遍历方式(掌握)

创建

Map集合

// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 创建并添加元素
map.put("杨过", "小龙女");
map.put("郭靖", "黄蓉");
map.put("梁山伯", "祝英台");
map.put("牛郎", "织女");

第一种

遍历方式(通过keySet())

Set<String> keySet = map.keySet();
for(String key : keySet){
    System.out.println("key:"+key+"  value"+map.get(key));
}

第二种

遍历方式(通过entrySet())

当一个类或者一个接口被定义到类的成员位置的时候，在其他类中可以直接通过导入包名.外部类名.内部类名来使用。注意：这种方式只能创见引用，不能创建对象

package cn.itcast;

import cn.itcast.Outer.InnerClass;

public class Test {

public static void main(String[] args) {

InnerClass in = new Outer().new InnerClass();

}

Set<Entry<String,String>> entrySet = map.entrySet();
for(Map.Entry<String, String> entry : entrySet){
     System.out.println("key"+entry.getKey()+"
value"+entry.getValue());
}

3、HashMap存储自定义对象实现去重 (将自定义对象存储到Key的位置)(掌握)

需求：需要将自定义对象存储到key的位置，并实现去重功能，怎么办？

解决方案1:使用HashMap(建议)

自定义对象重写hashCode()和equals()方法,并且使用HashMap

解决方案2:使用TreeMap(详见)

方案1：自定义对象实现Comparable 接口,并且重写compareTo方法

方案2：创建TreeMap集合对象时通过TreeMap的构造方法传入一个Comparator对象

4、TreeMap存储自定义对象实现排序 (将自定义对象存储到Key的位置)(掌握)

1、方案1

自定义对象实现Comparable 接口,并且重写compareTo方法

2、方案2

创建TreeMap集合对象时通过TreeMap的构造方法传入一个Comparator对象

5、面试题：HashTable和HashMap区别(掌握)

Hashtable,ConCurrentHashMap

线程安全，效率低，不允许null键和值

HashMap:

线程不安全，效率高，允许null键和值

Hashtable和ConCurrentHashMap都是线程安全的，并且都不能存储null键和null值,ConCurrentHashMap效率更高，推荐在开发中面试中使用,Hashtable一般使用的比较少

6、集合体系-总结(掌握)

注意：只有Vector和HashTable是线程安全的，效率低。

Collection(单列集合)

Map(双列集合)

|--Collection(单列)
  |--List(有序,可重复)
          |--ArrayList
                         底层数据结构是数组，查询快，增删慢。
                         线程不安全，效率高。
        |--Vector
                         底层数据结构是数组，查询快，增删慢。
                    线程安全，效率低。
        |--LinkedList
                         底层数据结构是链表，查询慢，增删快。
                         线程不安全，效率高。
  |--Set(可能无序,肯定唯一)
          |--HashSet
                         底层数据结构是哈希表。
                         线程不安全，效率高。

                         怎么保证唯一性的呢?
                         它依赖两个方法：hashCode()和equals()
                         顺序：
                              首先判断hashCode()值是否相同。
                              同：继续走equals()，看返回值
                                   如果true：就不添加到集合。
                                   如果false：就添加到集合。
                              不同：就添加到集合。
        |--TreeSet
                         底层数据结构是二叉树。
                         线程不安全，效率高。

                         怎么保证唯一性的呢?是根据返回是否是0。
                         怎么保证排序的呢?两种方式
                              自然排序(元素具备比较性)
                                   实现Comparable接口
                              比较器排序(集合具备比较性)
                                   实现Comparator接口

|--Map(双列底层结构是针对键有效，跟值无关)
    |--HashMap
                    底层数据结构是哈希表。
                    线程不安全，效率高。允许null键和值

                    怎么保证唯一性的呢?
                    它依赖两个方法：hashCode()和equals()
                    顺序：
                         首先判断hashCode()值是否相同。
                         同：继续走equals()，看返回值
                              如果true：就不添加到集合。
                              如果false：就添加到集合。
                         不同：就添加到集合。
   |--Hashtable
                    底层数据结构是哈希表。
                    线程安全，效率低。不允许null键和值

                    怎么保证唯一性的呢?
                    它依赖两个方法：hashCode()和equals()
                    顺序：
                         首先判断hashCode()值是否相同。
                         同：继续走equals()，看返回值
                              如果true：就不添加到集合。
                              如果false：就添加到集合。
                         不同：就添加到集合。
   |--TreeMap
                    底层数据结构是二叉树。
                    线程不安全，效率高。

                    怎么保证唯一性的呢?是根据返回是否是0。
                    怎么保证排序的呢?两种方式
                         自然排序(元素具备比较性)
                              实现Comparable接口
                         比较器排序(集合具备比较性)
                              实现Comparator接口

7、案例(掌握)

1、HashMap集合键是Student值是String的案例

2、LinkedHashMap演示(LinkedHashMap特点：可以保证怎么存就怎么取)

3、TreeMap集合键是Student值是String的案例(按照姓名排序)

4、集合嵌套之HashMap嵌套HashMap

5、统计字符中每个字符出现的次数

6、模拟斗地主洗牌和发牌，牌没有排序(了解)

7、Collections案例演示

8、案例代码(掌握)

1、HashMap集合键是Student值是String的案例

/**
学生类
*/
public class Student implements Comparable<Student> {
	private String name;
	private int age;
	public Student() {
		super();
		
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public int compareTo(Student o) {
		int num = this.age - o.age;					//以年龄为主要条件
		return num == 0 ? this.name.compareTo(o.name) : num;
	}
}





/**
测试类
*/
public class Demo5_HashMap {
	/*
	 * * A:案例演示
	 * HashMap集合键是Student值是String的案例
	 * 键是学生对象,代表每一个学生
	 * 值是字符串对象,代表学生归属地
	 */
	public static void main(String[] args) {
		HashMap<Student, String> hm = new HashMap<>();
		hm.put(new Student("张三", 23), "北京");
		hm.put(new Student("张三", 23), "上海");
		hm.put(new Student("李四", 24), "广州");
		hm.put(new Student("王五", 25), "深圳");
		
		System.out.println(hm);
	}
}

2、LinkedHashMap演示(LinkedHashMap特点：可以保证怎么存就怎么取)

package com.heima.map;

import java.util.LinkedHashMap;

public class Demo6_LinkedHashMap {

	/**
	 * @param args
	 * LinkedHashMap可以保证怎么存就怎么取
	 */
	public static void main(String[] args) {
		LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
		lhm.put("张三", 23);
		lhm.put("李四", 24);
		lhm.put("赵六", 26);
		lhm.put("王五", 25);
		
		System.out.println(lhm);
	}

}

3、TreeMap集合键是Student值是String的案例(按照姓名排序)

package com.heima.map;

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

import com.heima.bean.Student;

public class Demo7_TreeMap {

	/**
	 * * A:案例演示
	 * TreeMap集合键是Student值是String的案例
	 */
	public static void main(String[] args) {
		//demo1();
		TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {

			@Override
			public int compare(Student s1, Student s2) {
				int num = s1.getName().compareTo(s2.getName());		//按照姓名比较
				return num == 0 ? s1.getAge() - s2.getAge() : num;
			}
		});
		tm.put(new Student("张三", 23), "北京");
		tm.put(new Student("李四", 13), "上海");
		tm.put(new Student("赵六", 43), "深圳");
		tm.put(new Student("王五", 33), "广州");
		
		System.out.println(tm);
	}

	public static void demo1() {
		TreeMap<Student, String> tm = new TreeMap<>();
		tm.put(new Student("张三", 23), "北京");
		tm.put(new Student("李四", 13), "上海");
		tm.put(new Student("王五", 33), "广州");
		tm.put(new Student("赵六", 43), "深圳");
		
		System.out.println(tm);
	}

}

4、集合嵌套之HashMap嵌套HashMap

package com.heima.map;

import java.util.HashMap;

import com.heima.bean.Student;

public class Demo8_HashMapHashMap {

	/**
	 * * A:案例演示
	 * 集合嵌套之HashMap嵌套HashMap
	 * 
	 * 需求:
	 * 双元课堂有很多基础班
	 * 第88期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
	 * 第99期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
	 * 
	 * 无论88期还是99期都是班级对象,所以为了便于统一管理,把这些班级对象添加到双元课堂集合中
	 */
	public static void main(String[] args) {
		//定义88期基础班
		HashMap<Student, String> hm88 = new HashMap<>();
		hm88.put(new Student("张三", 23), "北京");
		hm88.put(new Student("李四", 24), "北京");
		hm88.put(new Student("王五", 25), "上海");
		hm88.put(new Student("赵六", 26), "广州");
		
		//定义99期基础班
		HashMap<Student, String> hm99 = new HashMap<>();
		hm99.put(new Student("唐僧", 1023), "北京");
		hm99.put(new Student("孙悟空",1024), "北京");
		hm99.put(new Student("猪八戒",1025), "上海");
		hm99.put(new Student("沙和尚",1026), "广州");
		
		//定义双元课堂
		HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
		hm.put(hm88, "第88期基础班");
		hm.put(hm99, "第99期基础班");
		
		//遍历双列集合
		for(HashMap<Student, String> h : hm.keySet()) {		//hm.keySet()代表的是双列集合中键的集合
			String value = hm.get(h);						//get(h)根据键对象获取值对象
			//遍历键的双列集合对象
			for(Student key : h.keySet()) {					//h.keySet()获取集合总所有的学生键对象
				String value2 = h.get(key);
				
				System.out.println(key + "=" + value2 + "=" + value);
			}
		}
		
	}

}

5、统计字符串中每个字符出现的次数

package com.heima.test;

import java.util.HashMap;

public class Test1 {

	/**
	 * * A:案例演示
	 * 需求：统计字符串中每个字符出现的次数
	 * 
	 * 分析:
	 * 1,定义一个需要被统计字符的字符串
	 * 2,将字符串转换为字符数组
	 * 3,定义双列集合,存储字符串中字符以及字符出现的次数
	 * 4,遍历字符数组获取每一个字符,并将字符存储在双列集合中
	 * 5,存储过程中要做判断,如果集合中不包含这个键,就将该字符当作键,值为1存储,如果集合中包含这个键,就将值加1存储
	 * 6,打印双列集合获取字符出现的次数
	 */
	public static void main(String[] args) {
		//1,定义一个需要被统计字符的字符串
		String s = "aaaabbbbbccccccccccccc";
		//2,将字符串转换为字符数组
		char[] arr = s.toCharArray();
		//3,定义双列集合,存储字符串中字符以及字符出现的次数
		HashMap<Character, Integer> hm = new HashMap<>();
		//4,遍历字符数组获取每一个字符,并将字符存储在双列集合中
		for(char c: arr) {
			//5,存储过程中要做判断,如果集合中不包含这个键,就将该字符当作键,值为1存储,如果集合中包含这个键,就将值加1存储
			/*if(!hm.containsKey(c)) {			//如果不包含这个键
				hm.put(c, 1);
			}else {
				hm.put(c, hm.get(c) + 1);
			}*/
			hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
		}
		//6,打印双列集合获取字符出现的次数
		
		for (Character key : hm.keySet()) {				//hm.keySet()代表所有键的集合
			System.out.println(key + "=" + hm.get(key));//hm.get(key)根据键获取值
		}
	}

}

6、模拟斗地主洗牌和发牌，牌没有排序(了解)

package com.heima.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Test3 {

	/**
	 * * A:案例演示
	 * 模拟斗地主洗牌和发牌并对牌进行排序的代码实现
	 * 
	 *  分析:
	 * 1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
	 * 2,洗牌
	 * 3,发牌
	 * 4,看牌
	 */
	public static void main(String[] args) {
		//1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
		String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
		String[] color = {"红桃","黑桃","方片","梅花"};
		HashMap<Integer, String> hm = new HashMap<>();					//存储索引和扑克牌
		ArrayList<Integer> list = new ArrayList<>();					//存储索引
		int index = 0;
		
		//拼接扑克牌并索引和扑克牌存储在hm中
		for(String s1 : num) {											//获取数字
			for(String s2 : color) {									//获取颜色
				hm.put(index, s2.concat(s1));
				list.add(index);										//将索引0到51添加到list集合中
				index++;
			}
		}
		//将小王添加到双列集合中
		hm.put(index, "小王");
		list.add(index);												//将52索引添加到集合中
		index++;
		hm.put(index, "大王");
		list.add(index);												//将52索引添加到集合中
		
		//2,洗牌
		Collections.shuffle(list);
		//3,发牌
		TreeSet<Integer> gaojin = new TreeSet<>();
		TreeSet<Integer> longwu = new TreeSet<>();
		TreeSet<Integer> me = new TreeSet<>();
		TreeSet<Integer> dipai = new TreeSet<>();
		
		for(int i = 0; i < list.size(); i++) {
			if(i >= list.size() - 3) {
				dipai.add(list.get(i));							//将三张底牌存储在底牌集合中
			}else if(i % 3 == 0) {
				gaojin.add(list.get(i));
			}else if(i % 3 == 1) {
				longwu.add(list.get(i));
			}else {
				me.add(list.get(i));
			}
		}
		
		//看牌
		lookPoker(hm, gaojin, "高进");
		lookPoker(hm, longwu, "龙五");
		lookPoker(hm, me, "冯佳");
		lookPoker(hm, dipai, "底牌");
	}
	/*
	 * 看牌
	 * 1,返回值类型void
	 * 2,参数列表HashMap,TreeSet,String name
	 */
	public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts ,String name) {
		System.out.print(name + "的牌是:");
		for(Integer i : ts) {						//i代表双列集合中的每一个键
			System.out.print(hm.get(i) + " ");
		}
		System.out.println();
	}
}

7、Collections案例演示

package com.heima.collections;

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

public class Demo1_Collecitons {

	/**
	 * 	Collecitons中的常见方法
	 * 	public static <T> void sort(List<T> list)
		public static <T> int binarySearch(List<?> list,T key)
		public static <T> T max(Collection<?> coll)
		public static void reverse(List<?> list)
		public static void shuffle(List<?> list)
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("c");
		list.add("d");
		list.add("g");
		list.add("f");
		//System.out.println(Collections.max(list)); 			//根据默认排序结果获取集合中的最大值
		//Collections.reverse(list);							//反转集合
		Collections.shuffle(list);								//随机置换,可以用来洗牌
		System.out.println(list);
	}

	public static void demo2() {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("c");
		list.add("d");
		list.add("f");
		list.add("g");
		
		System.out.println(Collections.binarySearch(list, "c"));
		System.out.println(Collections.binarySearch(list, "b"));
	}

	public static void demo1() {
		ArrayList<String> list = new ArrayList<>();
		list.add("c");
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("d");
		
		System.out.println(list);
		Collections.sort(list);						//将集合排序
		System.out.println(list);
	}

}

9、今天必须掌握的内容，面试题，笔试题。

1、HashMap中添加学生，姓名作为键，学生对象作为值，使用两种方式遍历

2、Hashtable和HashMap的区别

3、说说集合体系，最后那个大的总结背回

4、统计字符串中每个字符出现的次数

5、定义map<String,Integer>集合，集合中存储的元素：{"zhangsan",23}{"lisi",24}遍历集合中的元素，将key="张三"

6、有类似这样的字符串："1.2,3.4,5.6,7.8,5.56,44.55,5.4"请按照要求，依次完成以下试题。

	 * (1)以逗号作为分隔符，把已知的字符串分成一个String类型的数组，数组中的每一个元素类似于"1.2","3.4"这样的字符串

* (2)把数组中的每一个元素以

	 * "."作为分隔符，把"."左边的元素作为key，右边的元素作为value，封装到Map中，Map中的key和value都是Object类型。

* (3)把map中的key封装的Set中，并把Set中的元素输出。

* (4)把map中的value封装到Collection中，把Collection中的元素输出。

来自为知笔记(Wiz)

Day18_集合第四天的更多相关文章

Java List集合遍历四种方式（包含 Lambda 表达式遍历）
示例代码如下: package com.miracle.luna.lambda; import java.util.ArrayList; import java.util.List; /** * @A ...
Java中的集合(十四) Map的实现类LinkedHashMap
Java中的集合(十四) Map的实现类LinkedHashMap 一.LinkedHashMap的简介 LinkedHashMap是Map接口的实现类,继承了HashMap,它通过重写父类相关的方法 ...
Java中的集合（四）PriorityQueue常用方法
Java中的集合(四)PriorityQueue常用方法 PriorityQueue的基本概念等都在上一篇已说明,感兴趣的可以点击 Java中的集合(三)继承Collection的Queue接口查看 ...
Java中Map集合的四种访问方式(转)
最近学习Java发现集合类型真是很多,访问方式也很灵活,在网上找的方法,先放下备用 public static void main(String[] args) { Map<String, St ...
Map集合的四种遍历方式
很久以前写的代码,和上一个做比较吧!便于以后查看 import java.util.HashMap; import java.util.Iterator; import java.util.Map; ...
Map集合的四种遍历
Map集合遍历 Map<String,Integer> m = new HashMap<String,Integer>(); m.put("one",100 ...
集合（四）HashMap
之前的List,讲了ArrayList.LinkedList,最后讲到了CopyOnWriteArrayList,就前两者而言,反映的是两种思想: (1)ArrayList以数组形式实现,顺序插入.查 ...
Map集合的四种遍历方式(转载)
import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class TestMap { pu ...
Java集合系列(四)：HashMap、Hashtable、LinkedHashMap、TreeMap的使用方法及区别
本篇博客主要讲解Map接口的4个实现类HashMap.Hashtable.LinkedHashMap.TreeMap的使用方法以及三者之间的区别. 注意:本文中代码使用的JDK版本为1.8.0_191 ...

随机推荐

python collections defaultdict
class_counts = defaultdict(int) 一.关于defaultdict 在Python里面有一个模块collections,解释是数据类型容器模块.这里面有一个collect ...
java高薪之路__002_异常处理
自定义异常 package learn.JavaBasics.Class; import java.util.Date; /** * 如何自定义一个异常类 * 1. 继承一个现有的异常类 * 2. 提 ...
正则神器，RegexBuddy
解释转换测试匹配使用帮助正则图书馆转为PHP案例功能强大,虽然是英文的!挺不错的~
[分享] 晒一晒我的Windows7_SP1封装母盘（多图，附部分工具）,老鸟飘过~
[分享] 晒一晒我的Windows7_SP1封装母盘(多图,附部分工具),老鸟飘过~ 大宝贝1 发表于 2012-8-9 18:01:57 https://www.itsk.com/thread-20 ...
python爬虫（1）
了解python的基本语法后就可以开始了,边学边巩固. 学爬虫那什么是网络爬虫,以下是百度百科的定义:网络爬虫(又被称为网页蜘蛛,网络机器人, 在FOAF社区中间,更经常的称为网页追逐者),是一种按照 ...
python的函数及参数
函数式编程最重要的是增强代码的重用性和可读性 def 函数名(参数): ... 函数体 ... 函数的定义主要有如下要点: def:表示函数的关键字函数名:函数的名称,日后根据函数名调用函数函数体 ...
linux下mysql函数的详细案列
MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host, const char *user, const char *pas ...
【必备】史上最全的浏览器 CSS & JS Hack 手册(转)
浏览器渲染页面的方式各不相同,甚至同一浏览器的不同版本(“杰出代表”是 IE)也有差异.因此,浏览器兼容成为前端开发人员的必备技能.如果有一份浏览器 Hack 手册,那查询起来就方便多了.这篇文章就向 ...
c#网络通信框架networkcomms内核解析之九自定义处理方法的运行机制
NetworkComms网络通信框架序言本文基于networkcomms2.3.1开源版本 gplv3协议我们自己写的处理方法都称之为自定义处理方法比如,我们在服务器上写的与登陆相关的处理方法 ...
C#微信开发-微信JS-SDK（1）之通过config接口注入权限验证配置
官方文档是微信JS-SDK的使用步骤http://mp.weixin.qq.com/wiki/7/aaa137b55fb2e0456bf8dd9148dd613f.html#JSSDK.E4.BD.B ...

Day18_集合第四天

Day18_集合第四天的更多相关文章

随机推荐

热门专题