大家可以关注作者的账号，关注从零开始学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);
}
}
}