黑马程序员（Java）---API之集合（Map及其子类、Collections）

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

5.4 Map及其子类

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。Collection集合存储元素是单独出现的，Collection的子类Set是唯一的，List是可重复的。

Map集合的数据结构值针对键有效，跟值无关。Collection集合的数据结构是针对元素有效。

Map

|--HashMap

|--TreeMap

5.4.1 Map

1、Map的常用方法

1）添加功能

V put(K key,V value): 如果键是第一次存储，就直接存储键和值，返回null。如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值

2）删除功能

void clear():移除所有的键值对元素

V remove(Object key)：根据键删除键值对元素，并把值返回

3）判断功能

boolean containsKey(Object key)：判断集合是否包含指定的键

boolean containsValue(Object value):判断集合是否包含指定的值

boolean isEmpty()：判断集合是否为空

4）获取功能

V get(Object key):根据键获取值

Set<K> keySet():获取集合中所有键的集合

Collection<V> values():获取集合中所有值的集合

示例1:

import java.util.HashMap;
import java.util.Map;

public class MapDemo {
	public static void main(String[] args) {
		// 创建集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 添加元素
		// V put(K key,V value):添加元素。
		System.out.println("put:" + map.put("文章", "马伊琍"));
		System.out.println("put:" + map.put("文章", "姚笛"));

		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "昆凌");
		map.put("刘恺威", "杨幂");

		// V remove(Object key)：根据键删除键值对元素，并把值返回
		System.out.println("remove:" + map.remove("黄晓明"));
		System.out.println("remove:" + map.remove("黄海波"));

		// 输出集合名称
		System.out.println("map:" + map);

		// void clear():移除所有的键值对元素
		map.clear();
		System.out.println("map:" + map);
	}
}

运行结果：

示例2：

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

public class MapDemo2 {
	public static void main(String[] args) {
		//创建集合
		Map<String,String> map = new HashMap();

		//创建元素并添加
		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "昆凌");
		map.put("刘恺威", "杨幂");

		//V get(Object key):根据键获取值
		System.out.println("get:"+map.get("周杰伦"));
		System.out.println("-----------");

		//Set<K> keySet():获取集合中所有键的集合
		Set<String> set = map.keySet();
		System.out.println("keySet:"+set);
		for(String key:set){
			System.out.println(key);
		}
		System.out.println("-----------");

		//Collection<V> values():获取集合中所有值的集合
		Collection<String> c = map.values();
		System.out.println("values:"+c);
		for(Iterator<String> it = c.iterator();it.hasNext();){
			String value = it.next();
			System.out.println(value);
		}
	}
}

运行结果：

2、 Map集合的遍历

方式1：

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

/*
 * Map集合的遍历
 *
 * 思路：
 * 		A:获取所有的键
 * 		B:遍历键的集合，获取得到每一个键
 * 		C:根据键去找值
 *
 */
public class MapDemo3 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();

		//创建并添加到集合
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("陈玄风","梅超风");

		//遍历
		//获取所有的键
		Set<String> set = map.keySet();
		//遍历键的集合
		for(String key:set){
			String value = map.get(key);
			System.out.println(key+"---"+value);
		}
	}
}

运行结果：

方式2：

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

/*
 * Map集合的遍历
 *
 * 思路：
 * 		A:获取所有键值对对象的集合
 * 		B:遍历键值对对象的集合，得到每一个键值对对象
 * 		C:根据键值对对象获取键和值
 *
 * Set<Map.Entry<K,V>> entrySet():返回键值对对象的集合
 */
public class MapDemo4 {
	public static void main(String[] args) {
		// 创建集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 创建并添加到集合
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("陈玄风", "梅超风");

		//获取所有键值对对象的集合
		Set<Map.Entry<String,String>> set = map.entrySet();
		//遍历键值对对象的集合，得到每一个键值对对象
		for(Map.Entry<String, String> me:set){
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key+"---"+value);
		}
	}
}

运行结果：

5.4.2 HashMap

HashMap:是基于哈希表的Map接口实现。哈希表的作用是用来保证键的唯一性的。

