网站建设ftp软件,怎么建立公司网站?,拓者吧装修效果图,平台引流推广怎么做单列集合 及 数据结构 13.1 集合体系结构13.1.2 单列集合1. Collection2.Collection 的遍历方式迭代器遍历增强for遍历Lambda表达式遍历 3.List集合List集合的特有方法List集合的遍历方式五种遍历方式对比 4.数据结构1).栈2).队列3#xff09;数组4#xff09;链表小结5… 单列集合 及 数据结构 13.1 集合体系结构13.1.2 单列集合1. Collection2.Collection 的遍历方式迭代器遍历增强for遍历Lambda表达式遍历 3.List集合List集合的特有方法List集合的遍历方式五种遍历方式对比 4.数据结构1).栈2).队列3数组4链表小结5树6二叉查找树7平衡二叉树平衡二叉树旋转机制——左旋平衡二叉树旋转机制——右旋平衡二叉树需要旋转的四种情况 8红黑树添加节点的规则 5.ArrayList集合1.ArrayList集合底层原理2.LinkedList集合3.迭代器底层源码解析 6.泛型深入1泛型概述2泛型类3泛型方法4泛型接口5泛型的继承和通配符总结 7.Set系列集合1HashSet2LinkedHashSet3TreeSet 8.单列集合使用场景 13.1 集合体系结构 13.1.2 单列集合 List系列集合添加的元素是有序、可重复、有索引。Set系列集合添加的元素是无序、不重复、无索引。
1. Collection
Collection 是单列集合的祖宗接口它的功能是全部单列集合都可以继承使用的。
public static void main(String[] args) {/*注意点* Collection 是一个接口我们不能直接创建他的对象。* 所以在学习它的方法时只能创建他实现类的对象* 实现类ArrayList** 目的为了学习Collection接口里面的方法。*/CollectionString coll new ArrayList();//0.添加元素System.out.println(-------------0.添加元素-------------);/*细节1如果要往List系列集合中添加数据那么方法永远返回true因为List系列的是允许元素重复的。* 细节2如果要往Set系列集合中添加数据如果当前要添加元素不存在方法返回true表示添加成功。* 如果当前要添加的元素已经存在方法返回false表示添加失败* 因为Set系列的集合不允许重复。*/coll.add(zhangsan);coll.add(aaa);coll.add(bbb);coll.add(ccc);System.out.println(coll); // [zhangsan, aaa, bbb, ccc]//1.清空System.out.println(-------------1.清空-------------);
// coll.clear();System.out.println(coll); // []//2.删除//细节1因为Collection里面定义的是共性的方法所以此时不能通过索引删除只能通过元素的对象进行删除。//细节2方法会有一个返回值删除成功返回true删除失败返回false。System.out.println(-------------2.删除-------------);coll.remove(aaa);System.out.println(coll); // [zhangsan, bbb, ccc]//3.判断元素是否包含/*细节底层是依赖equals方法进行判断是否存在的。* 所以如果集合中存储的是自定义对象也想通过contains方法来判断是否包含那么在javabean类中一定要重写equals方法*/System.out.println(-------------3.判断元素是否包含-------------);System.out.println(coll.contains(aaa)); //falseSystem.out.println(coll.contains(bbb)); // trueSystem.out.println(------------------------------------------);//4.判断是否为空System.out.println(-------------3.判断元素是否包含-------------);System.out.println(coll.isEmpty()); //falseSystem.out.println(------------------------------------------);//5.获取集合的长度int size coll.size();System.out.println(size); // 3}Contains方法 细节
public static void main(String[] args) {//0.创建集合对象CollectionStudent coll new ArrayList();//1.创建三个学生对象Student s1 new Student(zhangsan, 23);Student s2 new Student(lisi, 25);Student s3 new Student(wangwu, 26);//2.把学生对象添加到集合中coll.add(s1);coll.add(s2);coll.add(s3);//3.判断集合中某一个学生对象是否包含Student s4 new Student(zhangsan, 23);/*因为contains方法在底层依赖equals方法判断对象是否一致的。如果存的是自定义对象没有重写equals方法那么默认使用Object类中的equals方法进行判断而Object类中equals方法依赖地址值进行判断。* 需求如果同姓名和同年龄就认为是同一个学生。所以需要在自定义的Javabean类中重写equals方法就可以了。*/System.out.println(coll.contains(s4));}public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name name;this.age age;}/*** 获取* return name*/public String getName() {return name;}/*** 设置* param name*/public void setName(String name) {this.name name;}/*** 获取* return age*/public int getAge() {return age;}/*** 设置* param age*/public void setAge(int age) {this.age age;}Overridepublic boolean equals(Object o) {if (this o) return true;if (o null || getClass() ! o.getClass()) return false;Student student (Student) o;return age student.age Objects.equals(name, student.name);}public String toString() {return Student{name name , age age };}
}2.Collection 的遍历方式 迭代器遍历 迭代器不依赖索引 迭代器在Java中的类是 Iterrator 迭代器是集合专用的遍历方式。
public static void main(String[] args) {//0.创建集合并添加元素CollectionString coll new ArrayList();coll.add(aaa);coll.add(bbb);coll.add(ccc);coll.add(ddd);//1.获取迭代器对象IteratorString it coll.iterator();//2.利用循环不断的去获取集合中的每一个元素while (it.hasNext()) {//3.next方法的两件事情获取元素并移动指针String str it.next();System.out.println(str);}}增强for遍历 public static void main(String[] args) {//增强for遍历//0.创建集合并添加元素CollectionString coll new ArrayList();coll.add(zhangsan);coll.add(lisi);coll.add(wangwu);//1.利用增强for遍历for (String s : coll) {System.out.println(s);}}Lambda表达式遍历 public static void main(String[] args) {//Lambda 表达式遍历//0.创建集合并添加元素CollectionString coll new ArrayList();coll.add(zhangsan);coll.add(lisi);coll.add(wangwu);//利用匿名内部类的形式/*底层原理* 其实也会自己遍历集合依次得到每一个元素* 把得到的每一个元素传递给下面的accept方法* s 依次表示集合中的每一个的对象 */coll.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.println(s);}});System.out.println(--------------------------);//1.Lambda表达式遍历coll.forEach(s - System.out.println(s) );}3.List集合 List集合的特有方法 public static void main(String[] args) {//0.创建一个集合ListString list new ArrayList();//1.添加元素list.add(aaa);list.add(bbb);list.add(ccc);//打印集合System.out.println(list); // [aaa, bbb, ccc]System.out.println(-------------------------);//2.在指定位置插入指定的元素list.add(2, zhangsan);System.out.println(list); // [aaa, bbb, zhangsan, ccc]System.out.println(-------------------------);//3.删除指定索引处的元素返回被删除的元素/*在调用方法的时候如果方法出现了重载现象* 优先调用实参跟形参类型一致的那个方法。*/String remove list.remove(2);System.out.println(remove); // zhangsanSystem.out.println(list); // [aaa, bbb, ccc]System.out.println(-------------------------);//4.修改指定索引处的元素返回被修改的元素list.set(0,狗剩);System.out.println(list); // [狗剩, bbb, ccc]System.out.println(-------------------------);//5.返回指定索引处的元素String s list.get(1);System.out.println(s); // bbb}List集合的遍历方式 public static void main(String[] args) {//0.创建集合并添加元素ListString list new ArrayList();list.add(aaa);list.add(bbb);list.add(ccc);//1.迭代器遍历IteratorString it list.iterator();while (it.hasNext()) {String s it.next();System.out.println(s);}System.out.println(------------------------);//2.增强forfor (String s : list) {System.out.println(s);}System.out.println(------------------------);//3.Lambda 表达式//匿名内部类list.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.println(s);}});System.out.println(-------------------------);list.forEach(s - System.out.println(s));System.out.println(------------------------);//4.普通for循环for (int i 0; i list.size(); i) {String s list.get(i);System.out.println(s);}System.out.println(-------------------------);//5.列表迭代器ListIteratorString it2 list.listIterator();while (it2.hasNext()){String s it2.next();if (bbb.equals(s)){it2.add(zhangsan);}System.out.println(s);}System.out.println(list); // [aaa, bbb, zhangsan, ccc]}五种遍历方式对比 4.数据结构
数据结构计算机存储、组织数据的方式不同的业务场景要选择不同的数据结构。是指数据之间是以什么方式排列在一起的。数据结构是为了更加方便的管理和使用数据需要结合具体的业务场景来进行选择。一般情况下精心选择的数据结构可以带来更高的运行或者存储效率。
每种数据结构长什么样子如何添加数据如何删除数据
1).栈
栈的特点后进先出先进后出
2).队列
队列的特点先进先出后进后出
3数组 查询速度快查询数据通过地址值和索引定位查询任意数据耗时相同。元素在内存中是连续存储的删除效率低要将原始数据删除同时后面每个数据前移。添加效率极低添加位置后的每个数据后移再添加元素。
**数组是一种查询快增删慢的模型。
4链表 链表中的结点是独立的对象在内存中是不连续的每个结点包含数据值和下一个结点的地址。链表查询慢无论查询哪个数据都要从头开始找。链表增删相对快。
小结 5树 6二叉查找树 前序遍历
中序遍历 后序遍历 层序遍历
7平衡二叉树 平衡二叉树旋转机制——左旋
就是将根节点的右侧往左拉,原先的右子节点变成新的父节点,并把多余的左子节点出让,给已经降级的根节点当右子节点 平衡二叉树旋转机制——右旋
就是将根节点的左侧往右拉,左子节点变成了新的父节点,并把多余的右子节点出让,给已经降级根节点当左子节点 平衡二叉树和二叉查找树对比结构图
平衡二叉树需要旋转的四种情况 左左 左左: 当根节点左子树的左子树有节点插入,导致二叉树不平衡 如何旋转: 直接对整体进行右旋即可 左右 左右: 当根节点左子树的右子树有节点插入,导致二叉树不平衡 如何旋转: 先在左子树对应的节点位置进行左旋,在对整体进行右旋 右右 右右: 当根节点右子树的右子树有节点插入,导致二叉树不平衡 如何旋转: 直接对整体进行左旋即可 右左 右左:当根节点右子树的左子树有节点插入,导致二叉树不平衡 如何旋转: 先在右子树对应的节点位置进行右旋,在对整体进行左旋 8红黑树 平衡二叉树
高度平衡当左右子树高度差超过1时通过旋转保持平衡
红黑树
是一个二叉查找树但是不是高度平衡的条件特有的红黑规则
红黑规则
每一个结点或是红色的或是黑色的根节点必须是黑色如果一个节点没有子节点或者父节点则该节点相应的指针属性值为 Nil 这些 Nil 视为叶节点每个叶节点Nil是黑色的如果某一个节点是红色那么它的子节点必须是黑色不能出现两个红色节点相连的情况对每一个结点从该节点到其所有后代叶节点的简单路径上均包含相同数目的黑色节点
添加节点的规则
默认颜色添加节点默认是红色的效率高
当默认是黑色时 当默认是红色时 红黑树添加节点后如何保持红黑规则
根节点位置 直接变为黑色 非根节点位置 父节点为黑色 不需要任何操作,默认红色即可 父节点为红色 叔叔节点为红色 将父节点设为黑色,将叔叔节点设为黑色将祖父节点设为红色如果祖父节点为根节点,则将根节点再次变成黑色 叔叔节点为黑色 将父节点设为黑色将祖父节点设为红色以祖父节点为支点进行旋转 举例 跳过添加20、18、23 全部添加完成后 再向其中添加 15 和 14 红黑树增删改查的性能都很好
5.ArrayList集合 1.ArrayList集合底层原理 2.LinkedList集合 3.迭代器底层源码解析 6.泛型深入
1泛型概述 没有泛型的时候集合如何存储数据
public static void main(String[] args) {//没有泛型的时候集合如何存储数据/*结论* 如果我们没有给集合指定类型默认认为所有的数据类型都是Object类型* 此时可以往集合添加任意的数据类型。* 带来一个坏处我们在获取数据的时候无法使用它的特有行为。*//*此时推出了泛型 可以在添加数据的时候就把类型进行统一。* 而且我们在获取数据的时候也省的强转了非常的方便。*///0.创建集合对象ArrayListObject list new ArrayList();//1.添加数据list.add(123);list.add(abc);list.add(new Student(zhangsan, 123));//2.遍历集合获取集合中的每一个元素IteratorObject it list.iterator();while (it.hasNext()){Object obj it.next();//多态的弊端是不能访问子类的特有功能System.out.println(obj);}}2泛型类 package Generics;import java.util.Arrays;/** 当在编写一个类的时候如果不确定类型那么这个类型就可以定义为泛型类。* */
public class MyArrayListE {Object[] obj new Object[10];int size;public boolean add(E e) {obj[size] e;size;return true;}public E get(int index) {return (E) obj[index];}Overridepublic String toString() {return Arrays.toString(obj);}
} public static void main(String[] args) {MyArrayListString list new MyArrayList();list.add(aaa);list.add(bbb);list.add(ccc);System.out.println(list); // [aaa, bbb, ccc, null, null, null, null, null, null, null]MyArrayListInteger list2 new MyArrayList();list2.add(123);list2.add(456);list2.add(789);System.out.println(list2); // [123, 456, 789, null, null, null, null, null, null, null]Integer i list2.get(0);System.out.println(i); //123}3泛型方法 package Generics;import java.util.ArrayList;public class ListUtil {private ListUtil() {}//类中定义一个静态方法addAll用来添加多个集合的元素。public static E void addAll(ArrayListE list, E e1, E e2, E e3, E e4) {list.add(e1);list.add(e2);list.add(e3);list.add(e4);}//添加元素个数未知public static E void addAll2(ArrayListE list, E...e) {for (E element : e) {list.add(element);}}
}
package Generics;import java.util.ArrayList;public class GenericsDemo3 {//定义一个工具类ListUtil//类中定义一个静态方法addAll用来添加多个集合的元素。public static void main(String[] args) {ArrayListString list new ArrayList();ListUtil.addAll(list, aaa, bbb, ccc,ddd );System.out.println(list);//[aaa, bbb, ccc, ddd]ArrayListInteger list1 new ArrayList();ListUtil.addAll2(list1,1,2,3,4,5,6,7,8,9,3,6,4,2,5);System.out.println(list1);}
} 4泛型接口 package Generics;import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;public class MyArrayList2 implements ListString {Overridepublic int size() {return 0;}Overridepublic boolean isEmpty() {return false;}Overridepublic boolean contains(Object o) {return false;}Overridepublic IteratorString iterator() {return null;}Overridepublic Object[] toArray() {return new Object[0];}Overridepublic T T[] toArray(T[] a) {return null;}Overridepublic boolean add(String s) {return false;}Overridepublic boolean remove(Object o) {return false;}Overridepublic boolean containsAll(Collection? c) {return false;}Overridepublic boolean addAll(Collection? extends String c) {return false;}Overridepublic boolean addAll(int index, Collection? extends String c) {return false;}Overridepublic boolean removeAll(Collection? c) {return false;}Overridepublic boolean retainAll(Collection? c) {return false;}Overridepublic void clear() {}Overridepublic String get(int index) {return null;}Overridepublic String set(int index, String element) {return null;}Overridepublic void add(int index, String element) {}Overridepublic String remove(int index) {return null;}Overridepublic int indexOf(Object o) {return 0;}Overridepublic int lastIndexOf(Object o) {return 0;}Overridepublic ListIteratorString listIterator() {return null;}Overridepublic ListIteratorString listIterator(int index) {return null;}Overridepublic ListString subList(int fromIndex, int toIndex) {return null;}
} public static void main(String[] args) {/*泛型接口的两种使用方式* 1.实现类给出具体的类型* 2.实现类延续泛型创建实现类对象时再确定类型 */MyArrayList2 list new MyArrayList2();list.add(abc);//list.add(123); // java: 不兼容的类型: int无法转换为java.lang.String}5泛型的继承和通配符
泛型不具备继承性但是数据具备继承性 泛型里面写的是什么类型那么在方法中只能传递什么类型的数据。、 package Generics.Test;public abstract class Animal {/*属性名字年龄行为吃东西*/private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name name;this.age age;}/*** 获取* return name*/public String getName() {return name;}/*** 设置* param name*/public void setName(String name) {this.name name;}/*** 获取* return age*/public int getAge() {return age;}/*** 设置* param age*/public void setAge(int age) {this.age age;}public abstract void eat();public String toString() {return Animal{name name , age age };}
}
package Generics.Test;public abstract class Cat extends Animal{
}
package Generics.Test;public abstract class Dog extends Animal{
}
package Generics.Test;public class PersianCat extends Cat {Overridepublic void eat() {System.out.println(一只叫做 getName() 的 getAge() 岁的波斯猫正在吃小饼干);}
}
package Generics.Test;public class LiHuaCat extends Cat {Overridepublic void eat() {System.out.println(一只叫做 getName() 的 getAge() 岁的狸花猫正在吃鱼);}
}
package Generics.Test;public class HuskyDog extends Dog {Overridepublic void eat() {System.out.println(一只叫做 getName() 的 getAge() 岁的哈士奇正在吃骨头边吃边拆家);}
}
package Generics.Test;public class TeddyDog extends Dog {Overridepublic void eat() {System.out.println(一只叫做 getName() 的 getAge() 岁的泰迪正在吃骨头边吃边蹭);}
}
public static void main(String[] args) {/*需求定义一个继承结构动物| |猫 狗| | | |波斯猫 狸花猫 泰迪 哈士奇属性名字年龄行为吃东西波斯猫方法体打印一只叫做XXX的X岁的波斯猫正在吃小饼干狸花猫方法体打印一只叫做XXX的X岁的狸花猫正在吃鱼泰迪方法体打印一只叫做XXX的X岁的泰迪正在吃骨头边吃边蹭哈士奇方法体打印一只叫做XXX的X岁的哈士奇正在吃骨头边吃边拆家测试类中定义一个方法用于饲养动物public static void keepPet(ArrayList??? list){//遍历集合调用动物的eat方法}要求1该方法能养所有品种的猫但是不能养狗要求2该方法能养所有品种的狗但是不能养猫要求3该方法能养所有的动物但是不能传递其他类型*/ArrayListPersianCat list1 new ArrayList();ArrayListLiHuaCat list2 new ArrayList();ArrayListTeddyDog list3 new ArrayList();ArrayListHuskyDog list4 new ArrayList();keepPet(list1);keepPet(list2);keepPet(list3);keepPet(list4);}//要求3该方法能养所有的动物但是不能传递其他类型public static void keepPet(ArrayList? extends Animal list){}//要求2该方法能养所有品种的狗但是不能养猫/*public static void keepPet(ArrayList? extends Dog list){}*///要求1该方法能养所有品种的猫但是不能养狗/*public static void keepPet(ArrayList? extends Cat list){}*/总结 7.Set系列集合
不可以存储重复元素没有索引,不能使用普通for循环遍历 无序存取顺序不一致不重复可以去除重复无索引没有带索引的方法所以不能使用普通for循环遍历也不能通过索引来获取元素
Set 集合的实现类
HashSet 无序、不重复、无索引LinkedHashSet有序、不重复、无索引TreeSet可排序、不重复、无索引 Set 接口中的方法上基本上与Collection的API一致
public static void main(String[] args) {/*练习 存储字符串并遍历* 利用Set系列的集合添加字符串并使用多种方式遍历* 0.迭代器* 1.增强for* 2.Lambda表达式*///0.创建Set集合的对线SetString s new HashSet();//1.添加元素/*如果当前元素是第一次添加那么可以添加成功返回true* 如果当前元素是第二次添加那么添加失败返回false*/s.add(张三);s.add(李四);s.add(王五);//2.打印集合System.out.println(s); // [李四, 张三, 王五]//迭代器遍历IteratorString it s.iterator();while (it.hasNext()) {String s1 it.next();System.out.println(s1);}System.out.println();//增强for遍历for (String s2 : s) {System.out.println(s2);}System.out.println();//Lambda 表达式/*s.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.println(s);}});*/s.forEach(s3 - System.out.println(s3));}1HashSet
HashSet 底层原理
HashSet 集合底层采取哈希表存储数据哈希表是一种对于增删改查数据性能都较好的结构
哈希表组成
JDK8之前数组链表JDK8开始数组链表红黑树
哈希值对象的整数表现形式 哈希值
根据hashCode方法计算出来的int类型的整数该方法定义在Object类中所有对象都可以调用默认使用地址值进行计算一般情况下会重写hashCode方法利用对象内部的属性值计算哈希值 public static void main(String[] args) {//0.创建对象Student s1 new Student(zhangsan, 23);Student s2 new Student(zhangsan, 23);//1.如果没有重写hashCode方法不同对象计算处的哈希值是不同的System.out.println(s1.hashCode()); // 990368553System.out.println(s2.hashCode()); // 1096979270//2.如果已经重写hashCode方法不同的对象只要属性值相同计算处的哈希值就是一样的System.out.println(s1.hashCode()); // -1461067292System.out.println(s2.hashCode()); // -1461067292//3.但是在小部分情况下不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。哈希碰撞System.out.println(abc.hashCode()); // 96354System.out.println(acD.hashCode()); // 96354}public static void main(String[] args) {//0.创建学生对象Student s1 new Student(zhangsan, 23);Student s2 new Student(lisi, 14);Student s3 new Student(wangwu, 26);Student s4 new Student(zhangsan, 23);//1.创建集合用来添加学生HashSetStudent hs new HashSet();//2.添加数据System.out.println(hs.add(s1)); //trueSystem.out.println(hs.add(s2)); //trueSystem.out.println(hs.add(s3)); //trueSystem.out.println(hs.add(s4)); //falseSystem.out.println(hs);}package Set;import java.util.Objects;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;}Overridepublic boolean equals(Object o) {if (this o) return true;if (o null || getClass() ! o.getClass()) return false;Student student (Student) o;return age student.age Objects.equals(name, student.name);}Overridepublic int hashCode() {return Objects.hash(name, age);}Overridepublic String toString() {return Student{ name name \ , age age };}
} 2LinkedHashSet public static void main(String[] args) {//0.创建学生对象Student s1 new Student(zhangsan, 23);Student s2 new Student(lisi, 14);Student s3 new Student(wangwu, 26);Student s4 new Student(zhangsan, 23);//1.创建集合用来添加学生LinkedHashSetStudent lhs new LinkedHashSet();//2.添加数据System.out.println(lhs.add(s1)); //trueSystem.out.println(lhs.add(s2)); //trueSystem.out.println(lhs.add(s3)); //trueSystem.out.println(lhs.add(s4)); //falseSystem.out.println(lhs); //[Student{namezhangsan, age23}, Student{namelisi, age14}, Student{namewangwu, age26}]}3TreeSet public static void main(String[] args) {/*需求* 存储整数并进行排序 *///0.创建TreeSet集合对象TreeSetInteger ts new TreeSet();//1.添加数据ts.add(4);ts.add(5);ts.add(2);ts.add(1);ts.add(3);//2.打印集合System.out.println(ts); // [1, 2, 3, 4, 5]//3.遍历//迭代器IteratorInteger it ts.iterator();while (it.hasNext()) {Integer num it.next();System.out.println(num);}System.out.println();//加强forfor (Integer t : ts) {System.out.println(t);}System.out.println();//Lambda表达式ts.forEach(num - System.out.println(num));public static void main(String[] args) {/*需求* 创建TreeSet集合并添加3个学生对象* 学生对象属性* 姓名、年龄* 要求按照学生的年龄进行排序* 同年龄按照姓名字母排列暂不考虑中文* 同姓名同年龄认为是同一个人** 方式一* 默认的排序规则/自然排序* Student实现Comparable接口重写里面的抽象方法再指定比较规则** 方式二* 比较器排序* 创建TreeSet对象的时候传递比较器Comparator指定规则*///0.创建学生对象Student s1 new Student(zhangsan, 23);Student s2 new Student(lisi, 24);Student s3 new Student(wangwu, 25);//1.创建集合对象TreeSetStudent ts new TreeSet();//2.添加数据ts.add(s2);ts.add(s1);ts.add(s3);//3.打印数据System.out.println(ts);}package Set;import java.util.Objects;public class Student implements ComparableStudent{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;}Overridepublic String toString() {return Student{ name name \ , age age };}Overridepublic int compareTo(Student o) {int res this.getAge() - o.getAge();return res;}
} public static void main(String[] args) {/** 需求请自行选择比较器排序和自然排序两种方式* 要求存入四个字符串c , ab , df , qwer* 按照长度排序如果一样长则按照首字母排序*///0.创建集合/*o1:表示当前要添加的元素* o2:表示已经在红黑树存在的元素* 返回值* 负数认为要添加的元素是小的存左边* 正数认为要添加的元素是大的存右边* 0认为要添加的元素已经存在舍弃*//*TreeSetString ts new TreeSet(new ComparatorString() {Overridepublic int compare(String o1, String o2) {//按照长度排序int i o1.length() - o2.length();//如果一样长则按照首字母排序i i 0 ? o1.compareTo(o2) : i;return i;}});*/TreeSetString ts new TreeSet((o1, o2) - {//按照长度排序int i o1.length() - o2.length();//如果一样长则按照首字母排序i i 0 ? o1.compareTo(o2) : i;return i;});//添加数据ts.add(c);ts.add(ab);ts.add(df);ts.add(qwer);//打印System.out.println(ts); // [c, ab, df, qwer]}package Set;public class Student2 implements ComparableStudent2 {/*属性姓名、年龄、语文成绩、数学成绩、英语成绩*/private String name;private int age;private int Chinese;private int Math;private int English;public Student2() {}public Student2(String name, int age, int Chinese, int Math, int English) {this.name name;this.age age;this.Chinese Chinese;this.Math Math;this.English English;}/*** 获取** return name*/public String getName() {return name;}/*** 设置** param name*/public void setName(String name) {this.name name;}/*** 获取** return age*/public int getAge() {return age;}/*** 设置** param age*/public void setAge(int age) {this.age age;}/*** 获取** return Chinese*/public int getChinese() {return Chinese;}/*** 设置** param Chinese*/public void setChinese(int Chinese) {this.Chinese Chinese;}/*** 获取** return Math*/public int getMath() {return Math;}/*** 设置** param Math*/public void setMath(int Math) {this.Math Math;}/*** 获取** return English*/public int getEnglish() {return English;}/*** 设置** param English*/public void setEnglish(int English) {this.English English;}public String toString() {return Student2{name name , age age , Chinese Chinese , Math Math , English English };}/*按照总分从高到低输出到控制台* 如果总分一样按照语文成绩排* 如果语文一样按照数学成绩排* 如果数学成绩一样按照英语成绩排* 如果英语成绩一样按照年龄排* 如果年龄一样按照姓名的字母顺序排* 如果都一样认为是同一个学生不存*/Overridepublic int compareTo(Student2 o) {int sum1 this.getChinese() this.getMath() this.getEnglish();int sum2 o.getChinese() o.getMath() o.getEnglish();//比较总分int i sum1 - sum2;//果总分一样按照语文成绩排i i 0 ? this.getChinese() - o.getChinese() : i;//如果语文一样按照数学成绩排i i 0 ? this.getMath() - o.getMath() : i;//如果数学成绩一样按照英语成绩排可以省略不写i i 0 ? this.getEnglish() - o.getEnglish() : i;//如果英语成绩一样按照年龄排i i 0 ? this.getAge() - o.getAge() : i;//如果年龄一样按照姓名的字母顺序排i i 0 ? this.getName().compareTo(o.getName()) : i;return i;}
}
public static void main(String[] args) {/*需求创建5个学生对象* 属性姓名、年龄、语文成绩、数学成绩、英语成绩* 按照总分从高到低输出到控制台* 如果总分一样按照语文成绩排* 如果语文一样按照数学成绩排* 如果数学成绩一样按照英语成绩排* 如果英语成绩一样按照年龄排* 如果年龄一样按照姓名的字母顺序排* 如果都一样认为是同一个学生不存。*///0.创建5个学生对象Student2 s1 new Student2(zhangsan, 23, 90, 99, 50);Student2 s2 new Student2(lisi, 24, 90, 98, 50);Student2 s3 new Student2(wangwu, 25, 95, 100, 30);Student2 s4 new Student2(zhaoliu, 26, 60, 99, 70);Student2 s5 new Student2(qianqi, 26, 70, 80, 70);//1.创建集合TreeSetStudent2 ts new TreeSet();//2.添加数据ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);//3.打印//System.out.println(ts);IteratorStudent2 it ts.iterator();while (it.hasNext()) {Student2 info it.next();int sum info.getChinese() info.getMath() info.getEnglish();System.out.println(info 总分 sum);}/*Student2{name qianqi, age 26, Chinese 70, Math 80, English 70} 总分220Student2{name wangwu, age 25, Chinese 95, Math 100, English 30} 总分225Student2{name zhaoliu, age 26, Chinese 60, Math 99, English 70} 总分229Student2{name lisi, age 24, Chinese 90, Math 98, English 50} 总分238Student2{name zhangsan, age 23, Chinese 90, Math 99, English 50} 总分239*/}8.单列集合使用场景
