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 ...

随机推荐

Cheatsheet: 2015 08.01 ~ 08.31
Java Beginner's Guide to MVC with Spring Framework Exploring the Spring Web MVC for Web Application ...
How To Use DBLink In Oracle Forms 6i
You want to connect multiple databases in oracle forms to perform certain tasks, for example you nee ...
关于F12的有效利用
1.之前仅用F12查看页面的代码: 2.现在发现用F12可以查看css文件: 3.比如看到页面背景为黑色,然后在css里面把背景从黑色调成白色:
Linux用户与“最小权限”原则
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 作为一个Linux用户来说,我们并不需要特别关心下面的机制.但是,当我们去编写一个 ...
bzoj 4415: [Shoi2013]发牌
4415: [Shoi2013]发牌 Time Limit: 10 Sec Memory Limit: 256 MBSubmit: 173 Solved: 124[Submit][Status][ ...
Export Data from mysql Workbench 6.0
原文地址:export-data-from-mysql-workbench-6-0 问题描述 I'm trying to export my database, using MySQL Workben ...
[分享] RT7LITE精简后无法封装解决办法
eagleonly 发表于 2016-6-9 11:00:01 https://www.itsk.com/forum.php?mod=viewthread&tid=368090&hi ...
MAC air 安装redis-3.0.6
redis版本: p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 16.0px Menlo; color: #c33720; background-colo ...
JSP常见指令
JSP常见指令标签: jspincludeservletjavaappletarchive 2011-11-07 20:07 13193人阅读评论(3) 收藏举报版权声明:本文为博主原创文章, ...
[强连通分量] POJ 1236 Network of Schools
Network of Schools Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 16803 Accepted: 66 ...

Day18_集合第四天

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

随机推荐

热门专题