【从零开始学Java笔记】Set类和Map类

大家可以关注作者的账号，关注从零开始学Java笔记文集。也可以根据目录前往作者的博客园博客进行学习。本片文件将基于黑马程序员就业班视频进行学习以及资料的分享，并记录笔记和自己的看法。欢迎大家一起学习和讨论。

【从零开始学Java笔记】目录

Set类

Set集合的特点:
无序(存储和读取的顺序有可能不一样)
不允许重复(要求元素唯一)
没有索引

例子：使用HashSet存储自定义对象并遍历

import java.util.HashSet;

public class HashSetDemo2 {
	public static void main(String[] args) {
		Student s1 = new Student("大乔", "18");
		Student s2 = new Student("小乔", "17");
		Student s3 = new Student("小乔", "17");
		
		HashSet<Student> hs = new HashSet<Student>();
		hs.add(s1);
		hs.add(s2);
		hs.add(s3);
		
		for (Student student : hs) {
			System.out.println(student);
		}
		
		
	}
}
输出结果
Student [name=小乔, age=17]
Student [name=大乔, age=18]
Student [name=小乔, age=17]

为什么HashSet不可重复，但是s2和s3一样，却都存进去了？
通过查看add()方法源码发现:
HashSet的add()方法，首先会使用当前集合中的每一个元素和新加的元素进行hash值比较，如果hash值不一样， 则直接添加新的元素，如果hash值-样，比较地址值或者使用equals方法进行比较
比较结果-样，则认为是重夏不添加。set中所有元素的比较结果都不一样则添加。

但这并不是我们想要的，我们就像让他既有hashset的特性，不可重复，怎么办？
重新equal和hashcode
右键->resource-> generate hashcode and equal

生成如下代码

@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((age == null) ? 0 : age.hashCode());
		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 == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

再次运行主函数，结果如下

Student [name=大乔, age=18]
Student [name=小乔, age=17]

Collections类

Collection和Collections有什么区别?
Collection是集合体系的最顶层，包含了集合体系的共性
Collections是一个工具类， 方法都是用于操作Collection

常用方法

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


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

	private static void mothed7() {
		//static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(4);
		Collections.swap(list, 0, 1);
		
		System.out.println(list);
	}

	private static void method6() {
		//static void  sort(List<T> list) :按照列表中元素的自然顺序进行排序
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(4);
		list.add(3);
		list.add(2);
		
		Collections.sort(list);
		System.out.println(list);
	}

	private static void method5() {
		//static void shuffle(List list):随机置换  
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		Collections.shuffle(list);
		System.out.println(list);
	}

	private static void method4() {
		//static void reverse(List list)  :反转
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		
		Collections.reverse(list);
		System.out.println(list);
	}

	private static void method3() {
		//static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		System.out.println(list);
		
		Collections.fill(list, "android");
		
		System.out.println(list);
	}

	private static void method2() {
		//static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表
		//注意：目标列表的长度至少等于源列表的长度
		//创建源列表
		List<String> src = new ArrayList<String>();
		src.add("hello");
		src.add("world");
		src.add("java");
		
		//创建目标列表
		List<String> dest = new ArrayList<String>();
		dest.add("java");
		dest.add("java");
		dest.add("java");
		dest.add("java");
		Collections.copy(dest, src);
		System.out.println(dest);
	}

	private static void method() {
		//static int  binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置 
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		
		int index = Collections.binarySearch(list, 4);
		System.out.println(index);
	}
}

斗地主发牌系统

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

public class Landlords {
	public static void main(String[] args) {
		//生成一副扑克牌
		ArrayList<String> c = new ArrayList<String>();
		
		String[] arr = {"黑桃","红桃","方片","草花"};
		String[] arr2 = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
		
				
		
		for (int i = 0; i <4; i++) {
			
			for (int k = 0; k < 13.; k++) {
				c.add(arr[i]+arr2[k]);
							}
			
				}
		c.add("大王");
		c.add("小王");
		
//		System.out.println(c);
//		System.out.println(c.size());
		//打乱
		Collections.shuffle(c);
//		System.out.println(c); 
		
		//分成三组
		List<String> c1 = new ArrayList<String>();
		List<String> c2 = new ArrayList<String>();
		List<String> c3 = new ArrayList<String>();
		c1 = c.subList(0, 17);
		c2 = c.subList(17, 34);
		c3 = c.subList(34, 51);
				
		//排序
		Collections.sort(c1);
		Collections.sort(c2);
		Collections.sort(c3);
		//输出
		System.out.println("玩家1："+c1);
		System.out.println("玩家2："+c2);
		System.out.println("玩家3："+c3);
		
		//底牌
		List<String> c4 = new ArrayList<String>();
		c4 = c.subList(51, 54);
		System.out.println("底牌"+c4);
	}

}