1、HashMap的使用示例

示例1：

import java.util.HashMap;
import java.util.Set;

public class HashMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<String,String> hm = new HashMap<String,String>();

		//创建元素并添加元素
		hm.put("it001", "马云");
		hm.put("it002", "马化腾");
		hm.put("it003", "乔布斯");
		hm.put("it004", "张朝阳");
		hm.put("it005", "求伯君");
		hm.put("it001", "比尔盖茨");

		//遍历
		Set<String> set = hm.keySet();
		for(String key:set){
			String value = hm.get(key);
			System.out.println(key+"---"+value);
		}
	}
}

运行结果：

示例2：

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap<Student，String>
 */
public class 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 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;
	}

}

public class HashMapDemo3 {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<Student,String> hm = new HashMap<Student,String>();

		//创建学生对象
		Student s1 = new Student("周星驰",58);
		Student s2 = new Student("林志玲",43);
		Student s3 = new Student("梁朝伟",54);
		Student s4 = new Student("刘亦菲",50);

		//添加元素
		hm.put(s1,"香港");
		hm.put(s2,"台湾");
		hm.put(s3,"香港");
		hm.put(s4,"台湾");

		//遍历
		Set<Student> set = hm.keySet();
		for(Student key:set){
			String value = hm.get(key);
			System.out.println(key.getName()+"---"+key.getAge()+"---"+value);
		}
	}
}

运行结果：

示例3：

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap<Student,String>
 * 键：Student
 * 		要求：如果两个对象的成员变量值都相同，则视为同一对象
 * 值：String
 */

public class 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 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;
	}
}

public class HashMapDemo4 {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<Student,String> hm = new HashMap<Student,String>();

		//创建学生对象
		Student s1 = new Student("貂蝉",27);
		Student s2 = new Student("王昭君",30);
		Student s3 = new Student("西施",33);
		Student s4 = new Student("杨玉环",35);
		Student s5 = new Student("貂蝉",27);

		//添加元素
		hm.put(s1, "三国");
		hm.put(s2, "汉朝");
		hm.put(s3, "越国");
		hm.put(s4, "唐朝");
		hm.put(s5, "三国时期");

		//遍历
		Set<Student> set = hm.keySet();
		for(Student key:set){
			String value = hm.get(key);
			System.out.println(key.getName()+"---"+key.getAge()+"---"+value);
		}
	}
}

运行结果：

2、LinkedHashMap

LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。由哈希表保证键的唯一性，由链表保证键盘的有序(存储和取出的顺序一致)

示例：

import java.util.LinkedHashMap;
import java.util.Set;

/*
 * LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
 * 由哈希表保证键的唯一性
 * 由链表保证键盘的有序(存储和取出的顺序一致)
 */
public class LinkedHashMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		LinkedHashMap<String,String> hm = new LinkedHashMap<String,String>();
		//创建并添加元素
		hm.put("2345", "hello");
		hm.put("1234", "world");
		hm.put("3456", "java");
		hm.put("1234", "javaee");
		hm.put("3456", "android");
		//遍历
		Set<String> set = hm.keySet();
		for(String key:set){
			String value = hm.get(key);
			System.out.println(key+"---"+value);
		}
	}
}

运行结果：

5.4.3 TreeMap

TreeMap:是基于红黑树的Map接口的实现。

示例：

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

import javax.xml.bind.ValidationEvent;

/*
 * TreeMap<Student,String>
 * 键:Student
 * 值：String
 */
public class TreeMapDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new Comparator<Student>(){
			@Override
			public int compare(Student s1, Student s2) {
				int num = s1.getAge()-s2.getAge();
				int num2 = (num==0)?s1.getName().compareTo(s2.getName()):num;
				return num2;
			}
		});
		//创建学生对象
		Student s1 = new Student("潘安",30);
		Student s2 = new Student("柳下惠",35);
		Student s3 = new Student("唐伯虎",33);
		Student s4 = new Student("燕青",32);
		Student s5 = new Student("唐伯虎",33);
		//存储元素
		tm.put(s1, "宋朝");
		tm.put(s2, "元朝");
		tm.put(s3, "明朝");
		tm.put(s4, "清朝");
		tm.put(s5, "汉朝");

		//遍历
		Set<Student> set = tm.keySet();
		for(Student key:set){
			String value = tm.get(key);
			System.out.println(key.getName()+"---"+key.getAge()+"---"+value);
		}
	}
}

