黑马程序员——Java基础--集合(五)

原创 2015年07月06日 21:56:30

-----------android培训java培训、java学习型技术博客、期待与您交流!------------

第五讲 Map
一、概述
        存储的是俩个对象,映射键值对(a 1-->键a映射到值1), 键是唯一的,一对一的关系,Map<K,V> K 键的泛型 V值的泛型,将键值对存储到集合中put(K,V),put方法没有返回值,返回值数据类型是V类型,格式: V put(K,V),返回值的意思,存储了重复键,值就会被覆盖,put返回被覆盖之前的值。
        获取格式: V get(K),根据键获取值,没有这个键,返回null
        Map中的接口方法:
        boolean containsKey(K)判断集合中有么有这个键;
        boolean containsValue(V)判断集合中有么有这个值;
        Collection values() 将Map中的所有值存储到Collection集合
二、迭代方式
1、keySet方式
必须依赖于Set集合。Map接口中,keySet();将Map集合中所有的键存储到Set集合中,迭代Set集合,Map中的键,根据迭代Set的结果来,获取Map中的值。
实现步骤:
        1、调用Map中接口方法keySet,存储到Set集合。Set(K)
        2、迭代Set结合
        3、获取出来的就是Map中所有的键
        4、使用Map接口方法get通过键获取值
应用举例
package cn.itheima.map;

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

/*
 * keySet方法
 * 步骤:
 * 1、调用Map中接口方法keySet,存储到集合Set
 * 2、迭代Set集合
 * 3、获取出来的是Map中所有的键
 * 4、用Map中get方法通过键获取值
 */
public class KeySetDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("zhangsan", "beijing");
		map.put("lisi", "shanghai");
		map.put("wangwu", "tianjing");
		map.put("zhaoliu", "chongqing");
		//调用Map中接口方法keySet,存储到集合Set
		Set<String> set = map.keySet();
		//迭代Set集合
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			//获取出来的是Map中所有的键
			String next = it.next();
			//用Map中get方法通过键获取值
			System.out.println(next+"----"+map.get(next));
		}
	}
}
结果为:
zhaoliu----chongqing
wangwu----tianjing
lisi----shanghai
zhangsan----beijing
2、ntrySet方式
实现步骤:
        1、Map集合方法entrySet,将键值对映射对象Entry存储到Set结合
        2、迭代Set集合
        3、Set集合存储的是Entry接口的实现类对象
        4、利用Entry接口实现类对象的方法getKey getValue
应用举例:
package cn.itheima.map;

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

/*
 * entrySet方式 
 * 1、用Map的entrySet方式存储到Set集合
 * 2、迭代Set集合
 * 3、Set集合存储的是Entry接口的实现类对象
 * 4、利用Entry接口实现类对象的方法getKey getValue
 */
public class EntrySetDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("zhangsan", "beijing");
		map.put("lisi", "shanghai");
		map.put("wangwu", "tianjing");
		map.put("zhaoliu", "chongqing");
		//用Map的entrySet方式存储到Set集合
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		//迭代Set集合
		Iterator<Map.Entry<String, String>> it = entrySet.iterator();
		while(it.hasNext()){
			Map.Entry<String, String> next = it.next();
			String key = next.getKey();
			String value = next.getValue();
			System.out.println(key+"-----"+value);
		}
	}
}

结果为:
zhaoliu-----chongqing
wangwu-----tianjing
lisi-----shanghai
zhangsan-----beijing
三、HashMap
        底层数据结构,线程不安全呢,运行速度快,允许存储null值,null键,保证唯一性,重写HashCode和equals方法,增强for不能直接遍历Map,可以间接遍历。
举例:
学生类
package cn.itheima.hashmap;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	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 + "]";
	}
}

测试类
package cn.itheima.hashmap;

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

/*
 * 案例 HashMap存储自定义对象,并两种方式迭代,自定义对象当作键
 * 
 */
