目录
前言
重点回顾：
1.Linkedlist的特点：
堆栈（先进后出）和队列（先进先出）
2.list集合去重底层原理：调用equals方法
3.list的优化：设置初始容量 以减少扩容的次数
一、set集合特点&遍历方式
代码展示：
/**
* set集合的特点
* 不重复：基本数据类型以及String
* 无序：只有两种遍历方式
* @author zjjt
*
*/
public class Demo1 {
public static void main(String[] args) {
HashSet<Object> set = new HashSet<>();
set.add("zs");
set.add("ls");
set.add("ww");
set.add("老六");
set.add("ls");
System.out.println(set.size());
//遍历方式
System.out.println("=========增强for循坏==========");
for (Object obj : set) {
System.out.println(obj);
}
System.out.println("=========迭代器==========");
Iterator<Object> it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}效果图：不重复
无序的两种遍历方式：
二、set集合去重原理
代码展示：
/**
* set底层去重原理
* @author zjjt
*
*/
public class Demo2 {
public static void main(String[] args) {
HashSet<Object> set = new HashSet<>();
set.add(new person("zs", 18));
set.add(new person("ls", 14));
set.add(new person("ww", 24));
set.add(new person("老六", 22));
set.add(new person("zs", 18));
System.out.println(set.size());
}
}
class person{
private String name;
private int 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 person() {
// TODO Auto-generated constructor stub
}
public person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "person [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
System.out.println("==============hashCode================");
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;//如果将result换为1 会调用equals 且调用5次 相当于每一个hashcode的值都是相等的
}
@Override
public boolean equals(Object obj) {
System.out.println("==============equals================");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
person other = (person) 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;//若if全注掉 set.size为1
}
}效果图：
结论：set集合去重底层原理是与对象的hashcode以及equals相关
在判断重复元素的时候，是先比较hashcode值，再调用equals比较内容
三、set集合自然排序接口
代码展示：
package com.chendongli.set;
import java.util.TreeSet;
/**
* set集合的排序
* @author zjjt
*
*/
public class Demo3 {
public static void main(String[] args) {
/**
* 需求：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
* 张三 部门总监 1
* 李四 普通员工 4
* 王五 部门经理 2
* 老六 主管 3
*/
TreeSet set = new TreeSet<>();
set.add(new person1("zs", 18,1));
set.add(new person1("ls", 24,4));
set.add(new person1("ww", 26,2));
set.add(new person1("老六", 20,3));
for (Object object : set) {
System.out.println(object);
}
}
}
class person1{
private String name;
private int age;
private int level;
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
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 person1() {
// TODO Auto-generated constructor stub
}
public person1(String name, int age, int level) {
super();
this.name = name;
this.age = age;
this.level = level;
}
@Override
public String toString() {
return "person1 [name=" + name + ", age=" + age + ", level=" + level + "]";
}
}
效果展示：
报错的提示：Exception in thread "main" java.lang.ClassCastException: com.chendongli.set.person1 cannot be cast to java.lang.Comparable
at java.util.TreeMap.compare(TreeMap.java:1290)
at java.util.TreeMap.put(TreeMap.java:538)
at java.util.TreeSet.add(TreeSet.java:255)
at com.chendongli.set.Demo3.main(Demo3.java:21)
现象：
1.String默认是能够排序的
2.自定义的对象无法排序，报类型转换异常
String能够排序的原因是因为String实现了Comparable接口
java.lang.Comparable:自然排序接口 排序的规则单一 不能够应对复杂的变化的需求
解决办法：要对person这个对象进行排序，就让这个对象实现该接口
代码展示：
需求1：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
张三 部门总监 1
李四 普通员工 4
王五 部门经理 2
老六 主管 3
package com.chendongli.set;
import java.util.TreeSet;
/**
* set集合的排序
* @author zjjt
*
*/
public class Demo3 {
public static void main(String[] args) {
/**
* 需求1：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
* 张三 部门总监 1
* 李四 普通员工 4
* 王五 部门经理 2
* 老六 主管 3
*
*/
//String
TreeSet set = new TreeSet<>();
set.add(new person1("zs", 18,1));
set.add(new person1("ls", 24,4));
set.add(new person1("ww", 26,2));
set.add(new person1("老六", 20,3));
for (Object object : set) {
System.out.println(object);
}
}
}
class person1 implements Comparable<person1>{
private String name;
private int age;
private int level;
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
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 person1() {
// TODO Auto-generated constructor stub
}
public person1(String name, int age, int level) {
super();
this.name = name;
this.age = age;
this.level = level;
}
@Override
public String toString() {
return "person1 [name=" + name + ", age=" + age + ", level=" + level + "]";
}
@Override
public int compareTo(person1 o) {
return this.level - o.level;
}
}效果图：
需求1+需求2：按照年龄升序，打印出人员信息
代码展示：
package com.chendongli.set;
import java.util.TreeSet;
/**
* set集合的排序
* @author zjjt
*
*/
public class Demo3 {
public static void main(String[] args) {
/**
* 需求1：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
* 张三 部门总监 1
* 李四 普通员工 4
* 王五 部门经理 2
* 老六 主管 3
*
*
* 需求1：按照年龄升序，打印出人员信息
*/
//String
TreeSet set = new TreeSet<>();
set.add(new person1("zs", 18,1));
set.add(new person1("ls", 24,4));
set.add(new person1("ww", 26,2));
set.add(new person1("老六", 20,3));
set.add(new person1("八戒", 18,4));
for (Object object : set) {
System.out.println(object);
}
}
}
class person1 implements Comparable<person1>{
private String name;
private int age;
private int level;
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
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 person1() {
// TODO Auto-generated constructor stub
}
public person1(String name, int age, int level) {
super();
this.name = name;
this.age = age;
this.level = level;
}
@Override
public String toString() {
return "person1 [name=" + name + ", age=" + age + ", level=" + level + "]";
}
@Override
public int compareTo(person1 o) {
int levelRes = this.level - o.level;
return levelRes == 0 ? this.age - o.age : levelRes;
}
}
效果图：
四、set集合比较器排序
java.util.comparator:比较器排序
代码展示：
package com.chendongli.set;
import java.util.Comparator;
import java.util.TreeSet;
/**
* set集合的排序
* java.lang.Comparable:自然排序接口 排序的规则单一 不能够应对复杂的变化的需求
* java.util.comparator:比较器排序
* @author zjjt
*
*/
public class Demo3 {
public static void main(String[] args) {
/**
* 需求1：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
* 张三 部门总监 1
* 李四 普通员工 4
* 王五 部门经理 2
* 老六 主管 3
*
* 需求2：按照年龄升序，打印出人员信息
*
* 需求3：按照用户的首字母排序
*/
//String
TreeSet set = new TreeSet<>(new levelComparator());
set.add(new person1("zs", 18,1));
set.add(new person1("ls", 24,4));
set.add(new person1("ww", 26,2));
set.add(new person1("老六", 20,3));
set.add(new person1("八戒", 18,4));
for (Object object : set) {
System.out.println(object);
}
}
}
class person1 /*implements Comparable<person1>*/{
private String name;
private int age;
private int level;
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
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 person1() {
// TODO Auto-generated constructor stub
}
public person1(String name, int age, int level) {
super();
this.name = name;
this.age = age;
this.level = level;
}
@Override
public String toString() {
return "person1 [name=" + name + ", age=" + age + ", level=" + level + "]";
}
/*@Override
public int compareTo(person1 o) {
int levelRes = this.level - o.level;
return levelRes == 0 ? this.age - o.age : levelRes;
}*/
public static void main1(String[] args) {
/**
* 需求1：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
* 张三 部门总监 1
* 李四 普通员工 4
* 王五 部门经理 2
* 老六 主管 3
*
* 现象：
* 1.String默认是能够排序的
* 2.自定义的对象无法排序，报类型转换异常
*
* 需求2：按照年龄升序，打印出人员信息
*
* 需求3：按照用户的首字母排序
*/
//String
TreeSet set = new TreeSet<>();
set.add(new person1("zs", 18,1));
set.add(new person1("ls", 24,4));
set.add(new person1("ww", 26,2));
set.add(new person1("老六", 20,3));
set.add(new person1("八戒", 18,4));
for (Object object : set) {
System.out.println(object);
}
}
}
class levelComparator implements Comparator<person1>{
@Override
public int compare(person1 o1, person1 o2) {
int levelRes = o1.getLevel() - o2.getLevel();
return levelRes == 0 ? o1.getAge() - o2.getAge() : levelRes;
}
}
效果图：
需求1+需求2：
package com.chendongli.set;
import java.util.Comparator;
import java.util.TreeSet;
/**
* set集合的排序
* java.lang.Comparable:自然排序接口 排序的规则单一 不能够应对复杂的变化的需求
* java.util.comparator:比较器排序
* @author zjjt
*
*/
public class Demo3 {
public static void main(String[] args) {
/**
* 需求1：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
* 张三 部门总监 1
* 李四 普通员工 4
* 王五 部门经理 2
* 老六 主管 3
*
* 需求2：按照年龄升序，打印出人员信息
*
* 需求3：按照用户的首字母排序
*/
//String
//TreeSet set = new TreeSet<>(new levelComparator());
//TreeSet<person1> set = new TreeSet<>((x,y)-> x.getName().compareTo(y.getName()));
TreeSet<person1> set = new TreeSet<>((x,y)-> {
int ageRes = x.getAge() - y.getAge();
int levelRes = 0;
if(ageRes == 0) {
levelRes = x.getLevel() - y.getLevel();
}
else {
return ageRes;
}
return levelRes;
});
set.add(new person1("zs", 18,1));
set.add(new person1("ls", 24,4));
set.add(new person1("ww", 26,2));
set.add(new person1("老六", 20,3));
set.add(new person1("八戒", 18,4));
for (Object object : set) {
System.out.println(object);
}
}
}
class person1 /*implements Comparable<person1>*/{
private String name;
private int age;
private int level;
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
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 person1() {
// TODO Auto-generated constructor stub
}
public person1(String name, int age, int level) {
super();
this.name = name;
this.age = age;
this.level = level;
}
@Override
public String toString() {
return "person1 [name=" + name + ", age=" + age + ", level=" + level + "]";
}
/*@Override
public int compareTo(person1 o) {
int levelRes = this.level - o.level;
return levelRes == 0 ? this.age - o.age : levelRes;
}*/
public static void main1(String[] args) {
/**
* 需求1：从第三方拿到用户数据 需要根据用户的级别，进行会议的座位排序
* 张三 部门总监 1
* 李四 普通员工 4
* 王五 部门经理 2
* 老六 主管 3
*
* 现象：
* 1.String默认是能够排序的
* 2.自定义的对象无法排序，报类型转换异常
*
* 需求2：按照年龄升序，打印出人员信息
*
* 需求3：按照用户的首字母排序
*/
//String
TreeSet set = new TreeSet<>();
set.add(new person1("zs", 18,1));
set.add(new person1("ls", 24,4));
set.add(new person1("ww", 26,2));
set.add(new person1("老六", 20,3));
set.add(new person1("八戒", 18,4));
for (Object object : set) {
System.out.println(object);
}
}
}
class levelComparator implements Comparator<person1>{
@Override
public int compare(person1 o1, person1 o2) {
int levelRes = o1.getLevel() - o2.getLevel();
return levelRes == 0 ? o1.getAge() - o2.getAge() : levelRes;
}
}
效果图：
好啦 这期分享到这里就结束啦 我们下次再见！
5807
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
