【java基础概述-5】详说泛型、解析Collection集合底层（Set和List集合底层）。

已于 2024-01-03 17:20:55 修改
阅读量1k 收藏 22
点赞数 32
分类专栏： Java 文章标签： java 开发语言
于 2024-01-03 17:19:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AiryCloud/article/details/135363856
版权

目录

1.泛型

1.1泛型的优点

1.2自定义泛型类

1.3自定义泛型方法

1.4自定义泛型接口

1.5泛型的通配符

 2.Collection集合的概述

2.1 Collection集合的常用API

        2.2 Collection集合的遍历方法

                2.2.1 迭代器遍历

                2.2.2  foreach集合遍历

                        2.2.3 Lambda表达式遍历（JDK1.8开始之后可用）

3. List系列集合的使用

       3.1 ArrayList集合

        3.2 LinkedList集合

4.Set系列集合的使用

        4.1 Set集合去重的方式

        4.2 Set集合底层分析。

        4.3 LinkedHashSet集合

    4.4 TreeSet集合

4.5集合总结

1.泛型

        概述：泛型是一个标签:<数据类型>

                泛型可以在编译阶段约束只能操作某种数据类型。

                注意：JDK1.7开始之后，泛型后面的申明可以省略不写

                泛型和集合都只支持引用数据类型，不支持基本数据类型。

例：

public class GenericityDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //jdk1.7之后不用写后面的泛型new ArrayList<>();
        list.add("Java");
        list.add("MySQl");
//        list.add(false);
//        list.add(99.9);
        System.out.println(list);
    }
}

1.1泛型的优点

                1.泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常。

                2.体现的是Java的严谨性和规范性，数据类型经常需要进行统一。

1.2自定义泛型类

        我们在之前使用泛型呢，都是别人写好给我们使用的，我们应该如何自定义自己的泛型类来使用。

        泛型类的概念：使用了泛型的类。

        泛型类的格式：

        修饰符 class 类名<泛型变量>{

        }

        泛型变量建议使用E、T、K、V

        例：

*       需求，模拟ArrayList自定义一个集合MyArrayList集合。
*       泛型类的核心思想：是把出现泛型的变量的地方全部替换成传输的真实数据类型。

public class GenericDemo {
    public static void main(String[] args) {
        MyArrayList<String> lists = new MyArrayList<>();
        lists.add("java");
        lists.add("mysql");

    }
}

class MyArrayList<E>{
    private ArrayList<E> list =new ArrayList();
    public void add(E e){
        list.add(e);
    }
    public void remove(E e){
        list.remove(e);
    }

    @Override
    public String toString() {
        return list.toString();
    }
}

1.3自定义泛型方法

                什么是泛型方法？

                定义了泛型的泛型方法。

                泛型方法的定义格式：

                修饰符<泛型变量> 返回值类型 方法参数(形参){

                }

                注意：方法定义了是什么泛型变量，后面就用什么泛型变量。

                泛型类的核心思想：是把泛型变量的地方全部替换成传输的真实数据类型。

public class GenericityDemo {
    public static void main(String[] args) {
        Integer[] nums ={10,20,30,40,50};
        String string = arrToString(nums);
        System.out.println(string);
    }
    //需求：给你任何一个类型的数组，都能返回它的内容。
    public static <T> String arrToString(T[] nums){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        if(nums!=null && nums.length > 0){
            for(int i=0;i<nums.length;i++){
                T ele=nums[i];
                sb.append(i== nums.length-1?ele:ele+",");
            }
        }

        sb.append("]");
        return sb.toString();
    }

}

1.4自定义泛型接口

        泛型接口的格式：

                修饰符 interface 接口名称 <泛型变量>{

                }

        泛型接口的核心思想：在实现接口的时候传入真实的数据类型。

        这样重写的方法就对该数据的操作。

        例子：

package _12自定义泛型接口;

public class Student {
}


package _12自定义泛型接口;

public class StudentImpl implements Data<Student>{
    @Override
    public boolean add(Student student) {
        return false;
    }

    @Override
    public boolean delete(Student student) {
        return false;
    }

    @Override
    public boolean update(Student student) {
        return false;
    }

    @Override
    public Student query(int id) {
        return null;
    }
}

package _12自定义泛型接口;

public class Teacher {
}