public class HashMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<Student, String> map = new HashMap<Student, String>();
		//添加元素到集合
		map.put(new Student("zhangsan", 20), "beijing");
		map.put(new Student("lisi", 19), "shanghai");
		map.put(new Student("wangwu", 22), "tianjing");
		//调方法
		keySet(map);
		System.out.println("-------------------------");
		entrySet(map);
	}
	public static void keySet(Map<Student, String> map){
		//调用Map的keySet方法存储到Set集合中
		Set<Student> ks = map.keySet();
		//迭代
		Iterator<Student> it = ks.iterator();
		while(it.hasNext()){
			Student next = it.next();
			System.out.println(next+"----"+map.get(next));
		}
	}
	public static void entrySet(Map<Student, String> map){
		//调用Map的entrySet方法存储到Set集合中
		Set<Map.Entry<Student, String>> es = map.entrySet();
		//迭代
		Iterator<Map.Entry<Student, String>> it = es.iterator();
		while(it.hasNext()){
			Map.Entry<Student, String> next = it.next();
			Student key = next.getKey();
			String value = next.getValue();
			System.out.println(key+"----"+value);
		}
	}
}

结果:
Student [name=wangwu, age=22]----tianjing
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing
-------------------------
Student [name=wangwu, age=22]----tianjing
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing

四、TreeMap
       底层结果红黑树,对存储(键)的对象进行排序,线程不安全,运行速度快。其排序方式有自然排序和比较器排序。
举例:TreeMap存储自定义对象,并两种方式迭代,自定义对象当作键。
学生类
package cn.itheima.treemap;

public class Student implements Comparable<Student>{
	private String name;
	private int age;
	public int compareTo(Student s) {
		//姓名为主要比较条件
		int num = this.name.compareTo(s.name);
		return num==0?this.age-s.age:num;
	}
	public int hashCode() {
		return this.name.hashCode()+this.age*31;
	}
	public boolean equals(Object obj) {
		if (obj==null) {
			return false;
		}if(this==obj){
			return true;
		}if(obj instanceof Student){
			Student s = (Student)obj;
			return this.name.equals(s.name)&&this.age==s.age;
		}
		return false;
	}

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	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 + "]";
	}


}
比较器
package cn.itheima.treemap;

import java.util.Comparator;

public class MyComparator implements Comparator<Student> {

	public int compare(Student s1, Student s2) {
		//比较年龄主要条件
		int age = s1.getAge()-s2.getAge();
		return age==0?s1.getName().compareTo(s2.getName()):age;
	}
}

测试类
package cn.itheima.treemap;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import cn.itheima.treemap.Student;


/*
 *  案例 TreeMap存储自定义对象,并两种方式迭代,自定义对象当作键
 * 
 */
public class TreeMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		TreeMap<Student,String> map = new TreeMap<Student, String>(new MyComparator());
		//添加元素到集合
		map.put(new Student("zhangsan", 20), "beijing");
		map.put(new Student("lisi", 19), "shanghai");
		map.put(new Student("wangwu", 22), "tianjing");
		keySet(map);
	}
	public static void keySet(TreeMap<Student, String> map){
		Set<Student> ks = map.keySet();
		Iterator<Student> it = ks.iterator();
		while(it.hasNext()){
			Student next = it.next();
			System.out.println(next+"----"+map.get(next));
		}
	}
}

结果为:
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing
Student [name=wangwu, age=22]----tianjing

五、Map集合嵌套(俩种方式)
package cn.itheima.mapqiantao;

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

/*
 * Map嵌套
 * 	分析:
 * 	1、Java班分为基础班和就业班
 *  2、基础班有学生信息 学号"001" "张三" "002" "李四"
 *  3、就业班有学生信息 学号"001" "王五" "002" "赵六"
 *  4、Java班是一个集合,存储班级
 *  5、基础班和就业班分别是一个集合存储学生信息
 * 
 */
