day19泛型&增强for循环&静态导入&可变参数&Set集合（HashSet&TreeSet）

已于 2022-02-15 20:28:48 修改
阅读量224 收藏
点赞数
文章标签： java
于 2022-02-12 21:27:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qnmdlzg/article/details/122900596
版权

                泛型：
                    把明确数据类型的工作，提前到了编译时期，在创建集合的时候明确存储元素的数据类型。
                    这样的做法有点向把数据类型当作参数一样传递，所以泛型还有一个叫法：参数化类型

                泛型的语句定义格式：
                    <引用数据类型>
                    注意：尖括号中的数据类型只能是引用数据类型

                泛型的好处：
                    1、将我们运行时期出现的问题，提前到编译时期
                    2、不需要做强制类型转换
                    3、优化了代码。消除了不必要的黄色警告线，使代码看起来更简洁

package com.shujia.wyh.day18;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {
        //创建一个List集合对象
        //在JDK1.7之后，泛型会进行自动类型推断
        ArrayList<String> list = new ArrayList<>();

        //向集合中添加元素
        list.add("hello");
        list.add("hello");
        list.add("hello");
        list.add("hello");
        list.add("hello");

        //遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }

    }
}

            泛型通配符<?>
                任意类型，如果没有明确，那么就是Object以及任意的Java类了
            ? extends E
                向下限定，E及其子类
            ? super E
                向上限定，E及其父类

package com.shujia.wyh.day19;

import java.util.ArrayList;

class Animal {
}

class Cat extends Animal{
}

class Dog extends Animal{
}

public class GenericDemo1 {
    public static void main(String[] args) {
        ArrayList<Animal> list1 = new ArrayList<Animal>();
        ArrayList<Dog> list2 = new ArrayList<Dog>();
        ArrayList<Object> list3 = new ArrayList<Object>();

        //泛型通配符<?>
        //任意类型，如果没有明确，那么就是Object以及任意的Java类了
        ArrayList<?> list4 = new ArrayList<Animal>();
        ArrayList<?> list5 = new ArrayList<Dog>();
        ArrayList<?> list6 = new ArrayList<Object>();

        //? extends E  向下限定，E及其子类
        ArrayList<? extends Animal> list7 = new ArrayList<Animal>();
        ArrayList<? extends Animal> list8 = new ArrayList<Dog>();
        ArrayList<? extends Animal> list9 = new ArrayList<Cat>();

        //? super E  向上限定，E及其父类
        ArrayList<? super Animal> list11 = new ArrayList<Animal>();
        ArrayList<? super Animal> list13 = new ArrayList<Object>();



    }
}

        泛型类
            把泛型定义在类上
            格式:public class 类名<泛型类型1,…>
            注意:泛型类型必须是引用类型

package com.shujia.wyh.day19;

class GenericTool1<T> {
    private T obj;

    public T getObj(){
        return obj;
    }

    public void setObj(T obj){
        this.obj = obj;
    }

}
public class GenericTest1 {
    public static void main(String[] args) {
        GenericTool1<String> gt2 = new GenericTool1<>();
        gt2.setObj("hello");

        String obj = gt2.getObj();


    }
}

        泛型方法
            把泛型定义在方法上
            格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

package com.shujia.wyh.day19;

public class GenericTool2 {
    //用泛型方法，将来不确定要传入什么类型的数据
    public <F> void show(F f){
        System.out.println(f);
    }

}
public class GenericTest2 {
    public static void main(String[] args) {
        GenericTool2 genericTool2 = new GenericTool2();
        genericTool2.show("hello");
        genericTool2.show(10);
        genericTool2.show(12.34);

    }
}

        泛型接口
            把泛型定义在接口上
            格式:public  interface 接口名<泛型类型1…>

package com.shujia.wyh.day19;

interface GenericTool3<W> {
    public void show(W w);
}

class GenericTool3Impl<W> implements GenericTool3<W>{
    @Override
    public void show(W w) {
        System.out.println(w);
    }
}

