黑马程序员——java基础学习笔记——第九天

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Map集合

一概述：

Map与Collection在集合框架中属并列存在，Map存储的是键值对，Map存储元素使用put方法，Collection使用add方法，Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素Map集合中键要保证唯一性。

二Map常用方法：

添加、删除操作：

Object put(Object key,Object value)

Object remove(Object key)

void putAll(Mapt)

void clear()

元视图操作的方法：

Set keySet()

Collection values()

Set entrySet()

元素查询的操作：

Object get(Object key)

boolean containsKey(Objectkey)

boolean containsValue(Objectvalue)

int size()

boolean isEmpty()

boolean equals(Object obj)

import java.util.*;
class MapDemo 
{
	public static void main(String[] args) 
	{
		Map map=new HashMap();
		map.put("01","zhangsan1");
		map.put("02","zhangsan1");
		map.put("03","zhangsan1");

		System.out.println("containsKey:"+map.containsKey("02"));
		System.out.println("remove:"+map.remove("02"));
		System.out.println(map);
	}
}

三HashMap：

允许使用null键和null值，与HashSet一样，不保证映射的顺序。

HashMap 判断两个 key 相等的标准是：两个 key 通过 equals()方法返回 true，hashCode 值也相等。

HashMap 判断两个 value相等的标准是：两个 value通过 equals()方法返回 true。

import java.util.*;
class Student implements Comparable
{
	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 MapTest 
{
	public static void main(String[] args) 
	{
		HashMap hm=new HashMap();

		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 keySet=hm.keySet();

		Iterator it=keySet.iterator();

		while(it.hasNext())
		{
			Student stu=it.next();

			String addr=hm.get(stu);
			System.out.println(stu+"..."+addr);
		}*/
		//第二种取出方式entrySet
		Set> entrySet=hm.entrySet();

		Iterator> iter=entrySet.iterator();

		while(iter.hasNext())
		{
			Map.Entry me =iter.next();
			Student stu=me.getKey();
			String addr=me.getValue();
			System.out.println(stu+"......."+addr);
		}
	}
}

四TreeMap：

TreeMap存储 Key-Value对时，需要根据 key-value对进行排序。TreeMap 可以保证所有的Key-Value对处于有序状态。
TreeMap 的 Key 的排序：

自然排序 ：TreeMap 的所有的 Key 必须实现 Comparable接口，而且所有的Key应该是同一个类的对象，否则将会抛出ClasssCastException

定制排序：创建 TreeMap 时，传入一个Comparator对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要Map的 Key 实现 Comparable接口

TreeMap判断 两个 key 相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

若使用自定义类作为TreeMap的key，所属类需要重写equals()和hashCode()方法，且equals()方法返回true时，compareTo()方法应返回0。

五操作集合的工具类：

Collections 是一个操作Set、List 和 Map 等集合的工具类

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

排序操作：（均为static方法）

reverse(List)：反转 List 中元素的顺序

shuffle(List)：对 List集合元素进行随机排序

sort(List)：根据元素的自然顺序对指定List集合元素按升序排序

sort(List，Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序

swap(List，int，int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找、替换：

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素

Object max(Collection，Comparator)：根据 Comparator指定的顺序，返回给定集合中的最大元素

Object min(Collection)

Object min(Collection，Comparator)

int frequency(Collection，Object)：返回指定集合中指定元素的出现次数

void copy(List dest,Listsrc)：将src中的内容复制到dest中

boolean replaceAll(Listlist，ObjectoldVal，ObjectnewVal)：使用新值替换List对象的所有旧值

同步控制：

Collections 类中提供了多个synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

package com.atguigu.java;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.junit.Test;

/*
 * 操作Collection以及Map的工具类：Collections
 * 
 * 面试题：区分Collection与Collections
 * 
 */
public class TestCollections {
	/*
	 *  Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
		Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
		Object min(Collection)
		Object min(Collection，Comparator)
		int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
		void copy(List dest,List src)：将src中的内容复制到dest中
		boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

	 */
	@Test
	public void testCollections2(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(12);
		list.add(78);
		list.add(456);
		Object obj = Collections.max(list);
		System.out.println(obj);
		int count = Collections.frequency(list, 4567);
		System.out.println(count);
		//实现List的复制
		//List list1 = new ArrayList();//错误的实现方式
		List list1 = Arrays.asList(new Object[list.size()]);
		Collections.copy(list1, list);
		System.out.println(list1);
		//通过如下的方法保证list的线程安全性。
		List list2 = Collections.synchronizedList(list);
		System.out.println(list2);
	}
	/*
	 *  reverse(List)：反转 List 中元素的顺序
		shuffle(List)：对 List 集合元素进行随机排序
		sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
		sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
		swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
		
	 */
	@Test
	public void testCollections1(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(12);
		list.add(78);
		System.out.println(list);
		Collections.reverse(list);
		System.out.println(list);
		Collections.shuffle(list);
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
		Collections.swap(list, 0, 2);
		System.out.println(list);
	}
}