Java基础知识八：Set集合介绍、HashSet、LinkedHashSet、TreeSet、泛型介绍、泛型类、泛型方法、泛型接口、类通配符、可变参数及常用方法

Set集合

1、Set集合基本介绍

Set集合 : 是一个不包含重复元素的集合

Set集合特点：没有带索引的方法，所以不能使用普通for循环进行遍历

HasSet:对集合的跌代顺序不做任何保证

 

哈希值：用HasCode()方法获取，同一个对象多次调用该方法获取的值是一样的

注意：1. 默认情况下，不同对象的哈希值是不同的

2. 通过方法重写，可以实现不同对象的哈希值是相同的

 

 

2、HahSet案例：遍历学生对象元素

 

 

3、LinkedHashSet讲解与案例

1.底层是链表和哈希表实现的Set接口

2.存储数据的顺序和取出数据的顺序是一致的，一致性是由链表来保证的

3.存储的元素不能重复是由哈希表来保证的

 

TreeSet

1、TreeSet基本介绍

1. 间接的实现了Set接口，不是直接实现，元素不能包含重复元素

2. TreeSet元素是排序的，可以根据自然排序(比如：a 到z 排序)，也可以根据比较器comparable排序

3. 如何排序取决于所使用的构造方法: 无参是自然排序，有参是比较器comparable排序

4. 有参是比较器comparable排序时，如果遍历的是对象，需要该对象实现comparable接口，实现后要重写接口中的compareTo()方法，重写的compareTo()方法好中ruturn返回值要改为1(改为1后遍历的集合结果按照升序排序，如果是－1遍历的集合结果按照降序排序)，否则只能遍历出来集合中的第一个元素。

 

2、TreeSet集合讲解与特点

 

 

3、TreeSet进行排序两种方式

详见：CollectionURSet包中TreeSetDemo2类 与 TreeSetDemo3类

 

 

泛型与可变参数

1、泛型基本介绍

泛型：本质是参数化类型，在使用/调用时才传入具体类型

注：这种参数类型可以用在类、方法、接口中，分别被称为泛型类、泛型方法、泛型接口

泛型类格式: public class 类名<T>{ }    注：T可以换成任何字母比如T、V、K、E等

泛型方法格式：public <T> void 方法名(T  t){ }

泛型接口格式：public interface 接口名<T> { }

 

2、泛型类案例一：泛型类、泛型方法的使用

package Generic;
//泛型类
public class generic<T> {
   private T t;
   public T getT() {
       return t;
   }
   public void setT(T t) {
       this.t = t;
   }
   //泛型方法
   public <V> void show(V v){
       System.out.println(v);
   }
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

//泛型测试类
public class genericDemo {
   public static void main(String[] args) {
       System.out.println("以下是调用泛型类的使用");
       //存储String类型
       generic<String> g1 = new generic<String>();
       g1.setT("beijing");
       System.out.println(g1.getT());
       //存储Integer类型
       generic<Integer> g2 = new generic<Integer>();
       g2.setT(100);
       System.out.println(g2.getT());
       //存储Boolean类型
       generic<Boolean> g3 = new generic<Boolean>();
       g3.setT(true);
       System.out.println(g3.getT());
       System.out.println("以下是调用泛型方法的使用");
       //generic定义为泛型方法后，调用方法时可以传递任意类型
       generic g4 = new generic();
       g4.show("beijing");
       g4.show(200);
       g4.show(true);
       g4.show(13.14);
   }
}

3、泛型接口案例二

//定义泛型接口
public interface gen<T> {
   void show(T t);
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

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

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

//定义泛型接口测试类
public class genDemo {
   public static void main(String[] args) {
       //String类型
       gen<String> g = new genImpl<String>();
       g.show("beijng");
       //Integer类型
       gen<Integer> g1 = new genImpl<Integer>();
       g1.show(100);
       //Boolean类型
       gen<Boolean> g2 = new genImpl<Boolean>();
       g2.show(true);
   }
}

4、类型通配符

 

//类型通配符
public class typeGen {
   public static void main(String[] args) {
       List<?> list1 = new ArrayList<Number>();
       List<?> list2 = new ArrayList<Integer>();
       List<?> list3 = new ArrayList<Object>();

       //类型通配符的上限 格式<? extends 类型>
       List<? extends Number> list4 = new ArrayList<Number>();
       List<? extends Integer> list5 = new ArrayList<Integer>();

       //类型通配符的下限 格式<? super 类型>
       List<? super Number> list6 = new ArrayList<Object>();
       List<? super Number> list7 = new ArrayList<Number>();
   }
}

5、可变参数介绍

 

//可变参数
public class AryDemo1 {
   public static void main(String[] args) {
       System.out.println(sum(10,20,30));
       System.out.println(sum(90,0,70,60));
       System.out.println(sum1(10,20,30,40,50,60));
   }
   //变量a其实就是一个数组
   public static int sum(int...a){
       int sum = 0;
       for(int i: a){
           sum += i;
       }
       return sum;
   }
   //方法有多个参数的情况下，可变参数要放到最后
   public static int sum1(int a,int...b){
       return 0;
   }
}

6、可变参数几个重要常见方法的使用

 

//可变参数几个重要常见方法的使用
public class AryDemo2 {
   public static void main(String[] args) {
       //ArrayList中有一个静态方法：asList(T...a) 返回指定数组支持的固定大小列表
       List<String> list = Arrays.asList("java", "hello", "world");
       //list.add("beijing"); 改变了数组大小，不能用
       //list.remove("java"); 改变了数组大小，不能用
       list.set(0,"javaSE"); //修改数组元素，但未改变数组大小，可用
       System.out.println(list);

       //List接口中有一个静态方法：of(E...elements) 返回包含任意数量元素的不可变列表
       List<String> list1 = List.of("java","hello","world","java");//List集合允许有重复元素
       //list.add("beijing"); 改变了数组大小，不能用
       //list.remove("java"); 改变了数组大小，不能用
       //list.set(0,"javaSE"); 改变了数组的元素，不能用
       System.out.println(list1);

       //Set接口中有一个静态方法：of(E...elements) 返回一个包含任意数量元素的不可变集合
       Set<String> set = Set.of("java","hello","world");//Set集合不允许有重复元素
       //list.add("beijing"); 改变了数组大小，不能用
       //list.remove("java"); 改变了数组大小，不能用
       //Set集合中没有索引，所以不能用set()方法
       System.out.println(set);
   }
}