Set集合以及Set集合排序/泛型还有可变参数

ps:应网友反馈要添加文章目录so从此一概添加文章目录
java

Set集合

Set集合的特色

1. 元素存取无序
2. 没有索引、只能经过迭代器iterator或加强for循环遍历
3. 不能存储重复元素

Set集合的基本使用web

public class example_1 {
    public static void main(String[] args) {
        Set<String> stringSet = new HashSet<String>();
        stringSet.add("Java");  //添加元素
        stringSet.add("hello");  //添加元素
        for (String S:  //使用加强for遍历
             stringSet) {
            System.out.println(S);
        }
    }
}

HashSet集合概述和特色

1. 底层数据结构是哈希表
2. 对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素顺序一致
3. 没有带索引的方法，因此不能使用普通for循环遍历
4. 因为是Set集合，因此是不包含重复元素的集合

LinkedHashSet集合概述和特色

1. 哈希表和链表实现的Set接口，具备可预测的迭代次序
2. 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
3. 由哈希表保证元素惟一，也就是说没有重复的元素

基本使用与集合类似数组

Set集合排序

TreeSet集合概述和特色

TreeSet集合概述安全

• 元素有序，能够按照必定的规则进行排序，具体排序方式取决于构造方法
  1. TreeSet()：根据其元素的天然排序进行排序
  2. TreeSet(Comparator comparator) ：根据指定的比较器进行排序
• 没有带索引的方法，因此不能使用普通for循环遍历
• 因为是Set集合，因此不包含重复元素的集合

构造方法1数据结构

public class example_1 {
    public static void main(String[] args) {
        Set<Integer> stringSet = new TreeSet<Integer>();
        stringSet.add(34);  //添加元素
        stringSet.add(12);  //添加元素
        stringSet.add(45);  //添加元素
        stringSet.add(3);  //添加元素
        for (int i:  //使用加强for遍历
                stringSet) {
            System.out.println(i);
        }
    }
}

天然排序Comparable的使用

实现步骤ide

• 用TreeSet集合存储自定义对象，无参构造方法使用的是天然排序对元素进行排序的
• 天然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
• 重写方法时，必定要注意排序规则必须按照要求的主要条件和次要条件来写

以学生类为例子svg

//上面的学生代码省略
public class Student implements Comparable<Student> {
	private String name;
    private int math;
    private int chinese;
.
.
.
    @Override
    public int compareTo(Student student) {	//关键代码
        int num = this.getSum() - student.getSum();   //比较总分
        int num2 = num == 0 ? this.getChinese() - student.chinese : num;//若是总分相同的话就比较语文成绩
        int num3 = num == 0 ? this.getName().compareTo(student.getName()): num2;//若是语文成绩仍是相同的话就比较名字
        return num3;
    }
}

假若return取如下值工具

return 0; //相同元素添加不进去
return 1; //正数时是由小到大
return -1; //负数时就倒序排列测试

比较器排序Comparator的使用

实现步骤this

• 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
• 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
• 重写方法时，必定要注意排序规则必须按照要求的主要条件和次要条件来写

用第二个构造方法

public class example_1 {
    public static void main(String[] args) {
        Set<Student> stringSet = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student student, Student t1) {
                int num = student.getSum() - t1.getSum();   //比较总分
                int num2 = num == 0 ? student.getChinese() - t1.getChinese() : num;//若是总分相同的话就比较语文成绩
                int num3 = num == 0 ? student.getName().compareTo(t1.getName()): num2;//若是语文成绩仍是相同的话就比较名字
                return num3;
            }
        });
        //.
        //.
        //.
        //建立学生对象
        //添加学生对象
        //而后遍历
    }
}

this是表示当前,t1是表示前一个

泛型

泛型概述和好处

泛型概述

是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制容许在编译时检测到非法的类型它的本质是参数化类型，也就是说所操做的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，而后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，而后在使用/调用时传入具体的类型。这种参数类型能够用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型的定义格式

• <类型>：指定一种类型的格式。这里的类型能够当作是形参
• <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型能够当作是形参
• 未来具体调用时候给定的类型能够当作是实参，而且实参的类型只能是引用数据类型

泛型的好处

• 把运行时期的问题提早到了编译期间
• 避免了强制类型转换

泛型类

定义一个泛型类

class General<T>{
    private T t;    //泛型变量

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

测试

public class example_1 {
    public static void main(String[] args) {
        General<String> stringGeneral = new General<>();
        stringGeneral.setT("Java");
        System.out.println(stringGeneral.getT());   //输出Java
        General<Integer> integerGeneral = new General<>();
        integerGeneral.setT(20);
        System.out.println(integerGeneral.getT());  //输出20
    }
}

泛型方法

定义的格式

修饰符 <类型> 返回值类型 方法名(类型 变量名) { }

public class General {
	public <T> void show(T t) {
		System.out.println(t);
	}
}

测试

public class example_1 {
    public static void main(String[] args) {
        General general = new General();
        general.show("Java");   //String类型
        general.show(20);   //Integer类型
    }
}

泛型接口

定义格式

修饰符 interface 接口名<类型> { }

public interface Generic<T> {
	void show(T t);
}

泛型类实现了这个泛型接口

class genericImp<T> implements generic<T>{  //泛型类实现泛型接口
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

而后就能够建立对象调用方法了

类型通配符

类型通配符的做用

为了表示各类泛型List的父类，可使用类型通配符

类型通配符的分类

• 类型通配符：<?>
  • List<?>：表示元素类型未知的List，它的元素能够匹配任何的类型
  • 这种带通配符的List仅表示它是各类泛型List的父类，并不能把元素添加到其中
• 类型通配符上限：<? extends 类型>
  • List<? extends Number>：它表示的类型是Number或者其子类型
• 类型通配符下限：<? super 类型>
  • List<? super Number>：它表示的类型是Number或者其父类型

Number只是做举例

可变参数

可变参数

• 可变参数介绍
  • 可变参数又称参数个数可变，用做方法的形参出现，那么方法参数个数就是可变的了
• 可变参数定义格式
  • 修饰符 返回值类型 方法名(数据类型… 变量名) { }
• 可变参数的注意事项
  1. 这里的变量实际上是一个数组 //那么就能够用加强for
  2. 若是一个方法有多个参数，包含可变参数，可变参数要放在最后

举个例子

public class example_1 {
    public static void main(String[] args) {
        int sum = sum(10, 20, 30);
        System.out.println(sum);
        int sum1 = sum(1, 2, 3, 4);
        System.out.println(sum1);

    }

    public static int sum(int... a) {   //a是一个数组
        int sum = 0;
        for (int i :
                a) {
            sum += i;
        }
        return sum;
    }
}

可变参数的使用

• Arrays工具类中有一个静态方法：
  • public static List asList(T… a)：返回由指定数组支持的固定大小的列表
  • 返回的集合不能作增删操做，能够作修改操做 //也就是能够调用set()方法进行修改
• List接口中有一个静态方法：
  • public static List of(E… elements)：返回包含任意数量元素的不可变列表
  • 返回的集合不能作增删改操做
• Set接口中有一个静态方法：
  • public static Set of(E… elements) ：返回一个包含任意数量元素的不可变集合
  • 在给元素的时候，不能给重复的元素
  • 返回的集合不能作增删操做，没有修改的方法 //没有set()方法的,由于没有索引

一个比一个严格

CET4P224

• porter
• nightmare
• chart
• dusk
• being
• weld
• somewhat
• plus
• weep
• budget