package _12自定义泛型接口;

public class TeacherImpl implements Data<Teacher>{
    @Override
    public boolean add(Teacher student) {
        return false;
    }

    @Override
    public boolean delete(Teacher student) {
        return false;
    }

    @Override
    public boolean update(Teacher student) {
        return false;
    }

    @Override
    public Teacher query(int id) {
        return null;
    }
}


public class GenericDemo {
    public static void main(String[] args) {
        Data<Student> studentData = new StudentImpl();
        studentData.add(new Student());
        Data<Teacher> teacherData =new TeacherImpl();
        teacherData.add(new Teacher());
    }

1.5泛型的通配符

        泛型的通配符是：？，就是什么类型都可以。

        泛型的上限：

        上限：? extends Car:也就是?的数据类型是继承了Car的类或者Car本身。

        泛型的下限：？super Car:也就是?的数据类型是Car的父类或者Car本身。

        注意：泛型没有继承关系，也即是子类不可以直接填写由父类约束的类型，如下图：

public class GenericDemo {
    public static void main(String[] args) {
        ArrayList<BWM> bmws = new ArrayList<>();
        bmws.add(new BWM());
        bmws.add(new BWM());
        bmws.add(new BWM());
        ArrayList<BENZ> benzs= new ArrayList<>();


        ArrayList<BWM> bwm = new ArrayList<>();
        bwm.add(new BWM());
        bwm.add(new BWM());
        bwm.add(new BWM());
        run(benzs);
        run(bwm);

    }

    //定义一个方法，可以让很多汽车一起进入参与比赛。
    // 如果写ArrayList<Car> cars，bwm和benz是进不来的
    public static void run(ArrayList<? extends Car> cars){
        System.out.println("进入了比赛");
    }
}

class Car{

}
class BWM extends Car{

}
class BENZ extends Car{

}

 2.Collection集合的概述

        什么是集合？答：集合是一个大小可变的容器，集合中的每一个数据称为一个元素。

        集合的特点：类型可以不确定，大小可以不固定，集合有很多种，不同的集合特点和使用场景不同。

        与数组不同，数组的大小和类型是一般固定的。

         集合有啥用？

        在开发中，很多元素的个数是不确定的。

        而且经常要进行元素的增删改查，集合是比较适合的。

        

        Java中集合的代表是Collection.

        Collection是Java集合中的祖宗类。

        那么我们就可以知道，学习Collection集合的功能，那么一切集合都是通用的！！

        

        集合的特点：

        Set系列集合，添加元素是无序不重复，无索引的。

        --HashSet：添加的元素无序，不重复，无索引。

        --LinkedHashSet:添加的元素是有序，不重复，无索引

        --TreeSet:按照升序默认排序！！

        List系列集合：添加的元素有序，可重复，有索引。

        --ArrayList:添加的元素有序，可重复，有索引。

        --LinkedList：添加的元素有序，可重复，有索引。

        --vector:无需掌握，已经淘汰，从jdk1.0便存在了。

        注意：Collection是集合的祖宗类,Collection集合的功能是一切集合可以使用的。

2.1 Collection集合的常用API

        public boolean add(E e):把给定的对象添加到当前集合中。

        public boolean remove(E e):把给定的对象从当前对象中删除。

        public void clear():清空集合中所有的元素。

        public boolean contains(Object obj):判断当前集合中是否包含给定的对象。

        public boolean isEmpty():判空

        public int size():集合元素个数。

        扩展：

        public boolean addAll(Object o):把集合o倒入当前集合。
public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        System.out.println(lists.add("贾乃亮"));
        System.out.println(lists.add("张三"));
        System.out.println(lists.add("张三"));
        System.out.println(lists.add("李四"));
        System.out.println(lists);//集合已经重写了toString方法

        //清空集合元素
//        lists.clear();
//        System.out.println(lists);

        //判断集合是否为空
        System.out.println(lists.isEmpty());

        //判断集合个数
        System.out.println(lists.size());

        //删除某个元素,默认删除第一个。
        System.out.println(lists.remove("张三"));
        System.out.println(lists);