Map类

需求：实现学号和姓名这样有对应关系的数据存储（一对一:一个学号对应一个姓名）
为了体现这种有对应关系的数据，我们使用以前所学的内容是可以实现的，但是略有不变，所以java又给我买提供了一种专门用于存储对应关系的集合——Map
Map:将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值

Map和Collection有什么区别?
Map:是一个双列集合，常用语处理有对应关系的数据，key是不可以重复的，我们也称之为是夫妻对集合
Collection:是单列集合，Collection有不同的子体系，有的允许重复有索引有序，有的不允许重复而且无序，那么我们也称之为单身汉集合

Map的方法

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

/*
 * 	Map的常用功能：
 * 		映射功能：
 * 			 	V put(K key, V value) 
 * 		获取功能：
 * 				V get(Object key) 
 * 				int size() 
 * 		判断功能：
 * 				boolean containsKey(Object key) 
 				boolean containsValue(Object value) 
 				boolean isEmpty() 
 
 * 		删除功能：
 * 				void clear()  
 * 				V remove(Object key)  
 * 
 * 		遍历功能：
 * 				Set<Map.Entry<K,V>> entrySet() 
 * 
 * 
 * 			Set<K> keySet()  
 * 			Collection<V> values()  
 
 */
public class MapDemo2 {
	public static void main(String[] args) {
		// 创建Map对象
		Map<String, String> map = new HashMap<String, String>();
		map.put("001", "张三");
		map.put("002", "李四");
		

		// V put(K key, V value) ：就是将key映射到value，如果key存在，则覆盖value，并将原来的value返回
//		System.out.println(map.put("001", "张三"));
//		System.out.println(map.put("002", "李四"));
//		System.out.println(map.put("001", "王五"));

		// void clear() : 清空所有的对应关系
//		System.out.println(map);
//		map.clear();
//		System.out.println(map);

		// V remove(Object key) :根据指定的key删除对应关系，并返回key所对应的值，如果没有删除成功则返回null
//		System.out.println(map.remove("005"));
//		System.out.println(map.remove("001"));

		// boolean containsKey(Object key) : 判断指定key是否存在
//		System.out.println(map.containsKey("003"));
//		System.out.println(map.containsKey("001"));

		// boolean containsValue(Object value)：判断指定的value是否存在
//		System.out.println(map.containsValue("王五"));
//		System.out.println(map.containsValue("张三"));

		// boolean isEmpty() : 判断是否有对应关系
//		System.out.println(map.isEmpty());
//		map.clear();
//		System.out.println(map.isEmpty());

		// int size() : 返回对应关系的个数
//		System.out.println(map.size());

		// V get(Object key) : 根据指定的key返回对应的value
//		System.out.println(map.get("002"));

		// Set<Map.Entry<K,V>> entrySet():输出所有的映射关系
//		System.out.println(map.entrySet());
//		System.out.println(map);

//		// Set<K> keySet() : 以Set的形式获返回所有的key
//		Set<String> keys = map.keySet();
//		for (String key : keys) {
//			System.out.println(key);
//		}
//		System.out.println("-----------");
//
//		// Collection<V> values() :以Collection的形式获返回所有的values，不能使用List
//		Collection<String> values = map.values();
//		for (String value : values) {
//			System.out.println(value);
//		}

	}
}

Map两种的遍历方法

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

public class MapDemo3 {
	public static void main(String[] args) {
		Map<String,String> m= new HashMap<String,String>();
		
		m.put("刘备", "孙尚香");
		m.put("诸葛亮", "黄月英");
		m.put("曹丕", "甄姬");
		
//		method(m);
//		method1(m);
	}

	private static void method1(Map<String, String> m) {
		/*
		 * 第二种遍历
		 * 面向对象的方法
		 * entry是map的一个内部类，他有两个变量key和value，就可以像类一样获取成员变量
		 */
		Set<Map.Entry<String, String>> set = m.entrySet();
		for (Map.Entry<String, String> entry : set) {
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println("丈夫:"+key+"---媳妇:"+value);
		}
	}

	private static void method(Map<String, String> m) {
		/*
		 * 第一种遍历
		 * 先获得丈夫集合
		 * 遍历丈夫
		 * 让丈夫去找自己的老婆
		 */
		
		Set<String> s = m.keySet();
		for (String key : s) {
			String value = m.get(key);
			System.out.println("丈夫:"+key+"---媳妇:"+value);
		}
	}

}

原文链接:https://www.cnblogs.com/zllk/p/12656888.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有