【Java集合进阶】LinkedList和迭代器的源码分析泛型类、泛型方法、泛型接口

🍬 博主介绍

👨‍🎓 博主介绍：大家好，我是 hacker-routing ，很高兴认识大家~
✨主攻领域：【渗透领域】【应急响应】 【Java】 【VulnHub靶场复现】【面试分析】
🎉点赞➕评论➕收藏 == 养成习惯（一键三连）😋
🎉欢迎关注💗一起学习👍一起讨论⭐️一起进步📝文末有彩蛋
🙏作者水平有限，欢迎各位大佬指点，相互学习进步！

LinkedList和迭代器的源码分析

ArraList集合底层原理

LinkedList集合

LinkedList底层源码分析

泛型类、泛型方法、泛型接口

泛型深入

泛型的好处及拓展

泛型的细节

1、泛型类

代码演示：

2、泛型方法

练习泛型方法的练习

3、泛型接口

LinkedList和迭代器的源码分析

ArraList集合底层原理

利用空参创建的集合，在底层创建一个默认长度为0的数组
添加第一个元素时，底层会创建一个新的长度为10的数组
存满时，会扩容1.5倍
如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

LinkedList集合

底层数据结构是双链表，查询慢，增删快，但是如果操作的是首尾元素，速度也是极快的。
LinkedList本身多了很多直接操作首尾元素的特有API。

LinkedList底层源码分析

泛型类、泛型方法、泛型接口

泛型深入

泛型：是jdk5中引入的特性，可以在编译阶段约束的数据类型，并进行检查。

泛型的格式：<数类型>

注意：泛型只能支持引用数据类型

不使用泛型，无法使用前面的特有行为

package list;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Objects;

public class generics {
    public static void main(String[] args) {
        //没有泛型的时候，集合如何存储数据
        //结论：
        //如果我们没有给集合指定类型，默认认为所有的数据类型都是Object类型
        //此时可以往集合添加任意的数据类型。
        //带来一个坏处：我们在获取数据的时候，无法使用他的特有行为。

        //此时推出了泛型，可以在添加数据的时候就把类型进行统一。
        //而且我们在获取数据的时候，也省的强转了，非常的方便。

        //1、创建集合的对象
        ArrayList list = new ArrayList();

        //2、添加数据
        list.add(123);
        list.add("aaa");
        list.add(new student("zhangsan",21));


        //3、遍历集合获取里面的每一个元素
        Iterator it = list.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

使用泛型：

package list;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Objects;

public class generics {
    public static void main(String[] args) {
        //没有泛型的时候，集合如何存储数据
        //结论：
        //如果我们没有给集合指定类型，默认认为所有的数据类型都是Object类型
        //此时可以往集合添加任意的数据类型。
        //带来一个坏处：我们在获取数据的时候，无法使用他的特有行为。

        //此时推出了泛型，可以在添加数据的时候就把类型进行统一。
        //而且我们在获取数据的时候，也省的强转了，非常的方便。

        //1、创建集合的对象
        ArrayList<String> list = new ArrayList<>();

        //2、添加数据
        list.add("aaa");

        //3、遍历集合获取里面的每一个元素
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String str = it.next();
            //多态的弊端是不能访问子类的特有功能
            System.out.println(str);
        }
    }
}

泛型的好处及拓展

统一数据类型。

把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来。

泛型的细节

泛型中不能写基本数据类型
指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
如果不写泛型，类型默认是Object

1、泛型类

代码演示：

package list;

import java.util.Arrays;
import java.util.Objects;

public class myarraylist<E> {
    Object[] obj = new Object[10];
    int size;

    /*
    E : 表示是不确定的类型。该类型在类名后面已经定义过了。
    e：形参的名字，变量名
    * */
    public boolean add(E e){
        obj[size] = e;
        size++;
        return true;
    }


    public E get(int index){
        return (E)obj[index];
    }


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

package list;

public class GenericsDemo2 {
    public static void main(String[] args) {
               /* MyArrayList<String> list = new MyArrayList<>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");


        System.out.println(list);*/



        myarraylist<Integer> list2 = new myarraylist<>();
        list2.add(123);
        list2.add(456);
        list2.add(789);


        int i = list2.get(0);
        System.out.println(i);


        System.out.println(list2);
    }
}

2、泛型方法

练习泛型方法的练习

定义一个工具类：listutil

类中定义一个静态的方法addAll，用来添加多个集合的元素。

listutil类：

package list;

import java.util.ArrayList;

public class listutil {
    private listutil(){}

    public static<E> void addAll(ArrayList<E> list, E e1, E e2, E e3, E e4){
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
    }
    public void show(){
        System.out.println("hello world!!!");
    }

}

GenericsDemo3类：

package list;

import java.util.ArrayList;

//定义一个工具类：listutil
//类中定义一个静态方法addall，用来添加多个集合的元素
public class GenericsDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        listutil.addAll(list,"aaa","bbb","ccc","ddd");
        System.out.println(list);

        
    }
}

3、泛型接口

定义一个myarraylist2类

package list;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class myarraylist2 implements List<String> {

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<String> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(String s) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public String get(int index) {
        return null;
    }

    @Override
    public String set(int index, String element) {
        return null;
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<String> listIterator() {
        return null;
    }

    @Override
    public ListIterator<String> listIterator(int index) {
        return null;
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex) {
        return null;
    }
}

GenericsDemo4类：

package list;

public class GenericsDemo4 {
    public static void main(String[] args) {
        /*
            泛型接口的两种使用方式：
                1.实现类给出具体的类型
                2.实现类延续泛型，创建实现类对象时再确定类型
        */
        //1、实现类给出具体的类型
//        myarraylist2<String> list = new myarraylist2<>();

        //2、实现类延续泛型，创建实现类对象时再确定类型
        myarraylist2 list = new myarraylist2();
        list.add("123");
        System.out.println(list);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/524955.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！