不仅要会使用集合的方法,还要对它们底层的数据结构实现原理有一定的了解。
Set集合,无索引,不可以重复,无序(存取不一致)
这里主要总结HashSet,LinkedHashSet,TreeSet
HashSet:
只有重写hashCode方法(此方法不能固定,应尽量减少重复值,相同对象hashCode值相同,再调用equals方法比较属性值),才能保证HashSet集合里面对象的唯一性
import java.util.HashSet;
public class Test {
/**
* @param args
* Set集合,无索引,不可以重复,无序(存取不一致)
*/
public static void main(String[] args) {
//demo1();
HashSet<Person> hs = new HashSet<Person>();
hs.add(new Person("张三", 23));
hs.add(new Person("张三", 23));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
hs.add(new Person("李四", 24));
//System.out.println(hs.size());
System.out.println(hs);
}
public static void demo1() {
HashSet<String> hs = new HashSet<String>(); //创建HashSet对象
boolean b1 = hs.add("a");
boolean b2 = hs.add("a"); //当向set集合中存储重复元素的时候返回为false
hs.add("b");
hs.add("c");
hs.add("d");
System.out.println(hs); //HashSet的继承体系中有重写toString方法
System.out.println(b1);
System.out.println(b2);
for (String string : hs) { //只要能用迭代器迭代的,就可以使用增强for循环遍历
System.out.println(string);
}
}
}
class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
super();
}
public Person(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 String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
/*@Override
public boolean equals(Object obj) {
System.out.println("执行了吗");
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
@Override
public int hashCode() {
final int NUM = 38;
return name.hashCode() * NUM + age;
}*/
/*
* 为什么是31?
* 1,31是一个质数,质数是能被1和自己本身整除的数
* 2,31这个数既不大也不小
* 3,31这个数好算,2的五次方-1,2向左移动5位
*/
@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; //直接返回true
if (obj == null) //传入的对象为null
return false; //返回false
if (getClass() != obj.getClass()) //判断两个对象对应的字节码文件是否是同一个字节码
return false; //如果不是直接返回false
Person other = (Person) obj; //向下转型
if (age != other.age) //调用对象的年龄不等于传入对象的年龄
return false; //返回false
if (name == null) { //调用对象的姓名为null
if (other.name != null) //传入对象的姓名不为null
return false; //返回false
} else if (!name.equals(other.name)) //调用对象的姓名不等于传入对象的姓名
return false; //返回false
return true; //返回true
}
/*@Override
//按照年龄排序
public int compareTo(Person o) {
int num = this.age - o.age; //年龄是比较的主要条件
return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件
}*/
/*@Override
//按照姓名排序
public int compareTo(Person o) {
int num = this.name.compareTo(o.name); //姓名是主要条件
return num == 0 ? this.age - o.age : num; //年龄是次要条件
}*/
/*
* aaa
* bbb
*/
public int compareTo(Person o) {
int length = this.name.length() - o.name.length(); //比较长度为主要条件
int num = length == 0 ? this.name.compareTo(o.name) : length; //比较内容为次要条件
return num == 0 ? this.age - o.age : num; //比较年龄为次要条件
}
}
输出:
[Person [name=张三, age=23], Person [name=李四, age=24]]
LinkedHashSet:
继承自HashSet,保证元素唯一性,底层由链表实现,是Set集合中唯一可以保证怎么存就怎么取的集合对象,元素增删快,查找慢.
举个随机数的例子:用LinkedHashSet也行,不过是随机的,没必要保持产生的随机数的顺序.
import java.util.HashSet;
import java.util.Random;
public class Test {
/**
* 获取10个1至20的随机数,要求随机数不能重复。并把最终的随机数输出到控制台。
*
* 1,有Random类创建随机数对象
* 2,需要存储10个随机数,而且不能重复,所以我们用HashSet集合
* 3,如果HashSet的size是小于10就可以不断的存储,如果大于等于10就停止存储
* 4,通过Random类中的nextInt(n)方法获取1到20之间的随机数,并将这些随机数存储在HashSet集合中
* 5,遍历HashSet
*/
public static void main(String[] args) {
//1,有Random类创建随机数对象
Random r = new Random();
//2,需要存储10个随机数,而且不能重复,所以我们用HashSet集合
HashSet<Integer> hs = new HashSet<>();
//3,如果HashSet的size是小于10就可以不断的存储,如果大于等于10就停止存储
while(hs.size() < 10) {
//4,通过Random类中的nextInt(n)方法获取1到20之间的随机数,并将这些随机数存储在HashSet集合中
hs.add(r.nextInt(20) + 1);
}
// 5,遍历HashSet
for (Integer integer : hs) {
System.out.println(integer);
}
}
}
字符串去重:
import java.util.LinkedHashSet;
import java.util.Scanner;
public class Test {
/**
* * 使用Scanner从键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符
* 1,创建Scanner对象
* 2,创建LinkedHashSet对象,将字符存储,去掉重复
* 3,将字符串转换为字符数组,获取每一个字符存储在LinkedHashSet集合中,自动去除重复
* 4,遍历LinkedHashSet,打印每一个字符
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//2,创建LinkedHashSet对象,将字符存储,去掉重复
LinkedHashSet<Character> hs = new LinkedHashSet<>();
//3,将字符串转换为字符数组,获取每一个字符存储在LinkedHashSet集合中,自动去除重复
String line = sc.nextLine();
char[] arr = line.toCharArray();
for (char c : arr) { //遍历字符数组
hs.add(c);
}
//4,遍历LinkedHashSet,打印每一个字符
for(Character ch : hs) {
System.out.print(ch);
}
}
}
输入:
qweqwe
输出:
qwe
TreeSet:底层是由二叉树实现的,是用来给里面的元素排序的,同样可以保证元素的唯一性.
注意代码中排序的实现(要自己根据实际情况实现Comparable接口,并重写compareTo方法),详情见代码注释
自然排序:要自己根据实际情况实现Comparable接口,并重写compareTo方法,根据compareTo()方法的返回结果进行存储。排序输出。
比较器排序(优先):实例化TreeSet集合时要传入Comparator的子类对象,add()方法内部会自动调用Comparator接口中的Compare()方法排序
比较器排序的原理:
import java.util.Comparator;
import java.util.TreeSet;
public class Test {
/**
* @param args
* TreeSet集合是用来对象元素进行排序的,同样他也可以保证元素的唯一
* 当compareTo方法返回0的时候集合中只有一个元素
* 当compareTo方法返回正数的时候集合会怎么存就怎么取
* 当compareTo方法返回负数的时候集合会倒序存储
*/
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
//需求:将字符串按照长度排序
TreeSet<String> ts = new TreeSet<>(new CompareByLen()); //Comparator c = new CompareByLen();
ts.add("aaaaaaaa");
ts.add("z");
ts.add("wc");
ts.add("nba");
ts.add("cba");
System.out.println(ts);
}
public static void demo4() {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("zhangsan", 23));
ts.add(new Person("lisi", 13));
ts.add(new Person("wangwu", 33));
ts.add(new Person("zhaoliu", 43));
ts.add(new Person("aaaa", 53));
System.out.println(ts);
}
public static void demo3() {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("李四", 13));
ts.add(new Person("张三", 23));
ts.add(new Person("王五", 43));
ts.add(new Person("赵六", 33));
System.out.println('张' + 0);
System.out.println('李' + 0);
System.out.println('王' + 0);
System.out.println('赵' + 0);
System.out.println(ts);
}
public static void demo2() {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("张三", 23));
ts.add(new Person("李四", 13));
ts.add(new Person("周七", 13));
ts.add(new Person("王五", 43));
ts.add(new Person("赵六", 33));
System.out.println(ts);
}
public static void demo1() {
TreeSet<Integer> ts = new TreeSet<>();
ts.add(3);
ts.add(1);
ts.add(1);
ts.add(2);
ts.add(2);
ts.add(3);
ts.add(3);
System.out.println(ts);
}
}
class CompareByLen /*extends Object*/ implements Comparator<String> {
@Override
public int compare(String s1, String s2) { //按照字符串的长度比较
int num = s1.length() - s2.length(); //长度为主要条件
return num == 0 ? s1.compareTo(s2) : num; //内容为次要条件
}
}
class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
super();
}
public Person(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 String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
/*@Override
public boolean equals(Object obj) {
System.out.println("执行了吗");
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
@Override
public int hashCode() {
final int NUM = 38;
return name.hashCode() * NUM + age;
}*/
/*
* 为什么是31?
* 1,31是一个质数,质数是能被1和自己本身整除的数
* 2,31这个数既不大也不小
* 3,31这个数好算,2的五次方-1,2向左移动5位
*/
@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; //直接返回true
if (obj == null) //传入的对象为null
return false; //返回false
if (getClass() != obj.getClass()) //判断两个对象对应的字节码文件是否是同一个字节码
return false; //如果不是直接返回false
Person other = (Person) obj; //向下转型
if (age != other.age) //调用对象的年龄不等于传入对象的年龄
return false; //返回false
if (name == null) { //调用对象的姓名为null
if (other.name != null) //传入对象的姓名不为null
return false; //返回false
} else if (!name.equals(other.name)) //调用对象的姓名不等于传入对象的姓名
return false; //返回false
return true; //返回true
}
/*@Override
//按照年龄排序
public int compareTo(Person o) {
int num = this.age - o.age; //年龄是比较的主要条件
return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件
}*/
/*@Override
//按照姓名排序
public int compareTo(Person o) {
int num = this.name.compareTo(o.name); //姓名是主要条件
return num == 0 ? this.age - o.age : num; //年龄是次要条件
}*/
/*
* aaa
* bbb
*/
public int compareTo(Person o) {
int length = this.name.length() - o.name.length(); //比较长度为主要条件
int num = length == 0 ? this.name.compareTo(o.name) : length; //比较内容为次要条件
return num == 0 ? this.age - o.age : num; //比较年龄为次要条件
}
}
输出:
[z, wc, cba, nba, aaaaaaaa]
实例1:
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
public class Test {
/**
* 在一个集合中存储了无序并且重复的字符串,定义一个方法,让其有序(字典顺序),而且还不能去除重复
* 1,定义一个List集合,并存储重复的无序的字符串
* 2,定义方法对其排序保留重复
* 3,打印List集合
*/
public static void main(String[] args) {
//1,定义一个List集合,并存储重复的无序的字符串
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("aaa");
list.add("ccc");
list.add("ddd");
list.add("fff");
list.add("eee");
list.add("ggg");
list.add("bbb");
list.add("aaa");
list.add("aaa");
//2,定义方法对其排序保留重复
sort(list);
//3,打印list
System.out.println(list);
}
/*
* 定义方法,排序并保留重复
* 分析:
* 1,创建TreeSet集合对象,因为String本身就具备比较功能,但是重复不会保留,所以我们用比较器
* 2,将list集合中所有的元素添加到TrreSet集合中,对其排序,保留重复
* 3,清空list集合
* 4,将TreeSet集合中排好序的元素添加到list中
*/
public static void sort(List<String> list) {
//1,创建TreeSet集合对象,因为String本身就具备比较功能,但是重复不会保留,所以我们用比较器
//这里用到了匿名内部类
TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
int num = s1.compareTo(s2); //比较内容为主要条件
return num == 0 ? 1 : num; //保留重复,返回0代表不能存进去,所以改为1这个正整数
}
});
//2,将list集合中所有的元素添加到TrreSet集合中,对其排序,保留重复
ts.addAll(list);
//3,清空list集合
list.clear();
//4,将TreeSet集合中排好序的元素添加到list中
list.addAll(ts);
}
}
输出:
[aaa, aaa, aaa, aaa, bbb, ccc, ddd, eee, fff, ggg]