[Java视频笔记]day16

集合Map:

该集合存储键值对,一对一对往里存,而且要保证键的唯一性。

1.添加

put(Kkey, V value)

putAll(Map<?extends K,? extends V> m)

2.删除

clear()

remove(Object key)

3.判断

containsValue(Object value)

containsKey(Object key)

isEmpty()

4.获取

get(Objectkey)

size()

values()

entrySet()  返回此映射中包含的映射关系的 Set 视图。

keySet()  返回此映射中包含的键的 Set 视图。

Map

|--Hashtable: 底层是哈希表数据结构,不可以存入null键或null值。该集合是线程同步的。JDK 1.0.

|--HashMap:底层是哈希表数据结构,允许存入null键和null值。该集合是不同的。JDK 1.2.效率高。

|--TreeMap:底层是二叉树数据结构,线程不同步,可以用于给map集合中的键进行排序。

和Set很像。其实Set底层就是使用了Map集合。

import java.util.*;

class  day16
{
	public static void main(String[] args)
	{
		Map<String, String> map = new HashMap<String, String>();

		//添加元素,如果出现添加时,出现相同的键,那么后添加的会覆盖原有的
		//键的值,put方法会返回被覆盖的值
		map.put("01", "zhangsan1");//put会返回该键原来的值
		map.put("02", "zhangsan2");
		map.put("03", "zhangsan3");

		System.out.println(map.containsKey("02"));//输出true
		System.out.println(map.remove("02"));//输出zhangsan2
		System.out.println(map);//输出{01=zhangsan1, 03=zhangsan3}

		System.out.println(map.get("023"));//输出null
		System.out.println(map.get("03"));//输出zhangsan3

		//map.put("haha", null);//可以这样写

		//获取map集合中所有的值
		map.values();
		Collection<String>coll = map.values();
		System.out.println(coll);//输出[zhangsan1, zhangsan3]
		System.out.println(map);//输出{01=zhangsan1, 03=zhangsan3}

	}
}

Map集合(不是一个元素,而是所有元素)的两种取出方式

1. Set<K> keySet(): 将map中所有的键存入到Set集合中。因为Set具备迭代器。所以可以用迭代方式取出所有的键,再根据get方法,获取每一个键对应的值。

取出原理:将map集合转成set集合,然后用迭代器取出。

2. Set<Map.Entry<k, v>>entrySet() : 将map集合中的映射关系存入到了set集合中,返回的类型为Map.Entry

第一种方式代码:

import java.util.*;

class  day16
{
	public static void main(String[] args)
	{
		Map<String, String> map = new HashMap<String, String>();
		map.put("01", "zhangsan1");
		map.put("03", "zhangsan3");
		map.put("02", "zhangsan2");
		map.put("04", "zhangsan4");

		//先获取map集合的所有键的Set集合,keySet();
		Set<String> keySet = map.keySet();

		//有了set集合,就可以获取其迭代器
		Iterator<String> it = keySet.iterator();
		while(it.hasNext())
		{
			String key = it.next();

			//有了键就可以通过map集合的get()方法获取其对应的值
			String value = map.get(key);
			System.out.println("key: "+key+" , value: "+value);
		}

	}
}

第二种方式代码:

import java.util.*;

class  day16
{
	public static void main(String[] args)
	{
		Map<String, String> map = new HashMap<String, String>();
		map.put("01", "zhangsan1");
		map.put("03", "zhangsan3");
		map.put("02", "zhangsan2");
		map.put("04", "zhangsan4");

		//将map集合中的映射关系取出,存入到Set集合中
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		Iterator<Map.Entry<String, String>>  it = entrySet.iterator();

		while(it.hasNext())
		{
			Map.Entry<String, String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key+ " : " + value);
		}
	}
}

Map.Entry其实Entry也是一个接口,它是Map接口中的一个内部接口

