一、可变参数
package com.shujia.lhw.day19;
import java.util.Arrays;
import java.util.List;
/*
可变参数概述：
定义方法的时候不知道该定义多少个参数
格式：
修饰符 返回值类型 方法名（数据类型... 变量名）{}
注意：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
Arrays工具类中的一个方法
public static <T> List <T> asList(T... a)
*/
public class ArgsDemo {
public static void main(String[] args) {
//使用方法求两个数之和
int a = 10;
int b = 20;
sum(a, b);
//使用方法求三个数之和
int c = 30;
sum(a, b, c);
//使用方法求四个数之和
int d = 40;
sum(a, b, c, d);
sum("明旺", 90, 92, 93);
// sum(1,2,3,4,5,6,7,8,9);
//数组--->List(ArrayList)集合
List<String> strings = Arrays.asList("hello", "world", "java", "bigdata");
for (String s : strings) {
System.out.println(s);
}
}
//同一个方法定义中，可变参数只能出现一次
//public static void sum(int... ints1,int... ints2){
//}
//当使用可变参数定义方法的时候，有其他数据类型参与的时候，将可变参数的定义放在最后
public static void sum(String name,int... ints){
int sum = 0;
for (int i : ints) {
sum +=i;
}
System.out.println(name+"学生的总成绩为："+sum);
}
//使用可变参数的形式定义加法的方法
//注意可便参数的变量最终是一个数组的变量名
//这里将来传入多个参数的时候，内部会自动将这么多个参数形成一个数组，数组名就是我们定义的ints
public static void sum(int... ints){
int sum = 0;
for(int i :ints){
sum += i;
}
System.out.println(ints.length+"个数之和为："+sum);
}
// public static void sum(int a,int b,int c,int d){
// System.out.println("四个数之和为："+(a+b+c+d));
// }
// public static void sum(int a,int b, int c){
// System.out.println("三个数之和为："+(a+b+c));
// }
// public static void sum(int a,int b){
// System.out.println("两个数之和为："+(a+b));
// }
}
----------------------------------------------------------------------------------------------------------------------------
二、增强for循环遍历
package com.shujia.lhw.day19;
import java.util.ArrayList;
import java.util.ListIterator;
/*
JDK1.5之后出现的新特性：
到目前为止，学过哪些知识是JDK1.5之后出现的？
泛型，增强for，包装类，Scanner，枚举
增强for循环概述：简化数组和Collection集合的遍历
语句定义格式：
for(元素数据类型 变量名 (自定义) ：数组或者Collection集合){
使用变量即可，该变量就是元素
}
好处：简化遍历
*/
public class ForDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {1, 2, 3, 4, 5};
//普通for循环遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("使用增强for循环遍历数组：");
for (int i : arr) {
System.out.println(i);
}
System.out.println("===========================================");
ArrayList<String> strings = new ArrayList<>();
strings.add("hello");
strings.add("world");
strings.add("java");
strings.add("bigdata");
strings.add("hadoop");
for (String string : strings) {
System.out.println(string);
}
// strings = null;
// for (String string : strings) {//NullPointerException
// System.out.println(string);
// }
//我们应该在遍历之前判断一下是不是null
// if(strings!=null){
// for(String string:strings){
// System.out.println(string);
// }
// }else{
// System.out.println("该集合为：null");
// }
//其实增强for循环就是用来替代迭代器的
//怎么去验证它就是来替代迭代器的呢？
//使用并发修改异常验证
// for (String s : strings) {
// //ConcurrentModificationException
// if ("java".equals(s)) {
// strings.add("spark");
// }
// }
ListIterator<String> iterator = strings.listIterator();
while (iterator.hasNext()){
String next = iterator.next();
if("java".equals(next)){
iterator.add("spark");
}
}
System.out.println(strings);
}
}
---------------------------------------------------------------------------------------------------------------------------
三、泛型通配符<?>
package com.shujia.lhw.day19;
import java.util.ArrayList;
/*
泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E
向下限定，E及其子类
? super E
向上限定，E及其父类
*/
public class GenericDemo1 {
public static void main(String[] args) {
ArrayList<Animal> list1 = new ArrayList<Animal> ();
ArrayList<Dog> list2 = new ArrayList<Dog>();
ArrayList<Object> list3 = new ArrayList<Object>();
//泛型通配符<?>
//任意类型，如果没有明确，那么就是Object以及任意的java类了
ArrayList<?> list4 = new ArrayList<Animal>();
ArrayList<?> list5 = new ArrayList<Dog>();
ArrayList<?> list6 = new ArrayList<Object>();
//? Extends E 向下限定，E及其子类
ArrayList<? extends Animal> list7 = new ArrayList<Animal>();
ArrayList<? extends Animal> list8 = new ArrayList<Dog>();
ArrayList<? extends Animal> list9 = new ArrayList<Cat>();
// ArrayList<? extends Animal> list10 = new ArrayList<Object>();
//? super E 向上限定，E及其父类
ArrayList<? super Animal> list11 = new ArrayList<Animal>();
ArrayList<? super Animal> list12 = new ArrayList<Object>();
// ArrayList<? super Animal> list13 = new ArrayList<Dog>();
}
}
------------------------------------------------------------------------------------------------------------------------
四、GenericTest1
package com.shujia.lhw.day19;
/*
泛型类的测试
*/
public class GenericTest1 {
public static void main(String[] args) {
//如果不加泛型，默认使Object类型
// GenericTool1 gt1 = new GenericTool1();
// gt1.setObj("hello");
// gt1.setObj(20);
// gt1.setObj(12.34);
GenericTool1<String> gt2 = new GenericTool1<>();
gt2.setObj("hello");
// gt2.setObj(20);
String obj = gt2.getObj();
}
}
------------------------------------------------------------------------------------------------------------------------
五、GenericTest2
package com.shujia.lhw.day19;
public class GenericTest2 {
public static void main(String[] args) {
GenericTool2 genericTool2 = new GenericTool2();
genericTool2.show("hello");
genericTool2.show(10);
genericTool2.show(12.34);
}
}
------------------------------------------------------------------------------------------------------------------------------
六、泛型接口的测试
package com.shujia.lhw.day19;
/*
泛型接口的测试
*/
public class GenericTest3 {
public static void main(String[] args) {
GenericTool3lmpl<String> stringGenericTool3 = new GenericTool3lmpl<>();
stringGenericTool3.show("hello");
// stringGenericTool3.show(20);
}
}
---------------------------------------------------------------------------------------------------------------------------------
七、泛型类
package com.shujia.lhw.day19;
/*
泛型类
把泛型定义在类上
格式：public class 类名<泛型类型1,...>
注意：泛型类型必须是引用类型
这里的<>里面的内容仅仅表示的是一种参数数据类型，参数类型是一种变量
既然是一种变量，就要符合变量的命名规则，可以使任意符合标识符起名字规则的名字
一般情况下，在定义的时候，习惯用一个大写字母表示
*/
public class GenericTool1<T> {
private T obj;
public T getObj(){
return obj;
}
public void setObj(T obj){
this.obj = obj;
}
}
---------------------------------------------------------------------------------------------------------------------------------
八、泛型方法
package com.shujia.lhw.day19;
/*
泛型方法
把泛型定义在方法上
格式：public <泛型类型> 返回类型 方法名(泛型类型)
*/
public class GenericTool2 {
public void show(String s){
System.out.println(s);
}
public void show(int i){
System.out.println(i);
}
public void show(double d){
System.out.println(d);
}
//用泛型方法改进，将来不确定要传入什么类型的数据
public <F> void show(F f){
System.out.println(f);
}
}
---------------------------------------------------------------------------------------------------------------------------------
九、泛型接口
package com.shujia.lhw.day19;
/*
泛型接口
把泛型定义在接口上
格式：public interface 接口名<泛型类型1...>
*/
public interface GenericTool3<W> {
public void show(W w);
}
---------------------------------------------------------------------------------------------------------------------------------
十、
package com.shujia.lhw.day19;
public class GenericTool3lmpl<W> implements GenericTool3<W>{
@Override
public void show(W w){
System.out.println(w);
}
}
------------------------------------------------------------------------------------------------------------------------------
十一、LinkedHashSet
package com.shujia.lhw.day19;
import java.util.LinkedHashSet;
/*
public class HashSet<E> implements Set<E>
public class LinkedHashSet<E> extends HashSet<E> implements Set<E>
LinkedHashSet:
1、底层数据结构是哈希表和链表
2、哈希表保证元素的唯一
3、链表保证了元素的有序（存储和取出的顺序一致）
4、线程不安全，效率高
*/
public class LinkedHashSetDemo {
public static void main(String[] args) {
LinkedHashSet<String> set1 = new LinkedHashSet<>();
//添加元素到集合
set1.add("hello");
set1.add("world");
set1.add("java");
set1.add("bigdata");
set1.add("hadoop");
set1.add("world");
set1.add("java");
set1.add("hello");
set1.add("spark");
set1.add("spark");
set1.add("hbase");
set1.add("flink");
set1.add("java");
set1.add("hello");
//遍历
for(String s : set1){
System.out.println(s);
}
}
}
---------------------------------------------------------------------------------------------------------------------------
十二、集合的嵌套遍历
package com.shujia.lhw.day19;
import java.util.ArrayList;
import java.util.Iterator;
/*
集合的嵌套遍历
需求：目前，数加学院有十五期，十六期。每一期都有很多学生，每个学生都是一个学生对象，可以用一个集合表示一个班的
学生
十五期的学生：ArrayList<Student> classList15;
十六期的学生：ArrayList<Student> classList16;
无论是十五期还是十六期，都属于数加学院的班级
数加学院本身也可以通过集合表示：ArrayList<ArrayList<Student>> shujia;
这样的现象叫做集合嵌套。
*/
public class ListQianTaoTest {
public static void main(String[] args) {
//定义一个十五期的班级集合
ArrayList<Student> classList15 = new ArrayList<> ();
//定义一个十六期的班级集合
ArrayList<Student> classList16 = new ArrayList<> ();
//定义一个数加学院的集合
ArrayList<ArrayList<Student>> shujia = new ArrayList<>();
//将十五期和十六期添加到shujia集合中
shujia.add(classList15);
shujia.add(classList16);
//创建十五期的学生对象
Student s1 = new Student("明旺",18);
Student s2 = new Student("王宇",17);
Student s3 = new Student("周家祥",16);
Student s4 = new Student("张保桂",20);
//创建十六期的学生对象
Student s11 = new Student("小王",18);
Student s12 = new Student("小李",17);
Student s13 = new Student("小刘",19);
Student s14 = new Student("小杨",16);
//将十五期的学生对象添加到十五期集合中
classList15.add(s1);
classList15.add(s2);
classList15.add(s3);
classList15.add(s4);
//将十六期的学生对象添加到十六期集合中
classList16.add(s11);
classList16.add(s12);
classList16.add(s13);
classList16.add(s14);
//遍历
//增强for循环遍历
// for(ArrayList<Student> clazz : shujia){
// for (Student s : clazz){
// System.out.println(s);
// }
// }
//普通for循环遍历
for(int i = 0;i<shujia.size();i++){
if(i==0){
System.out.println("============十五期：===============");
for (int j = 0;j<shujia.get(i).size();j++){
Student student = shujia.get(i).get(j);
System.out.println(student);
}
}
}
System.out.println("=======================================================");
//迭代器遍历
Iterator<ArrayList<Student>> iterator = shujia.iterator();
while (iterator.hasNext()){
ArrayList<Student> clazz = iterator.next();
Iterator<Student> iterator1 = clazz.iterator();
while (iterator1.hasNext()){
Student student = iterator1.next();
System.out.println(student);
}
}
}
}
package com.shujia.lhw.day19;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
------------------------------------------------------------------------------------------------------------------------
十三、ListTest
package com.shujia.lhw.day19;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
/*
键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
1、由于不知道输入多少次所以用while循环进行输入
2、用集合存储数据
3、toArray()
4、Arrays.sort()
5、取最后一个元素就是最大值
*/
public class ListTest {
public static void main(String[] args) {
//键盘录入对象
Scanner sc = new Scanner(System.in);
//创建集合对象
ArrayList<Integer> list = new ArrayList<>();
boolean flag = true;
while (flag==true){
int number = sc.nextInt();
if (number==0){
flag=false;
System.out.println("数据录入完毕");
}else{
list.add(number);
}
}
//将集合转换成数组
Object[] objects = list.toArray();
Arrays.sort(objects);
System.out.println("最大值为："+objects[objects.length-1]);
}
}
-------------------------------------------------------------------------------------------------------------------------------
十四、RandomTest
package com.shujia.lhw.day19;
import java.util.ArrayList;
import java.util.Random;
/*
获取10个1-20之间的随机数，要求不能重复
1、由于我们不确定获取随机数的次数，长度不好确定，所以我们选择集合
2、随机数生成的方式：Random类：nextInt(int num):左闭右开
*/
public class RandomTest {
public static void main(String[] args) {
//1、创建随机数对象
Random random = new Random();
//2、创建集合对象存储随机数
ArrayList<Integer> list = new ArrayList<>();
// System.out.println(random.nextInt(20));
// int number = random.nextInt(20) + 1;
// System.out.println(number);
//定义一个变量统计集合中是否有10个元素
int count = 0;
while(count<10){
//生成随机数
int number = random.nextInt(20) + 1;
//判断集合中是否包含这个随机数
if (!list.contains(number)){
list.add(number);
count++;
}
}
System.out.println(list);
}
}
--------------------------------------------------------------------------------------------------------------------------------
十五、Set集合
package com.shujia.lhw.day19;
import java.util.HashSet;
import java.util.Set;
/*
Set集合：元素是唯一的，并且元素的顺序是无序的集合
在Set集合中存储的元素为什么不会有重复的呢？
*/
public class SetDemo1 {
public static void main(String[] args) {
Set<String> set1 = new HashSet<>();
//向集合中添加元素
set1.add("hello");
set1.add("world");
set1.add("java");
set1.add("bigdata");
set1.add("hadoop");
set1.add("world");
set1.add("java");
set1.add("hello");
set1.add("spark");
set1.add("spark");
set1.add("hbase");
set1.add("flink");
set1.add("java");
set1.add("hello");
//遍历
for(String s : set1){
System.out.println(s);
}
}
}
---------------------------------------------------------------------------------------------------------------------------------
package com.shujia.lhw.day19;
import java.util.HashSet;
import java.util.Set;
/*
用Set集合存储学生对象（当学生的姓名和年龄都一样的时候，判定是同一个学生）
*/
public class SetDemo2 {
public static void main(String[] args) {
//创建集合对象
Set<Student2> student2s = new HashSet<>();
//创建学生对象
Student2 s1 = new Student2("明旺",18);
Student2 s2 = new Student2("王宇",17);
Student2 s3 = new Student2("周家祥",16);
Student2 s4 = new Student2("明旺",18);
//将学生对象添加到集合中
student2s.add(s1);
student2s.add(s2);
student2s.add(s3);
student2s.add(s4);
//遍历
for (Student2 student2 : student2s) {
System.out.println(student2);
}
}
}
package com.shujia.lhw.day19;
import java.util.Objects;
public class Student2 {
private String name;
private int age;
public Student2() {
}
public Student2(String name, int age) {
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 boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student2 student2 = (Student2) o;
return age == student2.age && Objects.equals(name, student2.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student2{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
--------------------------------------------------------------------------------------------------------------------------------
十六、静态导入
package com.shujia.lhw.day19;
import static com.shujia.lhw.day19.StaticClass.fun;
import static com.shujia.lhw.day19.StaticClass.show;
import static java.lang.Math.abs;
import static java.lang.Math.pow;
/*
静态导入：
语句定义格式：import static 包名...类名.方法名;
可以直接导入到方法级别
注意事项：
1、方法必须是静态的
*/
public class StaticImportDemo {
public static void main(String[] args) {
//Math
System.out.println(abs(-100));
System.out.println(pow(2,3));
System.out.println(Math.max(100,200));
//有没有什么方法，不用写类名，直接写方法名？
// System.out.println(abs(-200));
//这时候就需要静态导入的技术
System.out.println(abs(-200));
System.out.println(pow(2,4));
fun();
//当静态导入的方法名与本类中的方法名冲突的时候，调用的是本类中的方法
show("spark");
//如果此时我们想使用静态导入的方法，怎么办呢？
// StaticClass.show("flink");
//将前缀路径写完整
com.shujia.lhw.day19.StaticClass.show("flink");
//当静态导入的方法名与本类中的方法名冲突的时候，我们发现，直接通过类名调用的方式会更加简单
//所以根据实际情况，选择使用静态导入
}
public static void show(String s){
System.out.println("这是在StaticImportDemo类中的show方法"+s);
}
}
package com.shujia.lhw.day19;
public class StaticClass {
public static void fun(){
System.out.println("数加科技，yyds");
}
public static void show(String s){
System.out.println(s);
}
}
------------------------------------------------------------------------------------------------------------------------------
十七、TreeSet
package com.shujia.lhw.day19;
import java.util.TreeSet;
/*
TreeSet:元素唯一，元素可以按照某种规则进行排序
两种排序方式：
自然排序
比较器排序
A NavigableSet实现基于TreeMap的原件的使用其有序natural ordering或由Comparetor集合创建时提供
这取决于所用的构造方法
为什么会进行去重以及排序呢？怎么排序呢？看源码
*/
public class TreeSetDemo1 {
public static void main(String[] args) {
//创建TreeSet平台
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(20);
treeSet.add(18);
treeSet.add(24);
treeSet.add(23);
treeSet.add(88);
treeSet.add(16);
treeSet.add(12);
treeSet.add(18);
treeSet.add(20);
treeSet.add(23);
treeSet.add(1);
treeSet.add(2);
//遍历
for (Integer i : treeSet) {
System.out.println(i);
}
// String s1 = "hello";
// String s2 = "hello";
// System.out.println(s1.compareTo(s2));
}
}
--------------------------------------------------------------------------------------------------------------------------------
十八、TreeSetDemo2
package com.shujia.lhw.day19;
import java.util.TreeSet;
/*
存储学生对象并遍历
按照正常的写法我们一运行就报错
java.lang.ClassCastException:类转换异常
由于我们这里TreeSet创建的时候，使用的是无参构造方法，走的是自然排序
而这里底层源码中有一步是向下转型的
Comparable<? super K> k = (Comparable<?super K>)key;报错了
原因是我们Student3没有实现Comparable接口，无法进行向下转型，所以报错了。
*/
public class TreeSetDemo2 {
public static void main(String[] args) {
//创建TreeSet集合
TreeSet<Student3> set = new TreeSet<>();
//创建学生对象
Student3 s1 = new Student3("theshy",20);
Student3 s2 = new Student3("xiaohu",24);
Student3 s3 = new Student3("uzi",25);
Student3 s4 = new Student3("kasa",22);
Student3 s5 = new Student3("rookie",23);
Student3 s6 = new Student3("zitai",21);
Student3 s7 = new Student3("faker",25);
Student3 s8 = new Student3("xiaohu",24);
//将学生对象添加到集合中
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
set.add(s7);
set.add(s8);
for (Student3 student3 : set) {
System.out.println(student3);
}
}
}
package com.shujia.lhw.day19;
public class Student3 implements Comparable<Student3>{
private String name;
private int age;
public Student3() {
}
public Student3(String name, int age) {
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 "Student3{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student3 o){
// return 0;
// return 1;
// return -1;
//这里返回什么应该根据我们自己定义的规则来排序
//比如我想在去重的前提下，按照年龄进行排序
// return this.age - o.age;
//年龄不一样，姓名不一定一样
//这里要区分主次条件（主要条件是业务明确给出的，次要条件是我们自己分析得出的）
int i = this.age - o.age;
//判断姓名是否一样（三目运算符）
int i2 = i == 0?this.name.compareTo(o.name): i;
return i2;
}
}
-----------------------------------------------------------------------------------------------------------------------------
十九、TreeSetDemo3
package com.shujia.lhw.day19;
import java.util.TreeSet;
/*
需求：TreeSet集合存储学生对象，并且以姓名的长度来排序
*/
public class TreeSetDemo3 {
public static void main(String[] args) {
//创建TreeSet集合对象
TreeSet<Student4> set = new TreeSet<>();
//创建学生对象
Student4 s1 = new Student4("mingwang",18);
Student4 s2 = new Student4("wangyu",19);
Student4 s3 = new Student4("zhoujiaxiang",17);
Student4 s4 = new Student4("zhangbaogui",18);
Student4 s5 = new Student4("liuzhicheng",18);
Student4 s6 = new Student4("wangyu",20);
//将学生对象添加到集合中
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
for (Student4 student4 : set) {
System.out.println(student4);
}
}
}
package com.shujia.lhw.day19;
public class Student4 implements Comparable<Student4>{
private String name;
private int age;
public Student4() {
}
public Student4(String name, int age) {
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 "Student4{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student4 o) {
// return 0;
//主要条件：姓名的长度排序
int i = this.name.length() - o.name.length();
// return i;
//长度一样，姓名内容不一定一样
int i2 = i == 0 ? this.name.compareTo(o.name) : i;
//姓名内容一样，年龄的大小不一定一样
int i3 = i2 == 0 ? this.age - o.age : i2;
return i3;
}
}
--------------------------------------------------------------------------------------------------------------------------
二十、TreeSetDemo4 比较器排序
package com.shujia.lhw.day19;
import java.util.Comparator;
import java.util.TreeSet;
/*
比较器排序
利用TreeSet创建对象时的带参数的构造方法来进行比较器排序
TreeSet(Comparator<? super E> comparator)
构造一个新的，空的树集，根据指定的比较器进行排序
*/
public class TreeSetDemo4 {
public static void main(String[] args) {
// MyComparator mc = new MyComparator();
// TreeSet<Student5> set = new TreeSet<>(mc);
//匿名内部类实现Comparator接口
TreeSet<Student5> set = new TreeSet<>(new Comparator<Student5>(){
@Override
public int compare(Student5 o1, Student5 o2) {
// return 0;
//主要条件：姓名的长度排序
int i = o1.getName().length() - o2.getName().length();
// return i;
//长度一样，姓名内容不一定一样
int i2 = i == 0 ? o1.getName().compareTo(o2.getName()) : i;
//姓名内容一样，年龄的大小不一定一样
int i3 = i2 ==0 ? o1.getAge() - o2.getAge() : i2;
return i3;
}
});
//创建学生对象
Student5 s1 = new Student5("mingwnag",18);
Student5 s2 = new Student5("wangyu",19);
Student5 s3 = new Student5("zhoujiaxiang",17);
Student5 s4 = new Student5("zhangbaogui",18);
Student5 s5 = new Student5("liuzhicheng",18);
Student5 s6 = new Student5("wangyu",20);
//将学生对象添加到集合中
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
//遍历
for (Student5 student5 : set) {
System.out.println(student5);
}
}
}
package com.shujia.lhw.day19;
public class Student5 {
private String name;
private int age;
public Student5() {
}
public Student5(String name, int age) {
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 "Student5{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.shujia.lhw.day19;
import java.util.Comparator;
public class MyComparator implements Comparator<Student5> {
@Override
public int compare(Student5 o1,Student5 o2){
//return 0;
//主要条件：姓名的长度排序
int i = o1.getName().length() - o2.getName().length();
// return i;
//长度一样，姓名内容不一定一样
int i2 = i == 0 ? o1.getName().compareTo(o2.getName()):i;
//姓名的内容一样，年龄的大小不一定一样
int i3 = i2 == 0 ? o1.getAge() - o2.getAge() : i2;
return i3;
}
}
扫一扫
946
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