public class GenericTest3 {
    public static void main(String[] args) {
        GenericTool3Impl<String> stringGenericTool3 = new GenericTool3Impl<>();
        stringGenericTool3.show("hello");
        stringGenericTool3.show(20);
    }
}

        增强for循环概述：简化数组和Collection集合的遍历

        语句定义格式：
            for(元素数据类型 变量名（自定义） : 数组或者Collection集合) {
                使用变量即可，该变量就是元素
            }
        好处：简化遍历

package com.shujia.wyh.day19;

import java.util.ArrayList;

public class ForDemo {
    public static void main(String[] args) {       
        ArrayList<String> strings = new ArrayList<>();
        strings.add("hello");
        strings.add("world");
        strings.add("java");
        strings.add("bigdata");
        strings.add("hadoop");

        for(String string : strings){
            System.out.println(string);
        }

    }
}

        静态导入：
            语句定义格式：import static 包名...类名.方法名;
            可以直接导入到方法级别

        注意事项：
            方法必须是静态的

        可变参数概述
            定义方法的时候不知道该定义多少个参数
        格式
            修饰符 返回值类型 方法名(数据类型…  变量名){}
        注意：
            这里的变量其实是一个数组
            如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

        Arrays工具类中的一个方法
            public static <T> List<T> asList(T... a)

package com.shujia.wyh.day19;

import java.util.Arrays;
import java.util.List;

public class ArgsDemo {
    public static void main(String[] args) {
        //使用方法求两个数之和
        int a = 10;
        int b = 20;
        sum(a, b);

        //使用方法求三个数之和
        int c = 30;
        sum(a, b, c);

        //使用方法求四个数之和
        int d = 40;
        sum(a, b, c, d);

        sum("小明", 90, 92, 93);


    }


    //当使用可变参数定义方法时候，有其他数据类型参与的时候，将可变参数的定义放在最后
    public static void sum(String name, int... ints) {
        int sum = 0;
        for (int i : ints) {
            sum += i;
        }
        System.out.println(name + "学生的总成绩为：" + sum);
    }

    //使用可变参数的形式定义加法的方法
    //注意可变参数的变量最终是一个数组的变量名
    //这里将来传入多个参数的时候，内部会自动将这多个参数形成一个数组，数组名就是我们定义的ints
    public static void sum(int... ints) {
        int sum = 0;
        for (int i : ints) {
            sum += i;
        }

        System.out.println(ints.length + "个数之和为：" + sum);
    }


}

        Set集合：元素是唯一的，并且元素的顺序是无序的集合

        HashSet： 元素有序唯一 无序

        对象类需要重写equals()，hashCode()方法  

package com.shujia.wyh.day19;

import java.util.HashSet;
import java.util.Set;
import java.util.Objects;

class Student2 {
    private String name;
    private int age;

    public Student2() {
    }

    public Student2(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student2 student2 = (Student2) o;
        return age == student2.age && Objects.equals(name, student2.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


}


public class SetDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        Set<Student2> student2s = new HashSet<>();

        //创建学生对象
        Student2 s1 = new Student2("小明", 18);
        Student2 s2 = new Student2("小王", 17);
        Student2 s3 = new Student2("小周", 19);
        Student2 s4 = new Student2("小明", 18);

        //将学生对象添加到集合中
        student2s.add(s1);
        student2s.add(s2);
        student2s.add(s3);
        student2s.add(s4);

        //遍历
        for (Student2 student2 : student2s) {
            System.out.println(student2);
        }


    }
}

        LinkedHashSet(父类HashSet)：
            1、底层数据结构是哈希表和链表
            2、哈希表保证元素的唯一
            3、链表保证了元素的有序（存储和取出的顺序一致）
            4、线程不安全，效率高

        TreeSet:元素唯一，元素可以按照某种规则进行排序
        两种排序方式：
            自然排序        对象类需要实现Comparable接口并重写compareTo()方法 （无参构造方法)
            比较器排序        对象类需要实现Comparable接口并重写compare()方法（有参构造方法所以可匿名内部类实现）

                自然排序

package com.shujia.wyh.day19;

import java.util.TreeSet;
import java.util.Objects;

class Student3 implements Comparable<Student3>{
    private String name;
    private int age;

    public Student3() {
    }

    public Student3(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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student3 o) {
        //年龄一样，姓名不一定一样
        int i = this.age - o.age;
        //判断姓名是否一样（三目运算符）
        int i2 = i == 0 ? this.name.compareTo(o.name) : i;
        return i2;
    }
}