运行结果：

5.4.4 Map及其子类的练习题

练习1：需求："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

public class TreeDemo {
	public static void main(String[] args) {
		//获取字符串
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		//将字符串转为字符数组
		char[] chs = s.toCharArray();
		//定义一个集合对象
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
		//遍历字符数组
		/*for(char ch:chs){
			if(!tm.containsKey(ch)){
				tm.put(ch, 1);
			}
			else{
				Integer value = tm.get(ch);
				value++;
				tm.put(ch, value);
			}
		}*/
		for(char ch:chs){
			Integer i = tm.get(ch);
			if(i==null){
				tm.put(ch, 1);
			}
			else{
				i++;
				tm.put(ch, i);
			}
		}
		//定义一个字符串缓冲区
		StringBuilder sb = new StringBuilder();
		//遍历集合
		Set<Character> set = tm.keySet();
		for(Character key:set){
			Integer value = tm.get(key);
			sb.append(key).append("(").append(value).append(")");
		}
		System.out.println(sb.toString());
	}
}

运行结果：

练习2：HashMap嵌套HashMap

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap嵌套HashMap
 *
 * czbk
 * 		基础班
 * 				陈玉楼		20
 * 				高跃		22
 * 		就业班
 * 				李杰		21
 * 				曹石磊		23
 *
 * 先存储元素，然后遍历元素
 */

public class HashMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<String,HashMap<String,Integer>> czbkMap = new HashMap<String,HashMap<String,Integer>>();
		//创建基础班集合对象
		HashMap<String,Integer> jcMap = new HashMap<String,Integer>();
		//添加元素
		jcMap.put("陈玉楼", 20);
		jcMap.put("高越", 22);
		//把基础班添加到大集合
		czbkMap.put("基础班", jcMap);

		//创建就业班集合对象
		HashMap<String,Integer> jyMap = new HashMap<String,Integer>();
		//添加元素
		jyMap.put("李杰", 21);
		jyMap.put("曹石磊", 23);
		//把就业班添加到大集合
		czbkMap.put("就业班", jyMap);

		//遍历
		Set<String> czbkMapSet = czbkMap.keySet();
		for(String czbkMapKey:czbkMapSet){
			System.out.println(czbkMapKey);
			HashMap<String,Integer> czbkMapValue = czbkMap.get(czbkMapKey);
			Set<String> czbkMapValueSet = czbkMapValue.keySet();
			for(String czbkMapValueKey:czbkMapValueSet){
				Integer czbkMapValueValue = czbkMapValue.get(czbkMapValueKey);
				System.out.println("\t"+czbkMapValueKey+"---"+czbkMapValueValue);
			}
		}
	}
}

运行结果：

练习3：HashMap嵌套ArrayList

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/*
 *需求：
 *假设HashMap集合的元素是ArrayList。有3个。
 *每一个ArrayList集合的值是字符串。
 *元素我已经完成，请遍历。
 *结果：
 *		 三国演义
 *		 	吕布
 *		 	周瑜
 *		 笑傲江湖
 *		 	令狐冲
 *		 	林平之
 *		 神雕侠侣
 *		 	郭靖
 *		 	杨过
 */
public class HashMapIncludeArrayListDemo {
	public static void main(String[] args) {
		//创建HashMap集合对象
		HashMap<String,ArrayList<String>> hm = new HashMap<String,ArrayList<String>>();
		//创建ArrayList集合对象
		ArrayList<String> array1 = new ArrayList<String>();
		//添加元素
		array1.add("吕布");
		array1.add("周瑜");
		hm.put("三国演义", array1);

		ArrayList<String> array2 = new ArrayList<String>();
		array2.add("令狐冲");
		array2.add("林平之");
		hm.put("笑傲江湖", array2);

		ArrayList<String> array3 = new ArrayList<String>();
		array3.add("郭靖");
		array3.add("杨过");
		hm.put("神雕侠侣", array3);

		//遍历集合
		Set<String> hmSet = hm.keySet();
		for(String hmKey:hmSet){
			System.out.println(hmKey);
			ArrayList<String> array = hm.get(hmKey);
			for(String value:array){
				System.out.println("\t"+value);
			}
		}
	}
}

