JAVA学习笔记（十一）

傷城~ 2023-10-01 20:55 38阅读 0赞

**目录**

一：Set（续）

二：泛型

--------------------

## 一：Set（续） ##

**1.1 LinkedHashSet集合概述和特点：**

*  哈希表和链表实现的set接口，具有可预测的迭代次序。
 *  由链表保证元素有序，也就是说元素的存储和取出顺序是一致的。
 *  由哈希表保证元素唯一，也就是说没有重复元素。

**1.2 Treeset集合概述和特点**

**treeSet集合特点：**

*  元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法。

TreeSet（）：根据其元素的自然排序进行排序

TreeSet（Comparator comparator）：根据指定的比较器进行排序

*  没有带索引的方法，所以不能使用普通for循环遍历。
 *  由于是Set集合，所以不包含重复元素的集合。

import java.util.*;
    public class Main {
        public static void main(String[] args) {
          TreeSet<Integer> ts=new TreeSet<>();
          ts.add(10);
          ts.add(40);
          ts.add(30);
          ts.add(50);
          ts.add(20);
          //TreeSet不包含重复元素
          ts.add(30);
          for(Integer i:ts){
              System.out.println(i);
          }
        }
    }

**1.3 自然排序Comparable的使用**

*  存储学生对象并遍历，创建TreeSet集合使用无参构造方法
 *  要求：按照年龄从小到大排序，年龄相同时，按照名字的字母顺序排序。

import java.util.TreeSet;
    public class Main {
        public static void main(String[] args) {
            //创建集合对象
            TreeSet<student> ts = new TreeSet<>();
            //创建学生对象
            student s1=new student("小明",19);
            student s2=new student("小白",18);
            student s3=new student("小黑",20);
            student s4=new student("小黄",22);
            student s5=new student("小绿",22);
            student s6=new student("小绿",22);
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            ts.add(s6);
            //保证元素的唯一性
            //遍历集合
            for(student s:ts){
                System.out.println(s.getName()+","+s.getAge());
            }
        }
    }
    
    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) {
            //return 1;    正向输出
            // return -1;   逆向输出
    
            //年龄由小到大排序
            int num=this.age-s.age;
            int num2=num==0?this.name.compareTo(s.name):num;
            return num2;
        }
    }

结论：

*  用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的。
 *  自然排序，就是让元素所属的类实现Comparable接口，重写comparableTo（To）方法。
 *  重写方法时，一定要注意排序规则必须按照；要求的主要条件和次要条件来写。

**1.4 比较器排序Comparator的使用**

*  存储学生对象并遍历，创建TreeSet集合使用带参构造方法
 *  要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

import java.util.Comparator;
    import java.util.TreeSet;
    public class Main {
        public static void main(String[] args) {
            //创建集合对象
            TreeSet<student> ts=new TreeSet<student>(new Comparator<student>() {
                @Override
                public int compare(student s1,student s2) {
                    int num=s1.getAge()-s2.getAge();
                    int num2=num==0?s1.getName().compareTo(s2.getName()):num;
                    return num2;
                }
            });
    
            student s1=new student("小明",19);
            student s2=new student("小白",18);
            student s3=new student("小黑",20);
            student s4=new student("小黄",22);
            student s5=new student("小绿",22);
            student s6=new student("小绿",22);
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            ts.add(s6);
            //保证元素的唯一性
            //遍历集合
            for(student s:ts){
                System.out.println(s.getName()+","+s.getAge());
            }
        }
    }
    
    
    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;
        }
    }

结论：

*  用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
 *  比较器排序，就是集合构造方法接收Comparator的实现类对象，重写compare（To1，To2）方法
 *  重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写。

## 二：泛型 ##

**2.1 泛型概述：**

泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型。

它的本质是参数化类型，也就是说操作的数据类型被指定为一个参数。

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

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

![77dfce80be8544d4897a8f18feabc88b.png][]

泛型的好处：

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