public class MapMapTest {
	public static void main(String[] args) {
		//创建Java班级集合
		Map<String, Map<String, String>> map = new HashMap<String, Map<String,String>>();
		//创建基础班集合
		Map<String, String> jichu = new HashMap<String, String>();
		Map<String, String> jiuye = new HashMap<String, String>();
		//添加元素到基础班和就业班集合中
		jichu.put("001", "张三");
		jichu.put("002", "李四");
		jiuye.put("001", "王五");
		jiuye.put("002", "赵六");
		//将班级集合添加到Java班级集合中
		map.put("基础班", jichu);
		map.put("就业班", jiuye);
		//调方法
		keySet(map);
		System.out.println("-------------------");
		entrySet(map);
	}
	//keySet方法
	public static void keySet(Map<String, Map<String, String>> map){
		//调用Map中keySet方法存储到Set集合中
		Set<String> ks = map.keySet();
		Iterator<String> it = ks.iterator();
		while(it.hasNext()){
			//next获取的Map 中的键,班级名字
			String next = it.next();
			//集合方法get获取值,值是一个集合,集合存储的是学生信息
			Map<String, String> map2 = map.get(next);
			//调用Map2中keySet方法存储到Set集合中
			Set<String> ks2 = map2.keySet();
			Iterator<String> it2 = ks2.iterator();
			while(it2.hasNext()){
				//next2获取的Map2 中的键,学生学号
				String next2 = it2.next();
				System.out.println(next+"----"+next2+"----"+map2.get(next2));
			}
		}
	}
	//entrySet方法
	public static void entrySet(Map<String, Map<String, String>> map){
		//调用Map中entrySet方法存储到Set集合中
		Set<Map.Entry<String, Map<String, String>>> entrySet = map.entrySet();
		Iterator<Map.Entry<String, Map<String, String>>> it = entrySet.iterator();
		while(it.hasNext()){
			//next获取的Map 中的键,班级名字
			Map.Entry<String, Map<String, String>> next = it.next();
			//键是班级名字
			String key = next.getKey();
			//值,是存储学生信息的班级集合
			Map<String, String> map2 = next.getValue();
			//调用Map2中entrySet方法存储到Set集合中
			Set<Map.Entry<String, String>> entrySet2 = map2.entrySet();
			Iterator<Map.Entry<String, String>> it2 = entrySet2.iterator();
			while(it2.hasNext()){
				//班级集合迭代器 next方法,获取到的是班级集合的键值对关系对象Entry
				Map.Entry<String, String> next2 = it2.next();
				//Entry方法getKey  getValue获取键值对,键是学号,值就是姓名
				String key2 = next2.getKey();
				String value = next2.getValue();
				System.out.println(key+"----"+key2+"----"+value);
			}
		}
	}
}

结果为:
就业班----001----王五
就业班----002----赵六
基础班----001----张三
基础班----002----李四
-------------------
就业班----001----王五
就业班----002----赵六
基础班----001----张三
基础班----002----李四

-----------android培训java培训、java学习型技术博客、期待与您交流!------------






版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

黑马程序员——java基础---集合(第14天)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流----- 集合 一、概述 1、为什么会出现这个多余的容器呢? 因为每一个容器对数据的存储方式有所不同。 这个...

黑马程序员——java基础知识之泛型、集合(Map、工具类等)

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- (一)、泛型

黑马程序员——java基础--集合(篇一)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一、集合框架 二、List 三、set 四、泛型   一、集合框架 1,集...

黑马程序员——java基础---集合--Collection

——— android培训、java培训、期待与您交流! ———理解集合所谓集合,就是存储对象的容器。集合类似于数组,两者的区别在于,数组在定义时就设置了长度,长度是不可变的。集合是可变长度的,不需要...

黑马程序员——JAVA基础------集合框架(四)----Map集合

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! —— 一、Map接口 public interface Map 将键映射到值的对象,一个映射不能包含重复的键;...

黑马程序员——JAVA基础------集合框架(二)----Set接口

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——一、Set接口1 、 Set 接口public interface Set extends Collection一 ...

黑马程序员——java基础(集合框架、泛型)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 第九章:java基础(集合框架、泛型)   本章概述: 第一部分:集合框架 第二部分:集合框...

黑马程序员——JAVA基础拾遗之泛型和集合框架(二)

泛型 JDK1.5以后出现的新特性,用于解决安全问题,是个类型安全机制, 先看以下的代码         ArrayList l = new ArrayList();         ...

黑马程序员——java基础知识之集合框架(容器)

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- 1、为什么出现集合框架? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进...

黑马程序员——Java基础---集合类(上)

------- android培训、java培训、期待与您交流! ---------- 集合类知识目录: 一、集合概述 1、对象数组的概述和使用 2、对象数组的内存(图解) 3、集合的由...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)