        //把集合转换成数组
        Object[] array = lists.toArray();
        System.out.println(Arrays.toString(array));

    }
}

        2.2 Collection集合的遍历方法

                2.2.1 迭代器遍历

                        public Iterator iterator():获取集合对应的迭代器，用来遍历集合中元素的。

                        E next():获取下一个迭代器。

                        boolean hasNext()：判断是否有下一个元素，有返回true否则false.

                        

public class CollectionDemo01 {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("张三");
        lists.add("周芷若");

        //1.迭代器遍历
        Iterator<String> iterator = lists.iterator();
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());//报错，没有此元素Exception in thread "main" java.util.NoSuchElementException
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

                2.2.2  foreach集合遍历

        

public class CollectionDemo02 {
    /*
    *foreach遍历集合
    *   for(类型 变量名称:被遍历的数组或者集合)
    * */
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("赵四");
        lists.add("张三");
        for (String s : lists){
            System.out.println(s);
        }

    }

}

                        2.2.3 Lambda表达式遍历（JDK1.8开始之后可用）

public class CollectionDemo03 {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("张三");
        lists.add("李四");
        lists.add("王五");
        System.out.println(lists);
        lists.forEach(s->{
            System.out.println(s);
        });
    }
}

3. List系列集合的使用

        List集合继承了Collection集合的全部功能，同时因为List集合有索引，自己也重载了一些方法。

       3.1 ArrayList集合

特点：基于顺序表（数组）实现，查询快，增删慢。

        List集合多了个索引，所以多了许多按照索引操作数据的功能：

        -public void add(int index,E element):将指定的元素。

        -public E get(int index):返回集合中的指定位置的元素。

        -public E remove(int index):移除指定位置的元素，并返回被删除元素的值。

        -public E set(int index,E element)：用指定元素替换指定的元素，返回的是更新后的值。

public class ListDemo01 {
    public static void main(String[] args) {
        //创建一个ArrayList集合对象，这是一行经典代码!!
        ArrayList<String> lists = new ArrayList<>();
        //在某个索引位置插入元素。
        lists.add(0,"张三");
        lists.add(1,"李四");
        lists.add(2,"王五");
        lists.add(3,"赵六");
        //根据索引删除元素
        lists.remove(0);
        lists.forEach(s-> System.out.println(s));
        //根据索引获取元素
        System.out.println("-------");
        System.out.println(lists.get(0));
        //修改索引位置的元素
        System.out.println("---------");
        lists.set(0,"张三");
        lists.forEach(s-> System.out.println(s));
    }
}

        注意：因为ArrayList集合有索引，所以我们也可以用for遍历

public class ListDemo02 {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("java1");
        lists.add("java2");
        lists.add("java3");
        lists.add("java4");

        for(int i=0;i<lists.size();i++){
            System.out.println(lists.get(i));
        }
    }
}

        3.2 LinkedList集合

        LinkedList底层是基于链表，增删比较快，查询比较慢（这是相对而言比较慢 ）

        LinkedList是支持双链表的，定位前后的元素是非常快的，增删前后的元素也是最快的！！！

        --public void addFirst():头插法。

        --public void addLast():尾插法。

        --public E getFirst():返回第一个元素。

        --public E getLast():返回最后一个元素。

        --public E removeFirst():头插法

        --public E removeLast():尾删法

        --public E pop():从此列表所表示的堆栈中弹出一个元素。

        --public void push(E e):压栈。

        注：可用来做栈或者队列。

public class ListDemo03 {
    public static void main(String[] args) {
        //用Linked做一个队列
        LinkedList<String> strings = new LinkedList<>();
        strings.addFirst("1");
        strings.addFirst("2");
        strings.addFirst("3");
        System.out.println(strings.removeLast());

        //栈
        LinkedList<String> Stack = new LinkedList<>();
//        Stack.addFirst("1");
//        Stack.addFirst("2");
//        Stack.addFirst("3");
//        System.out.println(Stack.removeFirst());
        Stack.push("1");
        Stack.push("2");
        Stack.push("3");
        System.out.println(Stack.pop());
    }
}

4.Set系列集合的使用

        特征：无序，不重复，无索引的。