interface Map
{
	public static interface Entry
	{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}

class HashMap implements Map
{
	class Hahs implements Map.Entry
	{
		public Object getKey(){}
		public Object getValue(){}
	}
}

需求:

每一个学生都有对应的归属地。学生Student, 地址 String.学生属性包括姓名和年龄。

注意:姓名和年龄相同的视为同一个学生。保证学生的唯一性。

1.描述学生

2.定义map容器,将学生作为键,地址作为值,存入。

3.获取map集合中的元素。

import java.util.*;

class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(num == 0)
			return this.name.compareTo(s.name);
		return num;
	}

	public int hashCode()
	{
		return name.hashCode() + age * 34;
	}

	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		Student s = (Student)obj;
		return this.name.equals(s.name) && this.age == s.age;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
}

class  day16
{
	public static void main(String[] args)
	{
		Map<Student, String> hm = new HashMap<Student, String>();
		hm.put(new Student("lisi1", 21), "beijing");
		hm.put(new Student("lisi2", 22), "shanghai");
		hm.put(new Student("lisi3", 23), "nanjing");
		hm.put(new Student("lisi4", 24), "wuhan");

		//第一种取出方式keySet
		Set<Student> keySet = hm.keySet();
		Iterator<Student> it = keySet.iterator();
		while(it.hasNext())
		{
			Student stu = it.next();
			String addr = hm.get(stu);
			System.out.println(stu+"..."+addr);
		}

		//第二种取出方式entrySet
		Set<Map.Entry<Student, String>> entrySet = hm.entrySet();
		Iterator<Map.Entry<Student, String>> itr = entrySet.iterator();
		while(itr.hasNext())
		{
			Map.Entry<Student, String> me = itr.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+"...."+addr);
		}
	}
}

需求:对学生对象的年龄进行升序排序

因为数据是以键值对形式存在的。

所以要使用可以排序的map集合 TreeMap

import java.util.*;

class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(num == 0)
			return this.name.compareTo(s.name);
		return num;
	}

	public int hashCode()
	{
		return name.hashCode() + age * 34;
	}

	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		Student s = (Student)obj;
		return this.name.equals(s.name) && this.age == s.age;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
}

class StuNameComparator implements Comparator<Student>//按照姓名排序
{
	public int compare(Student s1, Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num == 0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		return num;
	}
}

class  day16
{
	public static void main(String[] args)
	{
		TreeMap<Student, String>tm = new TreeMap<Student, String>();
		//如果想按照姓名排序,用比较器的形式
		//TreeMap<Student, String>tm = new TreeMap<Student, String>(new StuNameComparator());
		tm.put(new Student("lisi1", 22), "beijing");
		tm.put(new Student("lisi1", 22), "beijing");//重复的,无效
		tm.put(new Student("lisi2", 23), "shanghai");
		tm.put(new Student("lisi3", 24), "nanjing");
		tm.put(new Student("lisi4", 21), "wuhan");

		Set<Map.Entry<Student, String>> entrySet = tm.entrySet();
		Iterator<Map.Entry<Student, String>> it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<Student, String> me = it.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+"...."+addr);
		}
	}
}

练习:

“sdfgzxcvasdfxcvdf”获取该字符串中的字母出现的个数

希望打印的结果:a(1)c(2)…..

通过结果发现,每一个字母都有对应的次数。说明字母和次数之间有映射关系。

注意了,当发现有映射关系时,可以选择map集合。因为map集合中存放的就是映射关系。

什么时候使用map集合呢?

当数据之间存在映射关系时,就要先想map集合。

思路:

1.将字符串转换成字符数组,因为要对每一个字母进行操作。

2.定义一个map集合,因为打印结果的字母有顺序,所以使用treemap集合。

3.遍历这个字符数组,将每个字母作为键去查map集合。如果返回null,就将该字母和1存入到map集合中,如果返回不是null,说明该字母在map集合已经存在并有对应次数。那么就获取该次数进行自增。然后将该字母和自增后的次数存入到map集合中,覆盖掉原来键所对应的值。

4.将map集合中的数据变成指定的字符串形式返回。

import java.util.*;

class  day16
{
	public static void main(String[] args)
	{
		System.out.println(charCount("aabfdddefff"));
	}

