目录
(3)Set集合的唯一性(hashCode() -> equals())
0.知识概述:
1.集合
1.1 集合继承关系类图
1.2 集合遍历的三种方式
/* 遍历集合的三种方式: 01 -> for 循环遍历 02 -> forEach 方法遍历 03 -> Iterator 迭代器遍历 */
代码实现:
System.out.println(dmList); //[斗罗, 沧源图, 仙逆, 凡人, 斗破, 吞噬星空]
/* 遍历集合的三种方式:
01 -> for 循环遍历
02 -> forEach 方法遍历
03 -> Iterator 迭代器遍历
*/
// 法1:
for(String dm: dmList){
System.out.print(dm+" ");
} //斗罗 沧源图 仙逆 凡人 斗破 吞噬星空
System.out.println();
// 法2:
dmList.forEach(dm->{
System.out.print(dm + " "); //斗罗 沧源图 仙逆 凡人 斗破 吞噬星空
});
System.out.println();
// 法3:
Iterator<String> itr = dmList.iterator();
while(itr.hasNext()){
String dm = itr.next(); // 提取下一个元素, 同时指针向后移动
System.out.print(dm);
} // 斗罗沧源图仙逆凡人斗破吞噬星空
System.out.println();
1.3 集合排序
1.3.1 Collections实现
方式1: Collections.sort(list);方式2: 创建一个内部类继承Comparator, 实现其compare
code:
public class ListSorter {
// 方式1: Collections.sort(list);
public static List<Integer> sort1(List<Integer> list){
Collections.sort(list);
System.out.println(list); //[18, 25, 45, 49]
return list;
}
// 方式2: 创建一个内部类继承Comparator, 实现其compare
class CompareDemo implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
}
public List<Integer> sort2(List<Integer> list){
Collections.sort(list, new CompareDemo());
System.out.println(list); // [49, 45, 25, 18]
return list;
}
public static void main(String[] args) {
List<Integer> alist = new ArrayList<>();
alist.add(25);
alist.add(45);
alist.add(49);
alist.add(18);
System.out.println(alist); //[25, 45, 49, 18]
System.out.println(alist.toString()); //[25, 45, 49, 18]
System.out.println(ListSorter.sort1(alist)); //[18, 25, 45, 49]
ListSorter ls = new ListSorter();
System.out.println(ls.sort2(alist)); //[49, 45, 25, 18]
}
}
1.3.2 自定义排序类
public class TestSort {
class CarSortDemo implements Comparator<Car> {
// 01 比较car 对象
// @Override
// public int compare(Car o1, Car o2) {
// return o1.equals(o2) ? 0 : 1;
// }
// 02 比较car 对象的 sn属性值
// @Override
// public int compare(Car o1, Car o2) {
// return o1.getSn().compareTo(o2.getSn());
// }
// 03 比较car 对象的 brand 属性值
public int compare(Car o1, Car o2){
return o2.getModel().compareTo(o1.getModel());
}
}
public List<Car> sort(List<Car> list){
Collections.sort(list, new CarSortDemo());
return list;
}
public static void main(String[] args) {
List<Car> carsList = new ArrayList<>();
carsList.add(new Car("217893","baoma"));
carsList.add(new Car("689326","su7"));
carsList.add(new Car("859032","aodi"));
carsList.add(new Car("785932","benchi"));
carsList.add(new Car("238979","biyadi"));
System.out.println(carsList);
//[Car{sn='217893', model='baoma'}, Car{sn='689326', model='su7'}, Car{sn='859032', model='aodi'}, Car{sn='785932', model='benchi'}, Car{sn='238979', model='biyadi'}]
System.out.println(new TestSort().sort(carsList));
// 01 比较car 对象
//[Car{sn='217893', model='baoma'}, Car{sn='689326', model='su7'}, Car{sn='859032', model='aodi'}, Car{sn='785932', model='benchi'}, Car{sn='238979', model='biyadi'}]
// 02 比较car 对象的 sn属性值
//[Car{sn='217893', model='baoma'}, Car{sn='238979', model='biyadi'}, Car{sn='689326', model='su7'}, Car{sn='785932', model='benchi'}, Car{sn='859032', model='aodi'}]
// 03 比较car 对象的 brand 属性值
//[Car{sn='689326', model='su7'}, Car{sn='238979', model='biyadi'}, Car{sn='785932', model='benchi'}, Car{sn='217893', model='baoma'}, Car{sn='859032', model='aodi'}]
}
}
2 List 集合概述
有关List的相关继承关系:
2.1 ArrayList
(1)特点
(2)常用方法
/** * ArrayList -> * 01. ArrayList<String> nickList = new ArrayList<String>(); * 02. nickList.add("phdvb"); * nickList.add(1,"pxq"); * nickList.get(2) * 03. nickList.set(2, "drl"); * 04. nickList.remove("phdvc"); * remove(listSize-1); * nickList.size(); */
public class ArrayListDemo {
public static void main(String[] args) {
/**
* ArrayList ->
* 01. ArrayList<String> nickList = new ArrayList<String>();
* 02. nickList.add("phdvb");
* nickList.add(1,"pxq");
* nickList.get(2)
* 03. nickList.set(2, "drl");
* 04. nickList.remove("phdvc");
* remove(listSize-1);
* nickList.size();
*/
//01 创建ArrayList对象
ArrayList<String> nickList = new ArrayList<String>();
//02 往ArrayList中添加数据
nickList.add("phdvb");
nickList.add("phdva");
boolean isChange = nickList.add("phdvb");
System.out.println("ArrayList是否发生变化?"+ isChange); //ArrayList是否发生变化?true
System.out.println(nickList); //[phdvb, phdva, phdvb]
System.out.println(nickList.get(2)); //phdvb
nickList.add(1,"pxq");
System.out.println(nickList); //[phdvb, pxq, phdva, phdvb]
nickList.add("phdvb");
nickList.add("phdvc");
nickList.add("phdvc");
nickList.add("phdvd");
//03 更新ArrayList中的元素
String beforeNick = nickList.set(2, "drl");
System.out.println(beforeNick); //phdva
System.out.println(nickList); //[phdvb, pxq, drl, phdvb, phdvb, phdvb, phdvc, phdvd]
//04 删除ArrayList中的元素
boolean isRemove = nickList.remove("phdvc");
System.out.println(isRemove); //true
System.out.println(nickList); //仅删除了一个元素,[phdvb, pxq, drl, phdvb, phdvb, phdvc, phdvd]
int listSize = nickList.size();
System.out.println(listSize); //7
nickList.remove(listSize-1);
System.out.println(nickList); //[phdvb, pxq, drl, phdvb, phdvb, phdvc]
nickList.set(nickList.size()-2, "vb");
System.out.println(nickList); //[phdvb, pxq, drl, phdvb, vb, phdvc]
}
}
2.2 LinkedList
代码实现:
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> dmList = new LinkedList<String>();
dmList.add("仙逆");
dmList.add("凡人");
dmList.add("斗破");
System.out.println(dmList); //[仙逆, 凡人, 斗破]
dmList.add(0, "沧源图");
System.out.println(dmList); //[沧源图, 仙逆, 凡人, 斗破]
// 实现的是 Deque接口 中的方法
dmList.addFirst("斗罗");
dmList.addLast("吞噬星空");
System.out.println(dmList); //[斗罗, 沧源图, 仙逆, 凡人, 斗破, 吞噬星空]
}
}
3. Set集合
3.1 概述
(1)特点
Set集合接口间的实现关系:
(2)重要方法
代码实现:
public class HashSetDemo {
public static void main(String[] args) {
// 实例化一个 Set集合
Set<String> gameSet = new HashSet<String>();
gameSet.add("夏洛特");
gameSet.add("貂蝉");
gameSet.add("戈雅");
gameSet.add("不知火舞");
System.out.println(gameSet); //[不知火舞, 戈雅, 夏洛特, 貂蝉]
// add()返回值代表是否真正在集合中插入元素
boolean isChanged = gameSet.add("米莱迪");
System.out.println(gameSet); //[不知火舞, 戈雅, 夏洛特, 貂蝉, 米莱迪]
System.out.println(isChanged); //true
isChanged = gameSet.add("貂蝉");
System.out.println(gameSet); // [不知火舞, 戈雅, 夏洛特, 貂蝉, 米莱迪]
System.out.println(isChanged); // false
// Set 可以 使用所有 Collection 接口定义方法
int size = gameSet.size();
System.out.println(size); // 5
boolean isContain = gameSet.contains("夏洛特");
System.out.println(isContain); // true
}
}
(3)Set集合的唯一性(hashCode() -> equals())
/** * Q1 : Set集合如何确保数据的 唯一性 */ /** * A1 : Set集合在新增数据时, 先会判断hashCode() 是否已存在 * 若新增的hashCode() 在Set集合中存在, 在调用equals () 进行 值比较; * 新增的hashCode() 与 equals() 都存在的情况下 * Set集合认为数据已存在,不予新增 */
/** * Q2: 直接使用equals()判断不行吗? */ /** * A2: 出于执行效率老驴 * hashCode() 返回的整数结果 决定了其将Set集合中的存放位置 * 由于相比于Equals()方法hashCode()计算速度会很快, 但是有可能发生哈希碰撞 * 所以equals再次会发生哈希碰撞的值进行比较 */
School类(重写了hashCode()、equals()、toString())
public class School {
private String name;
private String addr;
public School(String name, String addr) {
setAddr(addr);
setName(name);
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// 重写Object类的 toString()方法
@Override
public String toString() {
return this.hashCode() + "= School{" +
"name='" + name + '\'' +
"addr='" + addr + '\'' +
"}";
}
@Override
public int hashCode() {
// return super.hashCode();
return this.name.hashCode();
}
@Override
public boolean equals(Object obj) {
// return super.equals(obj);
if(obj instanceof School){
School school = (School)obj;
if(this.name.equals(((School)obj).getName())){
return true;
}else{
return false;
}
}else{
return false;
}
}
}
Test类
public class SetConsistent {
public static void main(String[] args) {
String sa = "西交大";
String sb = "西工大";
System.out.println("sa.hashCode():" + sa.hashCode() +
",sa.hashCode():" + sb.hashCode());
// sa.hashCode():34473154,sa.hashCode():34594209
HashSet<School> schoolHashSet = new HashSet<School>();
schoolHashSet.add(new School(sa,"西安"));
schoolHashSet.add(new School(sb,"西安"));
schoolHashSet.add(new School("克职","克拉玛依"));
schoolHashSet.add(new School("克职","克拉玛依"));
System.out.println(schoolHashSet);
//[1956725890= School{name='克职'addr='克拉玛依'},
// 1163157884= School{name='西工大'addr='西安'},
// 460141958= School{name='西交大'addr='西安'}]
}
}
3.2 HashSet
数据存放实例:
3.3 LinkedHashSet
数据存放示例:
代码演示:
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> langSet= new LinkedHashSet<String>();
langSet.add("Java");
langSet.add("Python");
langSet.add("C#");
langSet.add("C++");
System.out.println(langSet); //[Java, Python, C#, C++]
}
}
3.4 TreeSet
code01:
public class TreeSetDemo {
public static void main(String[] args) {
Set<Integer> tSet = new TreeSet<Integer>();
tSet.add(108);
tSet.add(139);
tSet.add(75);
tSet.add(64);
tSet.add(225);
System.out.println(tSet); //[64, 75, 108, 139, 225]
TreeSetDemo td = new TreeSetDemo();
td.sort(); //[226, 140, 109, 76, 65]
}
// 重写Comparator接口中的compare方法, 实现自定义比较逻辑
class IntegerComparator implements Comparator<Integer> {
public int compare(Integer o1, Integer o2) {
return o2 -o1;
}
}
public void sort(){
Set<Integer> tSet = new TreeSet<Integer>(new IntegerComparator());
tSet.add(109);
tSet.add(140);
tSet.add(76);
tSet.add(65);
tSet.add(226);
System.out.println(tSet); //[226, 140, 109, 76, 65]
}
}
4.Map
4.1 概述
4.1.1 特点 & 继承关系
4.1.2 遍历集合的三种方式
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
public class LoopMapThreeWays {
// 遍历集合
//方式1: 增强for循环
public void doForLoop(Map map){
Set<String> keys = map.keySet();
for(String key : keys){
System.out.println(key + ":" + map.get(key));
}
}
// 方式2: lambda 表达式
public void doForLoop2(Map map){
map.forEach((key, value) ->{
System.out.println(key + ":" + value);
});
}
// 方式3: 使用迭代器
public void doForLoop3(Map map){
Iterator<Map.Entry<String, Object>> itr = map.entrySet().iterator();
while(itr.hasNext()){
Map.Entry<String, Object> entry = itr.next();
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
public static void main(String[] args) {
Map<String, Object> xlt = new LinkedHashMap<>();
xlt.put("name", "夏洛特");
xlt.put("nick", "玫瑰剑士");
xlt.put("技能", "七星光芒剑");
xlt.put("技能", "七星光芒斩");
xlt.put("皮肤1", "浮生王");
xlt.put("皮肤2", "金色皮");
System.out.println(xlt);
//{name=夏洛特, nick=玫瑰剑士, 技能=七星光芒斩, 皮肤1=浮生王, 皮肤2=金色皮}
LoopMapThreeWays lm = new LoopMapThreeWays();
lm.doForLoop(xlt);
System.out.println("——————————————————————————————————————————");
lm.doForLoop2(xlt);
System.out.println("——————————————————————————————————————————");
lm.doForLoop3(xlt);
/*
name:夏洛特
nick:玫瑰剑士
技能:七星光芒斩
皮肤1:浮生王
皮肤2:金色皮
*/
}
}
4.2 HashMap
code:
import java.util.HashMap;
import java.util.Map;
public class HashMapDemo {
public static void main(String[] args) {
Map<String, Object> xlt = new HashMap<String, Object>();
xlt.put("name", "夏洛特");
xlt.put("nick", "玫瑰剑士");
xlt.put("技能", "七星光芒剑");
xlt.put("技能", "七星光芒斩");
System.out.println(xlt); //{nick=玫瑰剑士, 技能=七星光芒斩, name=夏洛特}
String heroNick = (String) xlt.get("nick");
System.out.println(heroNick); //玫瑰剑士
System.out.println(xlt.containsKey("技能")); //true
System.out.println(xlt.containsKey("皮肤")); //false
xlt.put("皮肤1", "浮生王");
int count = xlt.size();
System.out.println(count); //4
xlt.put("皮肤2", "金色皮");
System.out.println(xlt); //{nick=玫瑰剑士, 技能=七星光芒斩, 皮肤2=金色皮, 皮肤1=浮生王, name=夏洛特}
String removeValur = (String)xlt.remove("皮肤2");
System.out.println(removeValur); //金色皮
}
}
4.3 LinkedHashMap
public class LinkedHashMapDemo {
public static void main(String[] args) {
Map<String, Object> xlt = new LinkedHashMap<>();
xlt.put("name", "夏洛特");
xlt.put("nick", "玫瑰剑士");
xlt.put("技能", "七星光芒剑");
xlt.put("技能", "七星光芒斩");
xlt.put("皮肤1", "浮生王");
xlt.put("皮肤2", "金色皮");
System.out.println(xlt);
//{name=夏洛特, nick=玫瑰剑士, 技能=七星光芒斩, 皮肤1=浮生王, 皮肤2=金色皮}
}
}
4.4 TreeMap
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
/*
正常需求测试1:
*/
Map<Object, Object> tMap = new TreeMap<Object, Object>();
tMap.put("a2", 589);
tMap.put("a1", "vb");
tMap.put("b4", "运还是重要的");
tMap.put("b5", "自信也重要");
tMap.put("b2", 3.5);
System.out.println(tMap);
//{a1=vb, a2=589, b2=3.5, b4=运还是重要的, b5=自信也重要}
/*
比较方法重写测试2:
*/
TreeMapDemo td = new TreeMapDemo();
td.sort(); //{b5=自信也重要, b4=运还是重要的, b2=3.5, a2=589, a1=vb}
}
class tMapComparator implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);
}
}
public void sort(){
Map<String, Object> t2Map = new TreeMap<>(new tMapComparator());
t2Map.put("a2", 589);
t2Map.put("a1", "vb");
t2Map.put("b4", "运还是重要的");
t2Map.put("b5", "自信也重要");
t2Map.put("b2", 3.5);
System.out.println(t2Map);
}
}