public class HashSetDemo01 {
    public static void main(String[] args) {
        HashSet<String> sets = new HashSet<>();
        sets.add("mysql");
        sets.add("Java");
        sets.add("mybatis");//与添加的顺序不一样。
        sets.forEach(s-> System.out.println(s));

    }
}

        面试重点：

        Set集合为什么是无序的？？

        Set集合为什么是无重复的？？是如何去重的？？        

        4.1 Set集合去重的方式

        1.对于基本值类型，Set集合可以直接判断进行去重。

        2.对于引用数据类型的类对象，Set集合是按照如下流程进行的。

        

        

        4.2 Set集合底层分析。

        Set集合是基于哈希存储的。

        它的增删改查的性能都很好！！，但是它是无序的不重复的。

        JDK1.8之前，哈希表 = 数组+链表+（哈希算法），如下图。

        JDK1.8之后，哈希表=数组+链表+红黑树+(哈希算法)，如下图。

        4.3 LinkedHashSet集合

        HashSet集合我们都知道，是无序的，上面的哈希表存储的方式我们就知道了，但是LinkedHashSet为什么又是有序的呢，其实LinkedHashSert也是哈希表存储，实现有序的方式就是每一个元素多一个值，用来记录下一个元素的地址，实质上是链表存储每一个元素。

    4.4 TreeSet集合

        排序不重复集合。     

        TreeSet集合：不重复，无索引，默认按照升序排列！！

        TreeSet集合被称为排序不重复集合，可以对元素进行默认的升序排序。

        排序规则：

  1.  数值类型：按照大小升序排序
  2. 字符串类型：按照首字母排序。
  3. 引用类型排序规则：对于自定义的引用规则，TreeSet默认规则无法排序，需要我们自己定制排序规则，有2重方式：

        a.直接为对象的类实现comparable接口，重写比较方法.

        b.直接在集合中设置比较器对象Comparator对象（优先级更高）：

        规则：

         --当比较着大于被比较者，返回正数

        --当比较着小于被比较者，返回负数

         --当比较着等于被比较着，返回0

package _04Set系列集合;

import java.util.Objects;

public class Student implements Comparable<Student> {
    private String name;

    /*
    * TreeSet集合想要对引用类型排序，那么必须重写comparableTo方法。
    *
    * 比较着:this
    * 被比较者:o
    * 需求：按照年龄比较
    * */
    @Override
    public int compareTo(Student o) {
        //规则：如果程序员认为比较着大于被比较者，返回正数！
        //如果程序员认为比较着小于被比较者，返回负数！
        //如果程序员认为比较者等于被比较者，返回0！
        return this.age - o.age;
    }

    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

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

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


public class  TreeSetDemo05 {
    public static void main(String[] args) {
        TreeSet<Integer> scores = new TreeSet<>();
        scores.add(1);
        scores.add(4);
        scores.add(3);
        scores.add(2);
        System.out.println(scores);
        //如果是字符串，按照首字母编号排序。

        TreeSet<String> str = new TreeSet<>();
        str.add("apple");
        str.add("orange");
        str.add("max");
        str.add("min");
        str.add("c");
        System.out.println(str);

        //a.引用数据类型定义TreeSet集合，报错，因为不知道怎么拍徐，默认无法排序。报错：Exception in thread "main" java.lang.ClassCastException: _04Set系列集合.Student cannot be cast to java.lang.Comparable
        TreeSet<Student> stu = new TreeSet<>();
        stu.add(new Student("张三", 18));
        stu.add(new Student("李四", 16));
        stu.add(new Student("王五", 20));
        stu.add(new Student("赵六", 30));
        System.out.println(stu);

        //b.直接为集合自定义比较规则。这个的优先级比类的高。
        TreeSet<Student> stu2 = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        stu.add(new Student("张三", 18));
        stu.add(new Student("李四", 16));
        stu.add(new Student("王五", 20));
        stu.add(new Student("赵六", 30));
        System.out.println(stu);

    }
}

4.5集合总结

        1.如果希望元素可以重复，有索引，查询要快用ArrayList集合。

        2.如果希望元素可以重复，又有索引，增删快用LinkedList集合。

        3.如果希望增删改查都很快，但是元素不重复以及无序列无索引，那么用HashSet集合。