	public static String charCount(String str)
	{
		char[] chs = str.toCharArray();
		TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();

		int count = 0;
		for(int x = 0; x < chs.length; x ++)
		{
			Integer value = tm.get(chs[x]);
			if(value != null)
				count = value;
			count ++;
			tm.put(chs[x], count);
			count = 0;

		}
		//System.out.println(tm);
		StringBuilder sb = new StringBuilder();
		Set<Map.Entry<Character, Integer>> entrySet = tm.entrySet();
		Iterator<Map.Entry<Character, Integer>> it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<Character, Integer> me = it.next();
			Character ch = me.getKey();
			Integer value = me.getValue();
			sb.append(ch+"("+value+")");
		}
		return sb.toString();
	}
}

输出:a(2)b(1)d(3)e(1)f(4)

map扩展知识:

map集合被使用是因为具备映射关系。

“yureban” “01”  “zhangsan”

“yureban” “02”  “lisi”

“jiuyeban” “01”  “wangwu”

“jiuyeban” “02”  “zhaowliu”

一个学校有多个教室,每个教室都有名称。

import java.util.*;

class  day16
{
	public static void main(String[] args)
	{

		HashMap<String, HashMap<String, String>>czbk = new HashMap<String, HashMap<String, String>>();
		HashMap<String, String> yure = new HashMap<String, String>();
		HashMap<String, String> jiuye = new HashMap<String, String>();
		czbk.put("yureban", yure);
		czbk.put("jiuye", jiuye);

		yure.put("01", "zhangsan");
		yure.put("02", "lisi");

		jiuye.put("01", "wangwu");
		jiuye.put("02", "zhaoliu");

		//遍历czbk集合,获取所有的教室
		Iterator<String> it = czbk.keySet().iterator();
		while(it.hasNext())
		{
			String roomName = it.next();
			HashMap<String, String>room = czbk.get(roomName);
			System.out.println(roomName);
			getStudentInfo(room);
		}
	}

	public static void getStudentInfo(HashMap<String, String> roomMap)
	{
		Iterator<String> it = roomMap.keySet().iterator();
		while(it.hasNext())
		{
			String id = it.next();
			String name = roomMap.get(id);
			System.out.println(id+"  :  "+name);
		}
	}
}

“yureban” 封装为Student(“01”  “zhangsan”)

“yureban” Stuent(“02”  “lisi”)

“jiuyeban” Student(“01”  “wangwu”)

“jiuyeban” Student(“02”  “zhaowliu”)

import java.util.*;

class Student
{
	private String id;
	private String name;
	Student(String id, String name)
	{
		this.id =id;
		this.name = name;
	}
	public String toString()
	{
		return  id+"..."+name;
	}
}

class  day16
{
	public static void demo()
	{
		HashMap<String,List<Student>>czbk = new HashMap<String,List<Student>>();
		List<Student> yure = new ArrayList<Student>();
		List<Student> jiuye = new ArrayList<Student>();
		czbk.put("yureban", yure);
		czbk.put("jiuyeban", jiuye);
		yure.add(new Student("01", "zhangsan"));
		yure.add(new Student("02", "zhangsan2"));
		jiuye.add(new Student("01", "zhangsan3"));
		jiuye.add(new Student("02", "zhangsan4"));

		Iterator<String> it = czbk.keySet().iterator();
		while(it.hasNext())
		{
			String roomName = it.next();
			List<Student> room  = czbk.get(roomName);
			System.out.println(roomName);
			getInfos(room);
		}

	}

	public static void getInfos(List<Student> list)
	{
		Iterator<Student> it = list.iterator();
		while(it.hasNext())
		{
			Student s = it.next();
			System.out.println(s);
		}
	}
	public static void main(String[] args)
	{
		demo();
	}
}

输出:

jiuyeban

01...zhangsan3

02...zhangsan4

yureban

01...zhangsan

02...zhangsan2

时间: 2024-10-13 01:13:16

[Java视频笔记]day16的相关文章

一名测试初学者听JAVA视频笔记(一)