class Student4 implements Comparable<Student4> {
    private String name;
    private int age;

    public Student4() {
    }

    public Student4(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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student4 o) {
        //主要条件：姓名的长度排序
        int i = this.name.length() - o.name.length();
        //长度一样，姓名内容不一定一样
        int i2 = i == 0 ? this.name.compareTo(o.name) : i;
        //姓名内容一样，年龄的大小不一定一样
        int i3 = i2 == 0 ? this.age - o.age : i2;

        return i3;

    }
}

public class TreeSetDemo2 {
    public static void main(String[] args) {
        //创建TreeSet集合
        TreeSet<Student3> set = new TreeSet<>();

        //创建学生对象
        Student3 s1 = new Student3("theshy", 20);
        Student3 s2 = new Student3("xiaohu", 24);
        Student3 s3 = new Student3("uzi", 25);
        Student3 s4 = new Student3("卡萨", 22);
        Student3 s5 = new Student3("rookie", 23);
        Student3 s6 = new Student3("姿态", 21);
        Student3 s7 = new Student3("faker", 25);
        Student3 s8 = new Student3("xiaohu", 24);

        //将学生对象添加到集合中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        set.add(s6);
        set.add(s7);
        set.add(s8);

        for(Student3 student3 : set){
            System.out.println(student3);
        }

        for(Student4 student4 : set){
            System.out.println(student4);
        }
    }
}

        比较器排序
        利用TreeSet创建对象时的带参数的构造方法来进行比较器排序
        TreeSet(Comparator<? super E> comparator)
        构造一个新的，空的树集，根据指定的比较器进行排序

package com.shujia.wyh.day19;

import java.util.Comparator;
import java.util.TreeSet;

class Student5 {
    private String name;
    private int age;

    public Student5() {
    }

