这里写目录标题
- 1.Set集合
- 1.1Set集合的特点
- 1.2HashSet集合的特点
- 2.Set集合排序
- 2.1 TreeSet
- 2.2 自然排序Comparable
- 2.3学生成绩排序实例
- 2.3.1 描述
- 2.3.2 书写
- 3.泛型
- 3.1 描述
- 3.2 泛型类举例
- 3.3 泛型方法举例
- 3.4泛型接口
1.Set集合
1.1Set集合的特点
元素存取无序
没有索引、只能通过迭代器或增强for循环遍历
不能存储重复元素
举例说明：
Set<String> set = new HashSet<String>();
//添加元素
set.add("hello");
set.add("world");
//不包含重复元素的集合//增强for循环遍历
for(String s : set) {
System.out.println(s);
}1.2HashSet集合的特点
1.对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
2.没有带索引的方法，所以不能使用普通for循环遍历
3.可使用增强for循环
举例说明：
HashSet<String> hs = new HashSet<String>();
//添加元素
hs.add("hello");
hs.add("world");
hs.add("java");//遍历
for(String s : hs) {
System.out.println(s);
}2.Set集合排序
元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet()：根据其元素的自然排序进行排序
TreeSet(Comparator comparator) ：根据指定的比较器进行排序。
2.1 TreeSet
举例说明：
//创建集合对象
TreeSet<Integer> ts = new TreeSet<Integer>();
//添加元素
ts.add(10);
ts.add(40);
ts.add(30);
ts.add(50);
ts.add(20);
ts.add(30);
for(Integer i : ts) {
System.out.println(i);
}
}
//结果是自然排序输出2.2 自然排序Comparable
根据指定的比较器进行排序：增加或者减少
步骤：
1.类继承Comparable
2.重写compareTo()
2.3学生成绩排序实例
2.3.1 描述
案例需求
存储学生对象并遍历，创建TreeSet集合使用无参构造方法
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写.
2.3.2 书写
方法一：
public class Student implements Comparable<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 int compareTo(Student s) {
//年龄相同时，按照姓名的字母顺序排序
int num2 = num==0?this.name.compareTo(s.name):num;
return num2;
}
}方法二：
可写到main函数里面，引用时添加重新方法
TreeSet<Student> students=new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num1=s1.getAge()-s2.getAge();
int num2=num1==0?s1.getName().compareTo(s2.getName()):num1;
return num2;
}
});main函数
import java.util.Comparator;
import java.util.TreeSet;
public class treeset {
public static void main(String[] args) {
TreeSet<Student> students=new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num1=s1.getAge()-s2.getAge();
int num2=num1==0?s1.getName().compareTo(s2.getName()):num1;
return num2;
}
});
Student s1=new Student("wang",18);
Student s2=new Student("gang",19);
Student s3=new Student("jia",17);
Student s4=new Student("ia",17);
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
for (Student s:students){
System.out.println(s.getName()+s.getAge());
}
}
}3.泛型
3.1 描述
：不具体指什么数据类型，需要用什么类型直接引用什么数据类型，避免了要引用各种数据类型的代码冗余情况。
3.2 泛型类举例
泛型类定义：修饰符 class 类名<类型> { }
student类
public class Student1<T> {
private T t;
public T getT() {//无参和构造
return t;
}
public void setT(T t) {//有参构造
this.t = t;
}
}main函数调用
public class Demo1 {
public static void main(String[] args) {
//String 类型
Student1<String> s1=new Student1();
s1.setT("xxi");
System.out.println(s1.getT());
// Integer类型
Student1<Integer> s2=new Student1<Integer>();
s2.setT(20);
System.out.println(s2.getT());
}
}3.3 泛型方法举例
修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
public class Generic {
public <T> void show(T t) {
System.out.println(t);
}
}3.4泛型接口
//定义Generic接口
public interface Generic<T> {
void show(T t);
}//实现类接口
public class Genericimpl<T> implements Generic<T> {
@Override
public void show(T t){
System.out.println(t);
}
}//测试类
public class Genericdemo {
public static void main(String[] args) {
Genericimpl<String> g1=new Genericimpl<String>();
g1.show("xoxo");
Genericimpl<Integer> g2=new Genericimpl<Integer>();
g2.show(20);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