运行结果：

练习4：ArrayList嵌套HashMap

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/*
 ArrayList集合嵌套HashMap集合并遍历。
 需求：
 假设ArrayList集合的元素是HashMap。有3个。
 每一个HashMap集合的键和值都是字符串。
 元素我已经完成，请遍历。
 结果：
 周瑜---小乔
 吕布---貂蝉

 郭靖---黄蓉
 杨过---小龙女

 令狐冲---任盈盈
 林平之---岳灵珊
 */
public class ArrayListIncludeHashMapDemo {
	public static void main(String[] args) {
		ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();

		HashMap<String, String> hm1 = new HashMap<String, String>();
		hm1.put("周瑜", "小乔");
		hm1.put("吕布", "貂蝉");
		array.add(hm1);

		HashMap<String, String> hm2 = new HashMap<String, String>();
		hm2.put("郭靖", "黄蓉");
		hm2.put("杨过", "小龙女");
		array.add(hm2);

		HashMap<String, String> hm3 = new HashMap<String, String>();
		hm3.put("令狐冲", "任盈盈");
		hm3.put("林平之", "岳灵珊");
		array.add(hm3);

		// 遍历
		for (HashMap<String, String> hm : array) {
			System.out.println();
			Set<String> set = hm.keySet();
			for (String key : set) {
				String value = hm.get(key);
				System.out.println(key + "---" + value);
			}
		}
	}
}

运行结果：

5.5 Collections

Collections:是集合框架的工具类，里面的方法都是静态的。

5.5.1 Collections的基本方法

示例：

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

/*
 * 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 class CollectionsDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<Integer> list = new ArrayList<Integer>();

		// 添加元素
		list.add(30);
		list.add(20);
		list.add(50);
		list.add(10);
		list.add(40);

		System.out.println("list:" + list);

		// public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
		Collections.sort(list);
		System.out.println("sort:" + list);

		//public static <T> int binarySearch(List<?> list,T key):二分查找
		System.out.println("binarySearch:"+Collections.binarySearch(list, 30));
		System.out.println("binarySearch:"+Collections.binarySearch(list, 300));

		//public static <T> T max(Collection<?> coll):最大值
		System.out.println("max:"+Collections.max(list));

		//public static void reverse(List<?> list):反转
		Collections.reverse(list);
		System.out.println("reverse:" + list);

		//public static void shuffle(List<?> list):随机置换
		Collections.shuffle(list);
		System.out.println("shuffle:" + list);
	}
}

运行结果：

5.5.2 Collections练习题

练习1：Collections可以针对ArrayList存储基本包装类的元素排序，存储自定义对象可不可以排序呢?

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

public class 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;
	}
}

public class CollectionsDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<Student> list = new ArrayList<Student>();

		// 创建学生对象
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("风清扬", 30);
		Student s3 = new Student("刘晓曲", 28);
		Student s4 = new Student("武鑫", 29);
		Student s5 = new Student("林青霞", 27);

		// 添加元素对象
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);

		// 排序
		// 比较器排序
		// 如果同时有自然排序和比较器排序，以比较器排序为主，此处按年龄从高到低排序
		Collections.sort(list, new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {
				int num = s2.getAge() - s1.getAge();
				int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
						: num;
				return num2;
			}
		});

		// 遍历集合
		for (Student s : list) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}

运行结果：

练习2：模拟斗地主洗牌和发牌

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

public class PokerDemo2 {
	public static void main(String[] args) {
		// 创建牌盒
		ArrayList<String> array = new ArrayList<String>();
		// 创建牌
		String[] colors = { "?", "?", "?", "?" };
		String[] numbers = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10",
				"J", "Q", "K" };
		String minKing = "小王";
		String maxKing = "大王";
		// 装牌
		for (String color : colors) {
			for (String number : numbers) {
				String poker = color.concat(number);
				array.add(poker);
			}
		}
		array.add(minKing);
		array.add(maxKing);
		// 洗牌
		Collections.shuffle(array);
		// 发牌
		ArrayList<String> player1 = new ArrayList<String>();
		ArrayList<String> player2 = new ArrayList<String>();
		ArrayList<String> player3 = new ArrayList<String>();
		ArrayList<String> diPai = new ArrayList<String>();
		for (int x = 0; x < array.size(); x++) {
			if (x >= array.size() - 3) {
				diPai.add(array.get(x));
			} else {
				if (x % 3 == 0) {
					player1.add(array.get(x));
				} else if (x % 3 == 1) {
					player2.add(array.get(x));
				} else if (x % 3 == 2) {
					player3.add(array.get(x));
				}
			}
		}
		// 看牌
		lookPocker("张三", player1);
		lookPocker("李四", player2);
		lookPocker("王五", player3);
		lookPocker("底牌", diPai);
	}

	public static void lookPocker(String name, ArrayList<String> array) {
		System.out.print(name + "的牌是：");
		for (String s : array) {
			System.out.print(s + " ");
		}
		System.out.println();
	}
}

运行结果：

练习3：模拟斗地主洗牌、发牌以及对牌进行排序

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

/*
 * 思路：
 * 		A:创建一个HashMap集合
 * 		B:创建一个ArrayList集合
 * 		C:创建花色数组和点数数组
 * 		D:从0开始往HashMap里面存储编号，并存储对应的牌
 *        同时往ArrayList里面存储编号即可。
 *      E:洗牌(洗的是编号)
 *      F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
 *      G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
 */