    public Student5(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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TreeSetDemo4 {
    public static void main(String[] args) {
        //匿名内部类实现Comparator接口
        TreeSet<Student5> set = new TreeSet<>(new Comparator<Student5>() {
            @Override
            public int compare(Student5 o1, Student5 o2) {
                //主要条件：姓名的长度排序
                int i = o1.getName().length() - o2.getName().length();
                //长度一样，姓名内容不一定一样
                int i2 = i == 0 ? o1.getName().compareTo(o2.getName()) : i;
                //姓名内容一样，年龄的大小不一定一样
                int i3 = i2 == 0 ? o1.getAge() - o2.getAge() : i2;

                return i3;
            }
        });


        //创建学生对象
        Student5 s1 = new Student5("mingwang", 18);
        Student5 s2 = new Student5("wangyu", 19);
        Student5 s3 = new Student5("zhoujiaxiang", 17);
        Student5 s4 = new Student5("zhangbaogui", 18);
        Student5 s5 = new Student5("liuzhicheng", 18);
        Student5 s6 = new Student5("wangyu", 20);

        //将学生对象添加到集合中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        set.add(s6);

        for(Student5 Student5 : set){
            System.out.println(Student5);
        }



    }
}

qnmdlzg
关注
泛型<编程>：转移构造函数
02-22
我想你们知道得很清楚，创建，拷贝，并摧毁临时对象是你的C++编译器爱做的事，临时对象在内部被创建，不幸的是这极大影响到了C++程序的执行效率。...例如，你应该把目标对象作为函数的一个参数传进
List的三个子类、泛型、增强for循环
qfmy__的博客
05-06 680
List的三个子类 ArrayList类：该类也是实现了List的接口。 public class test { public static void main(String[] args) { List<String> list=new ArrayList<String>(); list.add("Hello"); ...
java集合for循环_详解Java中list,set,map的遍历与增强for循环
weixin_28923455的博客
02-12 498
详解Java中list,set,map的遍历与增强for循环Java集合类可分为三大块，分别是从Collection接口延伸出的List、Set和以键值对形式作存储的Map类型集合。关于增强for循环,需要注意的是，使用增强for循环无法访问数组下标值，对于集合的遍历其内部采用的也是Iterator的相关方法。如果只做简单遍历读取，增强for循环确实减轻不少的代码量。集合概念:1.作用:用于存放对...
泛型<编程>：实施（Enforcements）
03-05
你知道，当一个概念从一...在所有泛型<编程>系列文章中都有一个成功的要素，就是进行特有至通用的“文法升华。”比如，在ScopeGuard中增加了放入“撤消”动作于正常执行路径而当一个复杂操作成功时解除“撤消”的常
泛型<编程>：类型化缓存(I)
03-05
想象本篇你正要读的“泛型<编程>”部分的开头是：“本文关于怎样用C++处理内存缓冲”。当你轻率地关掉浏览器时，如果竖起耳朵，你还会听到成千上万的鼠标在做和你一样的事情。因为谁会对处理内存缓冲这样的小事感...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 720
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 871
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 332
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 1044
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 462
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
GEMM优化（待更新）
qq_62704693的博客
11-03 807
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 336
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
greendao使用封装
白高林的专栏
11-07 319
greenDAO
【JAVA】Java基础—面向对象编程基础：类与对象的概念
thinking_chou的专栏
11-07 916
类是一个用户定义的数据类型，它包含了属性和方法。属性用于描述对象的特征，方法用于描述对象的行为。类与对象是Java编程的核心概念。类是对象的蓝图，定义了对象的属性和方法；对象是类的实例，具有独立的状态和行为。通过类与对象，我们可以更好地模拟现实世界中的事物，使得程序设计更加清晰和模块化。
【前端】JavaScript 方法速查大全-DOM、BOM、时间、处理JS原生问题（三）
万物皆有灵
11-06 928
在现代Web开发中，JavaScript是不可或缺的编程语言。无论是前端开发还是后端服务，掌握JavaScript的各种方法和技巧都是每位开发者的必修课。本文将为您提供一个全面、系统的JavaScript方法参考，涵盖数组操作、对象处理、DOM与BOM接口、时间处理、解决JS原生问题、函数应用、正则表达式、数据格式转换、随机数生成、文本处理等众多方面。无论您是初学者还是资深开发者，这份速查大全都将成为您日常开发中的得力助手！💪。
JMS消息中间件
刘皇叔说Java的博客
11-04 951
JMS（Java Message Service）即 Java 消息服务应用程序接口，是一个 Java 平台中关于面向消息中间件（MOM）的 API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java 消息服务是一个与具体平台无关的 API，绝大多数 MOM 提供商都对JMS 提供支持。简短来说，JMS 是一种与厂商无关的 API，是 sun 公司为了统一厂商的接口规范，而定义出的一组api接口，用来访问消息收发系统消息。
JAVA制作SSO用户中心实现同步登录
最新发布
qq_27246521的博客
11-07 45
如果用户中心的redis出现问题。一般是通过前端访问后端接口时请求中的Authorization 实现的。登录时在用户中心redis保存 code与token的对应关系。此链接跳转时，用code获取token及用户信息返回前端即可。而且 其它系统有自己的注册模块还需要同步注册信息至用户中心。是没有保存session信息的。则通过不同系统跳转时通过，跳转连接后添加code。则通过不同系统跳转时通过，跳转连接后添加code。如果前端项目是不同的分开的。跳转进入的系统 这时通过接口请求用户中心。
Spring 设计模式之责任链模式
qq_20236937的博客
11-05 704
Spring 设计模式之责任链模式
Spring IoC——依赖注入
2202_76097976的博客
11-02 2789
DI，也就是依赖注入，在容器中建立的 bean （对象）与 bean 之间是有依赖关系的，如果直接把对象存在 IoC 容器中，那么就都是一个独立的对象，通过建立他们的依赖关系，才能拿出一个对象，然后与它建立依赖关系的对象就也可以使用，在 Spring 的 IoC 容器中，通过配置可以明确各个 Bean之间的依赖关系当一个 Bean 需要另一个 Bean 时，IoC 容器会自动将依赖的 Bean 注入进来，这个过程就是依赖注入。
Java泛型与集合详解：Naftalin & Wadler权威指南
3. 泛型在集合中的应用：作者展示了如何利用泛型增强集合类的功能，如创建类型安全的自定义集合类，以及在并发编程中处理线程安全的问题。 4. 类型推断和自动装箱/拆箱：书中讨论了Java编译器如何通过类型推断自动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值