public class Main {
    
        public static void main(String[] args) {
           Generic<String> g=new Generic<String>();
           g.setT("java");
            System.out.println(g.getT());
            Generic<Integer> g1=new Generic<Integer>();
            g1.setT(123);
            System.out.println(g1.getT());
            Generic<Boolean> g2=new Generic<Boolean>();
            g2.setT(true);
            System.out.println(g2.getT());
    
        }
    }
    
    class Generic<T> {
        private T t;
    
        public Generic() {
        }
    
        public Generic(T t, T t1, T t2) {
            this.t = t;
        }
    
        public T getT() {
            return t;
        }
    
        public void setT(T t) {
            this.t = t;
        }
    
    
    }

**2.2 泛型方法**

public class Main {
        public static void main(String[] args) {
            Generic g=new Generic();
    
            g.show("123");
            g.show('a');
            g.show(true);
            g.show(12.13);
    
        }
    }
    class Generic<T> {
        public void show(T t) {
            System.out.println(t);
        }
    }

**2.3 泛型接口**

格式：修饰符interface接口名<类型>\{\}

范例：public interface Generic<T>\{\}

public class Main {
        public static void main(String[] args) {
            Genericimpl<String> g = new Genericimpl<String>();
            g.show("java");
            Genericimpl<Integer> g1=new Genericimpl<Integer>();
            g1.show(1);
            Genericimpl<Boolean> g2=new Genericimpl<Boolean>();
            g2.show(true);
        }
    }
    
    interface Generic<T> {
        void show(T t);
    }
    
    class Genericimpl<T> implements Generic<T> {
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }

**2.4 类型通配符：**

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

*  类型通配符：<?>
 *  List<?>:表示元素类型位置的List，它的元素可以匹配任何的类型。
 *  这种带通配符的List仅表示它是各种泛型LIst的父类，并不能把元素添加到其中

如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限。

*  类型通配符上限：<?extends 类型>
 *  List<?extends Number>:它表示的类型是Number或者其子类型。

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

*  类型通配符下限：<?super 类型>
 *  List<?super Number>:它表示的类型是Number或者其父类型。

import java.util.*;
    
    public class Main {
        public static void main(String[] args) {
           //类型通配符，<?>
            List<?> list1=new ArrayList<Object>();
            List<?> list2=new ArrayList<Number>();
            List<?> list3=new ArrayList<Integer>();
            System.out.println("--------------");
            //类型通配符上限：<? extends 类型>
           // List<? extends Number> list4 = new ArrayList<Object>();  报错
            List<? extends Number> list5 = new ArrayList<Number>();
            List<? extends Number> list6 = new ArrayList<Integer>();
            System.out.println("--------------");
            //类型通配符下限：<? super 类型>
            List<? super Number> list7 = new ArrayList<Object>();
            List<? super Number> list8 = new ArrayList<Number>();
            //List<? super Number> list9=new ArrayList<Integer>();  报错
    
        }
    }

**2.5 可变参数**

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了。

*  格式：修饰符 返回值类型 方法名（数据类型...变量名）\{\}
 *  范例：public static int usm（int...a）\{\}

可变参数注意事项

*  这里的变量其实是一个数组。
 *  如果一个方法有多个参数，包含可变参数，可变参数要放到最后。

public class Main {
        public static int sum(int b,int... a){
            int sum=b;
            for(int i:a){
                sum+=i;
            }
            return sum;
        };
        public static void main(String[] args) {
    
            System.out.println(sum(10,20,30,40));//100
    
        }
    }

**2.6 可变参数的使用**

**![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_13_color_FFFFFF_t_70_g_se_x_16][]**

[77dfce80be8544d4897a8f18feabc88b.png]: https://img-blog.csdnimg.cn/77dfce80be8544d4897a8f18feabc88b.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_13_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/ec4c851022f6496ba00ada9bba3707e7.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ==,size_13,color_FFFFFF,t_70,g_se,x_16