        4.如果希望增删改查都很快且有序，但是元素不重复无索引，那么用LinkedHashSet集合。

努力奋斗的张同学
关注
  • 32
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
压测之道-详说压测的那些事情.pdf
08-08
压测之道-详说压测的那些事情.pdf
详说如何用C，C＋＋和JAVA读入和保存位图
03-19
有位图文件结构的详细介绍，已经用C，C＋＋和JAVA进行读入和保存位图等相关操作
bcprov-ext-jdk15on-154.jar和bcprov-jdk15on-154.jar
11-26
解决javax.net.ssl.SSLException: java.lang.RuntimeException: Could not generate DH keypair异常所需jar包 首先第一种方法的话，因为Java8版本是颠覆性的，一旦换了之后代码就会发生不同程度的报错问题。因此个人不推荐。 其次就是第二种方法以及第三种方法，操作起来比较复杂，网上也有挺多的解释，所以我也不在这里详说了。不说的原因一是复杂，而是其解决的方法对于我而言没有起到作用，就算改了还是会报出原来的异常。 然后下载完毕之后就需要将这两个jar包放到 $JAVA_HOME/jre/lib/ext 放在指定的目录下之后，接下来就需要对一个文件进行编辑 这个文件的位置在 $JAVA_HOME/jre/lib/security/ 对这个路径下的java.security文件进行修改 找到security.provider.9，然后在这句话下面加上：security.provider.10=org.bouncycastle.jce.provider.BouncyCastleProvider 加上了之后，重启
直流变换器设计及参数详说-综合文档
05-23
直流变换器设计及参数详说
布隆过滤器-详说布隆过滤器.pdf
08-08
布隆过滤器-详说布隆过滤器.pdf
面试常考问题：Java泛型的底层原理是什么？
程序员小灰的博客
03-02 741
本文来自读者小志的投稿导语笔者在最近的日常工作中，因业务需要，研究 Java 字节码层面的知识。具体是，需要根据类字节码，获取特定方法名的方法入参，此方法名在源码中只有一个。但是在实际使用...
java 泛型底层原理_JAVA-泛型 底层细节
weixin_31985599的博客
02-16 1006
也许泛型最具挑战性的方面是擦除(erasure)，这是 Java语言中泛型实现的底层技术。擦除意味着编译器在生成类文件时基本上会抛开参数化类的大量类型信息。编译器用它的强制类型转换生成代码，就像程序员在泛型出现之前手工所做的一样。区别在于，编译器开始已经验证了大量如果没有泛型就不会验证的类型安全约束。尽管不能将 ArrayList赋给 ArrayList，因为它们不是协变的，但是ArrayLis...
Java 泛型之 JDK 的底层实现原理
禅与计算机程序设计艺术
08-18 8547
AnnotatedType 数组类型、参数化类型和 类型变量，或通配符类型. package java.lang.reflect; /** * {@code AnnotatedType} represents the potentially annotated use of a type in * the program currently running in this VM. The u...
Java泛型的实现原理
xyjikl
11-17 2141
由于前一段时间发现公司有些代码重复性很大，可以使用泛型方法简化，所以向领导提出，领导就让我整理了一下关于泛型的只是分享给大家。 一、Java泛型介绍       泛型是Java 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。          Java泛型被引入的好处是安全
[疯狂Java]泛型：泛型的底层原理（类型擦除、原生类型、编译前检查）
Lirx_Tech的专栏
06-07 1873
1.
Java泛型的实现：原理与问题
热门推荐
yi_Afly的专栏
07-23 1万+
很久没写博客了，因为项目和一些个人原因。最近复习找工作，看书+回想项目后有一些心得，加上博客停更这么长时间以来的积累，很是有些东西可写。从今儿开始，慢慢把之前积累的东西补上来，方便以后查漏补缺。 先从最近的开始。昨天看到Java泛型相关的内容，有些疑惑，查资料之后发现这部分很有些有意思的东西，比如类型擦除带来的重写问题等等，一并记录在这篇文章里。1. 泛型定义看了很多泛型的解释百度百科，解释1，解
【JVM】java中泛型底层是如何实现的？？
CAFE-BABE的博客
07-07 2206
首先说说语法糖 首先，在讲java中的泛型之前，需要介绍一下语法糖。什么是语法糖呢？ 简单来说，就是在计算机语言里面通过添加某种语法，这种语法不会对语言的编译结果产生实际的影响，但是可以使得程序员更方便的使用该语言，增加程序的可读性，减少代码量，提高开发效率。java里面常见的语法糖除了泛型除了之外，还有自动装箱拆箱，变长参数，他们都是语法糖。 但是实际上JVM虚拟机并不支持这些语法糖中的语法，他们会在编译阶段被还原成原始的基本语法结构。 再谈泛型 现在我们了解到了，泛型其实是java语法糖里面的
【系列】重新认识Java——泛型（基础、使用和实现原理）
HinyLover的专栏
03-18 4620
泛型是Java中重要知识点，是必须要深刻掌握的内容。由于泛型相关的内容比较多，基于单一知识原则，笔者打算将泛型部分分开成两部分书写。本文主要的内容如下： 泛型基础概念 泛型的分类、定义和使用
《Java核心技术卷I》泛型篇笔记(二) 泛型底层原理——泛型擦除
mrhanzhou5273的博客
03-04 758
写在最前：本笔记全程参考《Java核心技术卷I》，添加了一些个人的思考和整理 泛型底层原理 虚拟机没有泛型类型对象，所有对象都将转换为普通类。   1. 类型擦除 定义一个泛型类型时会自动提供一个原始类型(raw type)，它的名字就是去掉类型参数之后的泛型类型名。类型变量会被擦除，并替换为其限定类型（或者，对于无限定的变量替换为Object） 例如，Pair<T>的原代码如下： public class Pair<T> { private T first; p.
Java泛型（一）——你所不知道的那些泛型背后
David-Kuper的专栏
11-15 1946
一泛型 1编译期确定类型安全泛型Generics 2参数化类型与原始类型的兼容性 3类型擦除 4泛型的定义与使用 Java泛型(一)——泛型的定义与使用 Java泛型（二）——使用Gson解析嵌套泛型数组一、泛型1、编译期确定类型安全——泛型（Generics）泛型是提供给Javac编译器使用的。可以限定集合中输入的类型，让编译器在编译期间避免原始程序的非法输入，编译器编译带类型说明的集合时会去掉
Java 容器泛型_底层源码解读 尚学堂133
BOKEhhh的博客
07-22 139
先上代码： import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap; public class Test { public static void main(String[] args) { List<String> list = new ArrayList<String>(); Map map = new HashMap();.
JAVA泛型实现原理
weixin_33943347的博客
10-27 1116
1. Java范型时编译时技术，在运行时不包含范型信息，仅仅Class的实例中包含了类型参数的定义信息。 泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源码到源码的转换，它把泛型版本转换成非泛型版本。 基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉...
JAVA 学习·泛型（二）——通配泛型
最新发布
wr114514的博客
05-02 1056
介绍了Java泛型中的重要知识点——通配泛型及其应用。
获取Java 虚拟机进程ID（java应用进程Id的方法） Linux & windows
weixin_44131922的博客
04-30 501
这个命令会列出所有包含"java"的进程信息。从中你可以找到你的Java应用对应的进程行，第一列就是进程ID（PID）。这个命令会列出所有包含"java"的进程信息。在输出的信息中，你可以找到Java进程及其PID。替换为你的Java主类名或jar文件名的部分匹配字符串，pgrep会直接返回对应的进程ID。如果你需要在Java程序内部获取其自身的进程ID，可以使用。这段代码会打印出当前运行Java程序的进程ID。
详说jenkinsfiles编写规范
04-28
Jenkinsfile是Jenkins上的一种DSL脚本，用于定义Pipeline，将多个步骤组合起来形成一个集成过程。编写规范如下： 1. 文件名必须为Jenkinsfile，且必须放置于项目的根目录下。 2. Jenkinsfile必须使用Groovy语言编写，并遵循Jenkins Pipeline语法。 3. Jenkinsfile需要定义一个全局的Pipeline，以及一个或多个Stage，每个Stage代表一个构建过程。 4. Stage之间可以定义Dependencies，以及Parallel子操作。 5. 可以使用when语句指定构建条件，例如当Git提交时构建。 6. 可以使用Environment 列出构建所用的环境变量，例如Git仓库地址、JDK版本等。 7. 脚本应该保持简短，避免使用过多的if、else等语句，脚本逻辑应该清晰明了。 8. 脚本最终需要提供构建完成后的输出结果，通常表现为Jenkins的构建报告、文本输出或者发送邮件等。 注意：以上内容仅代表个人观点，具体实现方式请结合具体项目需求及实际情况酌情调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力奋斗的张同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值