public class PokerDemo2 {
	public static void main(String[] args) {
		TreeMap<Integer, String> tm = new TreeMap<Integer, String>();

		ArrayList<Integer> array = new ArrayList<Integer>();

		// 创牌
		String[] colors = { "?", "?", "?", "?" };
		String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
				"K", "A", "2" };
		String minKing = "小王";
		String maxKing = "大王";

		// 聚牌
		int index = 0;
		for (String number : numbers) {
			for (String color : colors) {
				String poker = color.concat(number);
				tm.put(index, poker);
				array.add(index);
				index++;
			}
		}
		tm.put(index, minKing);
		array.add(index);
		index++;
		tm.put(index, maxKing);
		array.add(index);

		// 洗牌（其实洗的是编号）
		Collections.shuffle(array);

		// 发牌
		TreeSet<Integer> player1 = new TreeSet<Integer>();
		TreeSet<Integer> player2 = new TreeSet<Integer>();
		TreeSet<Integer> player3 = new TreeSet<Integer>();
		TreeSet<Integer> diPai = new TreeSet<Integer>();
		for (int x = 0; x < array.size(); x++) {
			if (x >= array.size() - 3) {
				diPai.add(array.get(x));
			} else {
				if (x % 3 == 0) {
					player1.add(array.get(x));
				} else if (x % 3 == 1) {
					player2.add(array.get(x));
				} else if (x % 3 == 2) {
					player3.add(array.get(x));
				}
			}
		}

		// 看牌
		lookPocker("张三", player1, tm);
		lookPocker("李四", player2, tm);
		lookPocker("王五", player3, tm);
		lookPocker("底牌", diPai, tm);
	}

	public static void lookPocker(String name, TreeSet<Integer> ts,
			TreeMap<Integer, String> tm) {
		System.out.print(name + "的牌是：");
		for (Integer i : ts) {
			String s = tm.get(i);
			System.out.print(s + "  ");
		}
		System.out.println();
	}
}

运行结果：

时间： 2024-11-08 22:01:42

黑马程序员（Java）---API之集合（Map及其子类、Collections）的相关文章

黑马程序员——java基础 ArrayList集合基本方法演示

