目录
Set
1、Set集合概述及特点:
public interface Set<E> extends Collection<E> 不包含重复元素的集合。 更正式地,集合不包含一对元素e1和e2 ,使得e1.equals(e2) ,并且最多一个空元素。
Set接口继承自Collection接口的所有构造函数(方法)。Set与Collection方法一模一样。
2、Set集合子类如何保证元素唯一?
HashSet
1、Set集合子类HashSet<E>概述:
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable ,此类实现Set接口,由哈希表(实际上是一个HashMap实例)支持。 它不保证set的迭代顺序; 特别是它不保证该顺序在一段时间内保持不变。此类允许使用null元素。翻译:存取顺序不一致,可以存储null。
2、案例演示:HashSet存储字符串并遍历。
import java.util.HashSet;
/**
* set集合中元素无索引,不可以重复,无序(存取顺序不一致)
*/
public class Demo1_HashSet {
public static void main(String[] args) {
HashSet<String> hs = new HashSet<>(); //创建HashSet对象。
boolean b1 = hs.add("a");
boolean b2 = hs.add("a"); //当向Set集合中存储重复元素的时候返回为false。
System.out.println(hs); //HashSet的继承体系中有重写toString方法
System.out.println(b1); //true
System.out.println(b2); //false
//HashSet的爷爷类AbstractCollection重写了toString()
/*public String toString() {
Iterator<E> it = iterator(); //获取迭代器
if (! it.hasNext()) //如果迭代器中没有元素
return "[]"; //返回[]
StringBuilder sb = new StringBuilder(); //如果有元素,创建StringBuilder
sb.append('['); //将元素不断进行添加
for (;;) {
E e = it.next();
sb.append(e == this ? "(this Collection)" : e);
if (! it.hasNext())
return sb.append(']').toString(); //最后将元素转换成toString给返回
sb.append(',').append(' ');
}
}*/
System.out.println("----------------------------------");
hs.add("d");
hs.add("c");
hs.add("b");
System.out.println(hs);
for (String string : hs) { //只要能使用迭代器迭代的,就可以使用增强for循环遍历。
System.out.println(string);
}
}
}
3、案例演示:HashSet存储自定义对象,并保证元素唯一性。
import java.util.HashSet;
import com.bean.Person;
public class Demo2_HashSet {
public static void main(String[] args) {
HashSet<Person> hs = new HashSet<>();
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));
//即使重写了自定义类中的equals方法,依然所有元素都在。因为并没有执行。
//重写了hashCode方法后,保证元素唯一了,我们并没有调equals方法,equals方法也跟着执行了。
//集合的每个对象元素进入集合的内存空间时,对象元素会自动调对应自定义类的hashCode()给自己算一个具体的hashCode值(地址值),每个对象的hashCode值都不一样所以不会调equals()进行比较。因为地址值都不一样,所以重复的对象都保留了。
//重写hashCode()给定一个固定的值(任意),不让自己算了。地址值相同的对象元素,调用equals()进行比较,如果元素属性值相同,则返回值是true,就不存了。如果元素属性不同,HashSet有桶结构,新元素会像桶一样挂在被比较的元素上。再进来的元素会先与挂着的元素比较。
System.out.println(hs.size());
System.out.println(hs);
}
}
重写hashCode()和equals()方法
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
public int hashCode() {
return 10;
}
代码优化:
为了减少比较,优化hashCode()代码写法。最终版就是自动生成即可。
Alt + Shift + S + H 自动生成hashCode()和equals()。
//这么复杂是为了少调用equals(),提高程序的运行效率。
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
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) { //调用对象的name属性为null,name是自定义对象的属性,是可以赋值为null的(不给赋值),不存在空指针异常。
if (other.name != null) //传入对象的name属性不为null
return false; //返回false
} else if (!name.equals(other.name))//调用对象的姓名不等于传入对象的姓名
return false; //返回false
return true; //返回true
}
prime等于31是因为:
31是一个质数,质数是仅能被1和自己整除的数,这样他的公约数就少了,就可以降低重复的可能性。
31这个数既不大也不小。大了,进行运算之后可能超过int的取值范围,小了,最后相乘的结果可能还是重复的。能不重复尽量不重复。
31这个数好算,2的5次方减1,2向左移动5位再减去一。
4、HashSet如何保证元素唯一性的原理:
1.HashSet原理:
我们使用Set集合都需要去掉重复元素,如果在存储的时候逐个元素调用equals()进行比较,效率较低。哈希算法提高了去重复的效率,降低了使用equals()的次数。
当HashSet调用add()方法存储对象的时候,先调用对象的hashCode()方法得到一个哈希值,然后在集合中查找是否有哈希值相同的对象。
如果没有哈希值相同的对象就直接存入集合。
如果有哈希值相同的对象,就和哈希值相同的对象逐个元素调用equals()进行属性值比较,比较结果为false就存入,为true则不存入。
2.将自定义类的对象存入HashSet去重复:
类中必须同时重写hashCode()和equals()。如果只重写了hashCode(),存储时hashCode值都不一样,但是比较equals()全都为false,因为equals()比较是按照对象的地址值进行比较的,所以重复的都没有去掉。
hashCode():属性值相同的对象返回值必须相同,属性值不同的对象返回值尽量不同(这样做是提高效率,降低使用equals())。尽量不同说明有几率一样,但尽量保证不一样。
equals():属性值相同返回true,属性值不同返回false,返回false的时候存储。
LinkedHashSet
1、LinkedHashSet概述:
public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, Serializable,哈希表和链表实现了Set接口,具有可预测的迭代次序。这种实现不同于HashSet,它维持于所有条 目的运行双向链表。该链表定义了迭代排序,它是将元素插入集合(插入顺序 ) 的顺序 。请注意,如果一个元件被重新插入到组插入顺序不受影响 。(元件e重新插入一组s如果当s.contains(e)将返回true之前立即调用s.add(e)被调用。)
普通方法全部继承自父类以及其间接父类。
java.util包下,使用需要导包。
可以保证怎么存就怎么取,且能保证元素唯一。LinkedHashSet底层是链表实现的,是Set集合中唯一一个能保证怎么存就怎么取的集合对象。因为是HashSet的子类,所以也是保证元素唯一的,与HashSet的原理一样。LinkedHashSet可以看成Linked和HashSet两部分。
如果没要求怎么存就怎么取,就用HashSet,HashSet效率稍微比LinkedHashSet高一点。
2、案例演示:产生10个1-20之间的随机数要求随机数不能重复。
需求:编写一个程序,获取10个1至20的随机数,要求随机数不能重复。并把最终的随机数输出到控制台。
import java.util.HashSet;
import java.util.Random;
/**
* 需求:编写一个程序,获取10个1至20的随机数,要求随机数不能重复。并把最终的随机数输出到控制台。
* 分析:
* 1.用Random类创建随机数对象。
* 2.需要存取10个随机数,而且不能重复。所以我们用HashSet集合。
* 3.条件:如果HashSet的size是小于10就可以不断地存储;如果大于等于10,就停止存储。
* 4.通过Random类中的nextInt(n)获取1到20之间的随机数,并将这些随机数存储在HashSet集合中。
* 5.遍历HashSet。
*/
public class Test1 {
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);
}
}
}
3、练习1:使用Scanner从键盘读取一行输入,去掉其中重复字符,打印出不同的那些字符:aaaabbbcccddd。
import java.util.HashSet;
import java.util.Scanner;
/**
* 练习:使用Scanner从键盘读取一行输入,去掉其中重复字符,打印出不同的那些字符:aaaabbbcccddd。
* 分析:
* 1.创建Scanner对象。
* 2.创建HashSet对象,将字符存储,去掉重复字符。
* 3.将字符串转换为字符数组,获取每一个字符存储在HashSet集合中,自动去除重复。
* 4.遍历HashSet集合,打印每一个字符。
*/
public class Test2 {
public static void main(String[] args) {
//1.创建Scanner对象。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一行字符串:");
//2.创建HashSet对象,将字符存储,去掉重复字符。
HashSet<Character> hs = new HashSet<>();
//3.将字符串转换为字符数组,获取每一个字符存储在HashSet集合中,自动去除重复。
String line = sc.nextLine();
char[] arr = line.toCharArray();
//遍历字符数组。
for (char c : arr) { //char自动装箱成包装类Character。所以也可以直接写Character。
hs.add(c);
}
//4.遍历HashSet集合,打印每一个字符。
for(Character ch : hs) {//同理,这里直接写char也是可以的,自动拆箱。集合存储对象,遍历是当char遍历。
System.out.print(ch);
}
}
}
4、练习2:将集合中的重复元素去掉。
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
/**
* 练习:将集合中的重复元素去掉。
* 分析:
* 1.创建一个List集合,存储若干个重复元素。
* 2.单独定义方法去除重复。
* 3.再打印一下List集合。
*/
public class Test3 {
public static void main(String[] args) {
//1.创建一个List集合,存储若干个重复元素。
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
list.add("c");
list.add("c");
//2.单独定义方法去除重复。
getSingle(list);
//3.再打印一下List集合。
System.out.println(list);
}
/**
* 分析:去除List集合中的重复元素。
* 1.创建一个LinkedHashSet集合。
* 2.将List集合中所有的元素添加到LinkedHashSet集合中。
* 3.将List集合中的元素清除。
* 4.将LinkedHashSet集合中的元素添加回List集合中。
*/
public static void getSingle(List<String> list) {
//1.创建一个LinkedHashSet集合。
LinkedHashSet<String> lhs = new LinkedHashSet<>();
//2.将List集合中所有的元素添加到LinkedHashSet集合中。
lhs.addAll(list);
//3.将List集合中的元素清除。
list.clear();
//4.将LinkedHashSet集合中的元素添加回List集合中。
list.addAll(lhs);
}
}
TreeSet
1、案例演示:TreeSet存储Integer类型的元素并遍历。
import java.util.TreeSet;
/**
* 案例演示:TreeSet存储Integer类型的元素并遍历。
* TreeSet集合是用来对元素进行排序的,同时也能保证元素的唯一。
*/
public class Demo3_TreeSet {
public static void main(String[] args) {
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);
}
}
2、TreeSet存储自定义对象。
import java.util.TreeSet;
import com.bean.Person;
/**
* 自定义类的对象需要具备比较性,让自定义类去实现Comparable接口,并重写compareTo方法。依赖此功能即可保证TreeSet中元素唯一。保证元素唯一其实都是依赖一些功能的。就像HashSet必须重写HashCode和equals方法。
* 当compareTo()返回0的时候,集合中只有一个元素。
* 当compareTo()返回正数的时候,集合会怎么存就怎么取(正序)。
* 当compareTo()返回负数的时候,集合会逆序存储。
*/
public class Demo4_TreeSet {
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("张三", 23)); //ClassCastException
ts.add(new Person("李四", 13));
ts.add(new Person("王五", 43));
ts.add(new Person("赵六", 33));
ts.add(new Person("张三", 23));
System.out.println(ts);
}
}
Comparable<T>接口概述:
public interface Comparable<T>,该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ,类的compareTo方法被称为其自然比较方法 。参数类型:T - 可以将此对象与之进行比较的对象类型。
Collections.sort (和Arrays.sort )可以自动对实现此接口的对象进行列表(和数组)排序。
Comparable<T>接口的普通方法:
int compareTo(T o),将此对象与指定的对象进行比较以进行排序。 返回一个负整数,零或正整数,因为该对象小于,等于或大于指定对象。
3、TreeSet自然存储自定义对象和保证元素唯一的原理:
根据compareTo返回值。TreeSet底层是二叉树。
二叉树:两个叉。小的存储在左边(返回正数),大的存储在右边(返回负数),相等就不存(返回0)。
因此compareTo(),在TreeSet集合中如何存储元素取决于compareTo()的返回值。
ⅰ.返回值为0,集合中只有一个元素。首先第一个元素进集合作为二叉树的根,第二个元素进来调用compareTo(),compareTo()返回值是0,不储存该元素,同理剩余元素也不存储。
ⅱ.返回值为-1(负数),集合会将存储的元素倒序。首先第一个元素进集合作为二叉树的根,第二个元素进来调用compareTo(),compareTo()返回值是-1,-1表示该元素比根元素要小,所以存储在根元素的左边,第三个元素进来调用compareTo()与根元素作比较,compareTo()返回值是-1;再与第二个元素作比较,compareTo()返回值还是-1,成为第二个元素的左子树。同理其余元素进集合依次从根向下比较,返回值是-1就成为最底层元素的左子树。取的时候,树底层左边元素是最小的,再逐层依次向上取。
ⅲ.返回值为1(正数),集合会怎么存就怎么取。首先第一个元素进集合作为二叉树的根,第二个元素进来调用compareTo(),compareTo()返回值是1,1表示该元素比根元素要大,所以存储在根元素的右边,第三个元素进来调用compareTo()与根元素作比较,compareTo()返回值是1;再与第二个元素作比较,compareTo()返回值还是1,成为第二个元素的右子树。同理其余元素进集合依次从根向下比较,返回值是1就成为最底层元素的右子树。取的时候,根元素是最小的,再逐层依次向下取。
总结:比根元素小的存左边,比根元素大的存右边。比根元素大,比右子树小的存右子树左边。
取的时候从左边最小的开始取,取完根元素,到根元素的右边,先看右子树有没有他的左子树,有就先取他的左子树,再取他本身。
举例:自定义对象实现Comparable接口后重写的compareTo():
//按照年龄排序 public int compareTo(Person o) { int num = this.age - o.age; //年龄是比较的主要条件 return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件 }
String中重写了compareTo方法:int compareTo(String anotherString) 按字典顺序比较两个字符串。
4、练习1:案例演示:TreeSet存储自定义对象并遍历练习1(按照姓名排序)
import java.util.TreeSet;
import com.bean.Person;
/**
* 案例演示:TreeSet存储自定义对象并遍历练习1(按照姓名排序)
*/
public class Test4 {
public static void main(String[] args) {
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); //24352
System.out.println('李' + 0); //26446
System.out.println('王' + 0); //29579
System.out.println('赵' + 0); //36213
System.out.println(ts);
}
}
自定义类中重写的compareTo()
//按照姓名排序
public int compareTo(Person o) {
int num = this.name.compareTo(o.name); //姓名是比较的主要条件
return num == 0 ? this.age - o.age : num; //年龄是比较的次要条件
}
5、练习2:案例演示:TreeSet存储自定义对象并遍历练习2(按照姓名的长度排序)
import java.util.TreeSet;
import com.bean.Person;
/**
* 案例演示:TreeSet存储自定义对象并遍历练习2(按照姓名的长度排序)
*/
public class Test5 {
public static void main(String[] args) {
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);
}
}
自定义类中重写的compareTo()
//按照姓名的长度排序
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; //年龄是比较的次要条件
}
6、比较器排序:
案例演示:TreeSet保证元素唯一和比较器排序的原理及代码实现。
import java.util.Comparator;
import java.util.TreeSet;
/**
* 案例演示:TreeSet保证元素唯一和比较器排序的原理及代码实现。
*/
public class Test6 {
public static void main(String[] args) {
//需求:将字符串按照长度排序
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);
}
}
class CompareByLen implements Comparator<String> { //CompareByLen使我们自己定义的比较器。
//重写了compare(),之所以没重写equals()也没报错,是因为所有类默认继承Object。所以从对象类里继承了equals方法。实现接口时,只要有该方法即可。
public int compare(String s1, String s2) { //按照字符串的长度比较
int num = s1.length() - s2.length(); //长度为比较的主要条件
return num == 0 ? s1.compareTo(s2) : num; //内容为比较的主要条件
}
}
首先,第一个元素进树集作根元素。第二个元素进树集,为s1,根元素为s2,用s1的长度减去s2的长度,跟compareTo()原理相同,正右负左零不存。第三个元素进树集,为s1,根元素为s2,用s1的长度减去s2的长度,正右负左零不存,如果第三个元素与第二个元素符号相同(正、负或0),则出现在根元素的同一边,即需要再做一次比较。此时,第三个元素为s1,第二个元素为s2,用s1的长度再减去s2的长度,正右负左零不存。其余元素与之前原理相同。
总结:谁来调用这个实现了Comparator接口的方法谁就是s1,集合中的元素就是s2。也是Compare()的返回值决定了排序方法,正右负左零不存。
7、TreeSet的构造方法:
TreeSet(Comparator<? super E> comparator) 构造一个新的,空的TreeSet(树集),根据指定的比较器进行排序。
Comparator<T>接口概述:
public interface Comparator<T>,比较功能,对一些对象的集合施加了一个整体排序 。 可以将比较器传递给排序方法(如Collections.sort或Arrays.sort ),以便对排序顺序进行精确控制。java.util包下,需要导包。
Comparator<T>接口方法:
int compare(T o1, T o2) 比较其两个参数的顺序。 返回负整数,零或正整数,因为第一个参数小于,等于或大于第二个参数。跟compareTo的原理相同,正右负左零不存。
boolean equals(Object obj) 指示某个其他对象是否等于此比较器。 该方法必须遵守Object.equals(Object)的一般合同。 另外, 只有指定的对象也是一个比较器,这个方法只能返回true ,并且它与这个比较器的顺序相同。
8、TreeSet原理:
1.特点:
TreeSet是用来排序的,可以指定一个顺序,对象存入之后会按照指定的顺序排列。TreeSet有两种排序方式:自然排序和比较器排序。
2.使用方式:
ⅰ.自然顺序(Comparable) 需要你存储的这个类去实现Comparable接口,这个类创建的对象要具备一个比较的功能(重写Comparable接口内的compareTo())。
原理:
TreeSet类的add()方法中会把存入的对象提升为Comparable类型。不实现Comparable接口,就会报类型转换异常异常。
调用对象的compareTo()和集合中的对象比较。哪个元素存进去,谁就调compareTo()。把集合中的元素当做参数传进来与调用该方法的元素进行比较。
根据compareTo()返回的结果进行存储(正右负左零不存)。
ⅱ.比较器顺序(Comparator)。
原理:
创建TreeSet的时候可以制定 一个Comparator。
如果传入了Comparator的子类对象,那么TreeSet就会按照比较器中的顺序排序。
add()方法内部会自动调用Comparator接口中compare()排序。
调用对象的是compare方法的第一个参数,集合中的对象是compare方法的第二个参数。
ⅲ.两种方式的区别:
TreeSet构造函数什么都不传,默认按照类中Comparable的顺序去比较(没有Comparable就报ClassCastException)。
TreeSet如果传入Comparator比较器,就会优先按照Comparator去排序。
9、比较器练习1:在一个集合中存储了无序并且重复的字符串,定义一个方法,让其有序(字典顺序),而且还不能去除重复。
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
/**
* 练习:在一个集合中存储了无序并且重复的字符串,定义一个方法,让其有序(字典顺序),而且还不能去除重复。
* 分析:
* 1.定义一个List集合,并存储重复的无序的字符串。
* 2.定义方法对其排序,保留重复。
* 3.打印List集合。
*/
public class Test7 {
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("fffffffffff");
list.add("niubi");
list.add("itcast");
list.add("bbbb");
list.add("aaa");
list.add("aaa");
//2.定义方法对其排序,保留重复。
sort(list);
//3.打印List集合。
System.out.println(list);
}
/**
* 定义方法,排序并保留重复。
* 分析:
* 1.创建TreeSet集合对象。因为String本身就具备比较功能,但是重复不会保留,所以我们用比较器。
* 2.将list集合中所有的元素添加到TreeSet集合中,对其排序,保留重复。
* 3.清空list集合。
* 4.将TreeSet集合中排好序的元素添加到List集合中。
*/
public static void sort(List<String> list) {
//1.创建TreeSet集合对象。因为String本身就具备比较功能,但是重复不会保留,所以我们用比较器。
TreeSet<String> ts = new TreeSet<>(new Comparator<String>() { //new Comparator<>(){}代表Comparator的子类对象(实现了Comparator接口的方法)。匿名内部类。
public int compare(String s1, String s2) {
int num = s1.compareTo(s2); //比较内容为主要条件
return num == 0 ? 1 : num; //保留重复
}
});
//2.将list集合中所有的元素添加到TreeSet集合中,对其排序,保留重复。
ts.addAll(list);
//3.清空list集合。
list.clear();
//4.将TreeSet集合中排好序的元素添加到List集合中。
list.addAll(ts);
}
}
10、比较器练习2:从键盘接收一个字符串,程序对其中所有字符进行排序,例如键盘输入:helloitcast。程序打印:acehillostt。
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/**
* 练习:从键盘接收一个字符串,程序对其中所有字符进行排序,例如键盘输入:helloitcast。程序打印:acehillostt。
* 分析:
* 1.键盘录入字符串,Scanner。
* 2.将字符串转换成字符数组。
* 3.定义TreeSet集合,传入比较器对字符排序并保留重复。
* 4.遍历字符数组,将每一个字符存储在TreeSet集合中。
* 5.遍历TreeSet集合,打印每一个字符。
*/
public class Test8 {
public static void main(String[] args) {
//1.键盘录入字符串,Scanner。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String line = sc.nextLine();
//2.将字符串转换成字符数组。
char[] arr = line.toCharArray();
//3.定义TreeSet集合,传入比较器对字符排序并保留重复。
TreeSet<Character> ts = new TreeSet<>(new Comparator<Character>() {
public int compare(Character c1, Character c2) {
// int num = c1.compareTo(c2); //作用相同
int num = c1 - c2; //自动拆箱,转换成int数运算
return num == 0 ? 1 : num;
}
});
//4.遍历字符数组,将每一个字符存储在TreeSet集合中。
for(char c : arr) {
ts.add(c); //自动装箱
}
//5.遍历TreeSet集合,打印每一个字符。
for(Character c : ts) {
System.out.print(c);
}
}
}
Character重写了compareTo():
public int compareTo(character anotherCharacter) 根据数字比较两个 Character对象。所以直接TreeSet存储char字符元素,重复也会直接被干掉,所以只能写一个比较器。八种数据类型包装类都实现了Comparable并重写了comparet()。
11、练习:程序启动后,可以从键盘输入接收多个整数,直到输入quit时结束输入。把所有输入的整数倒序排列打印。
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/**
* 练习:程序启动后,可以从键盘输入接收多个整数,直到输入quit时结束输入。把所有输入的整数倒序排列打印。
* 分析:
* 1.创建Scanner对象,键盘录入。
* 2.创建TreeSet集合对象,TreeSet集合中传入比较器。
* 3.无限循环不断接收整数,遇到quit退出。因为退出时quit,所以键盘录入的时候应该都以字符串的形式录入。
* 4.判断是quit就退出,不是就将其转换为Integer,并添加到集合中。
* 5.遍历TreeSet集合并打印每一个元素。
*/
public class Test9 {
public static void main(String[] args) {
//1.创建Scanner对象,键盘录入。
Scanner sc = new Scanner(System.in);
System.out.println("请输入多个整数:");
//2.创建TreeSet集合对象,TreeSet集合中传入比较器。
TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
public int compare(Integer i1, Integer i2) {
// int num = i2 - i1; //自动拆箱,倒序排列。
int num = i2.compareTo(i1);
return num == 0 ? 1 : num;
}
});
//3.无限循环不断接收整数,遇到quit退出。因为退出时quit,所以键盘录入的时候应该都以字符串的形式录入。
while(true) {
String line = sc.nextLine(); //将键盘录入的字符串存储在line中 。
//4.判断是quit就退出,不是就将其转换为Integer,并添加到集合中。
if("quit".equals(line)) {
break;
}
try {
Integer i = Integer.parseInt(line); //将数字字符串转换成数字c,自动装箱。
ts.add(i);
} catch (Exception e) {
System.out.println("您录入的数据有误,请输入一个整数:");
}
}
//5.遍历TreeSet集合并打印每一个元素。
for (Integer integer : ts) {
System.out.println(integer);
}
}
}
12、案例演示:键盘录入学生信息按照总分排序后输出在控制台。
需求:键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
import com.bean.Student;
/**
* 需求:键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。
* 分析:
* 1.定义一个学生类。
* 成员变量:姓名,语文成绩,数学成绩,英语成绩,总成绩。
* 成员方法:空参、有参构造,有参构造的参数分别是姓名,语文成绩,数学成绩,英语成绩。toString(),在遍历集合中的Student对象、打印对象引用的时候显示属性值。
* 2.键盘录入Scanner,创建键盘录入对象。
* 3.创建TreeSet集合对象,在TreeSet的构造函数中传入比较器,按照总分比较。
* 4.录入五个学生,并以集合中的学生个数为判断条件,如果size小于五就进行存储。
* 5.将录入的字符串用逗号切割,会返回一个字符串数组,将字符串数组中的元素从第二个元素开始转换成int数。
* 6.将转换后的节后封装成Student对象,将Student对象添加到TreeSet集合中。
* 7.遍历TreeSet集合,打印每一个Student对象。
*/
public class Test10 {
public static void main(String[] args) {
//2.键盘录入Scanner,创建键盘录入对象。
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生成绩:(格式:姓名,语文成绩,数学成绩,英语成绩)");
//3.创建TreeSet集合对象,在TreeSet的构造函数中传入比较器,按照总分比较。
TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
public int compare(Student s1, Student s2) {
int num = s2.getSum() - s1.getSum();
return num == 0 ? 1 : num;
}
});
//4.录入五个学生,并以集合中的学生个数为判断条件,如果size小于五就进行存储。
while(ts.size() < 5) {
//5.将录入的字符串用逗号切割,会返回一个字符串数组,将字符串数组中的元素从第二个元素开始转换成int数。
String line = sc.nextLine();
try {
String[] arr = line.split(",");
int chinese = Integer.parseInt(arr[1]); //转换语文成绩
int math = Integer.parseInt(arr[2]); //转换数学成绩
int english = Integer.parseInt(arr[3]); //转换英语成绩
//6.将转换后的节后封装成Student对象,将Student对象添加到TreeSet集合中。
ts.add(new Student(arr[0], chinese, math, english));
} catch (Exception e) {
System.out.println("录入格式有误,输入5个学生成绩格式是:(姓名,语文成绩,数学成绩,英语成绩");
}
}
//7.遍历TreeSet集合,打印每一个Student对象。
System.out.println("排序后的学生信息:");
for (Student s : ts) {
System.out.println(s);
}
}
}
自定义类:
public class Student {
private String name;
private int chinese;
private int math;
private int english;
private int sum;
public Student() {
super();
}
public Student(String name, int chinese, int math, int english) {
super();
this.name = name;
this.chinese = chinese;
this.math = math;
this.english = english;
this.sum = this.chinese + this.math + this.english;
}
public int getSum() {
return sum;
}
public String toString() {
return name + "," + chinese + "," + math + "," + english + "," + sum;
}
}
List和Set迭代方式的区别:
1、List(4种迭代方式)
普通for循环, 使用get()逐个获取。
调用iterator()方法得到Iterator, 使用hasNext()和next()方法。
增强for循环, 只要可以使用Iterator的类都可以用。
Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法。
2、Set
a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法。
b.增强for循环, 只要可以使用Iterator的类都可以用。
3、总结:
只要能用迭代器迭代的,都能用增强for循环遍历。