搭建pho开发环境与框架图 韩顺平 第一章: No1  关于文件以及文件夹的管理 将生成的文本文档做成详细信息的形式,显示文件修改时间以及文件大小,便于文件查看和管理,也是对于一名IT人士高效能工作的专业素养要求.如下图所示: 为了方便Java文件能够及时正确的找到,需要对电脑进行环境配置,要注意一下四个问题: 1.在硬盘中对所有文件夹进行管理,全部设置.点击,工具 > 查看 2.勾选显示文件及所有文件夹 3.去掉隐藏已知文件拓展名,防止出现类如 xxx .java.java 4.显示文件的完全

[Java视频笔记]day23

网络编程 网络模型:OSI参考模型,TCP/IP参考模型 网络通讯要素:IP地址,端口号,传输协议 IP地址(对应对象 InetAddress) 网络中设备的标识 不易记忆,可用主机名 本地回环地址:127.0.0.1主机名:localhost import java.net.*; class day23 { public static void main(String[] args) throws Exception { InetAddress i = InetAddress.getLocal

[Java视频笔记]day14

为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式. 数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的,集合长度是可变的.数组中可以存储基本对象类型,集合只能存储对象,对象可以不同. 1. add方法的参数类型是Object,以便于接收任意类型对象. 2. 集合中存储的都是对象的引用(地址) 什么是迭代器呢? 其实就是集合的取出元素的方式. 共性方法代码: import java.

[Java视频笔记]day19

字符流的缓冲区 1. 缓冲区的出现提高了对数据的读写效率. 2. 对应类 BufferedWriter BufferedReader 3. 缓冲区要结合流才可以使用 4. 在流的基础上对流的功能进行了增强 缓冲区的出现是为了提高流的操作效率而出现的.所以在创建缓冲区之前,必须要先有流对象. 该缓冲区中提供了一个跨平台的换行符,newLine()方法. BufferedWriter import java.io.*; class day19 { public static void main(St

[Java视频笔记]day18

类 System: 类中的方法和属性都是静态的. out: 代表标准输出,默认是控制台. in: 标准输入,默认是键盘. 描述系统的一些信息. 获取系统属性信息:Properties getProperties(); import java.util.*; class day18 { public static void main(String[] args) { Properties prop = System.getProperties(); //因为Properties是HashTable

[Java视频笔记]day21

操作对象 ObjectInputStream ObjectOutputStream 被操作的对象需要实现Serializable(标记接口,没有方法的接口通常称为标记接口) 把对象存到硬盘上,叫做对象的持久化. 一般情况: import java.io.*; class Person implements Serializable { String name; int age; Person(String name, int age) { this.name = name; this.age =

[Java视频笔记]day20

File类 1. 用来将文件或者文件夹封装成对象 2. 方便对文件与文件夹的属性信息进行操作(流只能操作数据) 3. File对象可以作为参数传递给流的构造函数 File类常见方法: 1. 创建 boolean createNewFile();在指定位置创建文件,如果该文件已经存在,则不创建,返回false.和输出流不一样,输出流对象一建立就创建文件,而且文件已经存在,则覆            盖. boolean mkdir():创建文件夹 boolean mkdirs():创建多级文件夹

[java] 视频笔记

1 命名规则 class命名:第一个字母大写 变量命名:第一个字母小写 包命名:第一个字母小写 2 方法本质:实现方法的复用 3 类是对象的一个模板,对象是类的实例化. 对象也就是实例(Object    instance) 属性也就是成员变量 4 作为面向对象的思维来说,当你考虑一个问题时,不应该考虑第一步该干嘛,第二步该干嘛,这个是面向过程的编程思维,而应该考虑: (1)考虑问题有哪些类和对象: (2)这些类和对象有哪些属性和方法: (3)这些类(对象)之间的关系是什么. 类(对象)之间的关

java视频笔记--------String

String的相关知识点: 1.String 的构造方法: String()  创建一个空内容 的字符串对象. String(byte[] bytes)  使用一个字节数组构建一个字符串对象 String(byte[] bytes, int offset, int length) bytes :  要解码的数组 offset: 指定从数组中那个索引值开始解码. length: 要解码多个元素. String(char[] value)  使用一个字符数组构建一个字符串. String(char[