java基础 ArrayList集合基本方法演示 import java.util.ArrayList; import java.util.Iterator; public class ArrayListDemos { public static void main(String[] args) { // 创建一个新的容器 ArrayList al = new ArrayList(); al.add("abc1"); al.add("abc2"); al.add(&

黑马程序员-Java基础之集合(一)

集合框架:用于存储数据的容器. 特点: 1:对象封装数据,对象多了也需要存储.集合用于存储对象. 2:对象的个数确定可以使用数组,但是不确定怎么办?可以用集合.因为集合是可变长度的. 集合和数组的区别: 1:数组是固定长度的:集合可变长度的. 2:数组可以存储基本数据类型,也可以存储引用数据类型:集合只能存储引用数据类型. 3:数组存储的元素必须是同一个数据类型:集合存储的对象可以是不同数据类型. 数据结构:就是容器中存储数据的方式. 对于集合容器,有很多种.因为每一个容器的自身特点不同,其

黑马程序员——Java集合基础知识之Map

Map概念要同时存储两个元素Key和Value,他们之间有映射关系,每个键不能重复,每个键只能映射到一个值. 当数据之间存在映射关系的时候,考虑使用Map集合. Map常用方法如果添加的键原来有值,后添加的值会覆盖前面的值,并返回之前的值.put会返回来先添加的值,后添加的值会覆盖原有的值. Map tm =new TreeMap(); tm.put (key, value);//MAP没有add tm.remove (key) ;//去除一个key和对应的value,若不存在key返回nu

黑马程序员——Java基础---集合框架工具类

黑马程序员——Java基础<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java为操作Set.List和Map提供了一系列工具类,主要有Collections和Arrays.这两个工具类的特点:类中的方法都是静态的,不需要创建对象,直接使用类名调用即可.Collections:是集合对象

黑马程序员——Java集合基础知识之Collection

集合基础知识--Collection Java中集合框架由常用的Collection接口和Map接口组成,而Collection接口又有两个子接口,是List接口和Set接口,常用的集合框架由这三个类组成. List接口的功能方法 List的使用最为简单,创建集合,通过add方法添加元素,get方法获取元素,通过迭代器获取元素.List接口存放的数据无序的,添加速度快,但是查询速度慢,因为查询的时候必须遍历,每次都重头开始,效率较低.常用实现类有ArrayList,LinkedList. Lis

黑马程序员---Java集合框架

---------------------- Android开发.java培训.期待与您交流! ---------------------- Java集合框架集合我们都知道是用来储存对象的容器,那之前的数组不也可以储存对象么,为什么要出现集合呢? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,然而集合类中提供很多方便操作对象存储的方法,要比数组更容易操作对象,而且集合的长度是可变的,然而数组长度确实固定不变的,这样不利于对对象的间隔储存. 数组和集

黑马程序员——Java集合工具类和泛型

Collections工具类和泛型 Collections和Collection Collections和Collection是不同的,Collections是工具类,用来操作集合的,而Collection是集合接口.Collections中有一系列的静态方法用来操作集合,但是不能更改集合内容.比如不能set()不能remove()元素,可以替换全部元素或者添加同一个元素. static List<String> list =Arrays .asList("one Two three

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

黑马程序员--java基础--集合(Collection) ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 集合框架的构成及分类,如下图: 1.为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式. 2.数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的:集合长度是可变的.数组中可以存储基本数据类型,集合只能存储对象. 3.

黑马程序员——Java基础---IO(下)

黑马程序员——Java基础---IO(下) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供了File类.properties类.打印流.序列流等和输入输出相关的类,它们能够帮助我们更好的处理信息.下面将对它们进行简单的介绍. 一.正

黑马程序员——Java I/O流基础知识点（File类）

File工具 File类就是用俩将文件或者文件夹封装对象,弥补流对象的不足--流只能操作数据,不能操作文件夹的封装的是路径!!! 构造方法演示 1.可以将已有的未出现的文件或者文件夹封装成对象. File f1=new File("c:\\abc\\a.txt"): File f2=new File("d:\\abc","ab.txt"打印,会打印路径.:目录分隔符,为了更好地跨平台File. File类常见功能 1,创建 createNewF