Set集合，Set集合排序，泛型。小白也能懂

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);
    }
}