脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → java泛型包装类ArrayList

Java中关于泛型、包装类及ArrayList的详细教程

 更新时间：2021年12月06日 09:32:26   作者：来学习的小张  
泛型可以在类或方法中预支地使用未知的类型。这篇文章主要介绍了Java中关于泛型、包装类及ArrayList的详细教程,需要的朋友可以参考下

一、泛型

1.1 泛型类的定义

// 1. 尖括号 <> 是泛型的标志
// 2. E 是类型变量(Type Variable)，变量名一般要大写
// 3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道
	public class MyArrayList<E> {
	private E[] array;
	private int size;
}

泛型类可以一次有多个类型变量，用逗号分割。

  1. 泛型是作用在编译期间的一种机制，即运行期间没有泛型的概念。
  2. 泛型代码在运行期间，利用 Object 达到的效果（这里不是很准确）。
  3. 泛型的意义：自动对类型进行检查

1.2 泛型类的使用

示例：

class MyArrayList<E>{//  <E>代表当前类是一个泛型类，此时的E就是一个占位符而已
    private E[] elem;
    private int usedSize;

    public MyArrayList() {
//        this.elem = elem;
        this.elem = (E[])new Object[10];//这样的写法不是十分正确
    }
    public void add(E val){
        this.elem[usedSize] = val;
        usedSize++;
    }
    public E get(int pos){
        return this.elem[pos];
    }
}
public class test02 {
    public static void main(String[] args) {
        //泛型中尖括号里面的内容不参与类型的组成
        MyArrayList<String>  myArrayList = new MyArrayList<>();
        System.out.println(myArrayList);
        MyArrayList<Integer>  myArrayList1 = new MyArrayList<>();
        System.out.println(myArrayList1);
        MyArrayList<Boolean>  myArrayList2 = new MyArrayList<>();
        System.out.println(myArrayList2);
    }
    public static void main2(String[] args) {
        MyArrayList<String>  myArrayList = new MyArrayList<>();
        myArrayList.add("ni");//自动对类型进行检查，不是字符串类型就会报错
        myArrayList.add("n");
        String ret = myArrayList.get(1);//自动对类型进行强制类型转换
        System.out.println(ret);
   }
}

1.3 泛型总结

  1. 泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间做类型检查。
  2. 泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。
  3. 泛型是一种编译期间的机制，即 MyArrayList<Integer> 和 MyArrayList<String> 在运行期间是一个类型。即泛型中尖括号里面的内容不参与类型的组成。
  4. 泛型是 java 中的一种合法语法，标志就是尖括号 <>。

二、包装类

2.1基本数据类型和包装类直接的对应关系

基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

基本就是类型的首字母大写，除了 Integer 和 Character。

2.2 包装类的使用，装箱(boxing)和拆箱(unboxing)

装箱(装包)：把简单类型变成包装类型。 拆箱(拆包)：把包装类型变成简单类型。

public static void main(String[] args) {
        Integer a = 123;//装箱 装包（隐式的）
        //Integer 的范围[-128,127];
        int b= a;//拆箱 拆包（隐式的）
        System.out.println("a="+a+" "+ "b="+ b);
        System.out.println("===============");
        Integer a2 = Integer.valueOf(123);//显式的装包
        Integer a3 = new Integer(123);//显式的装包

        int b2 = a2.intValue();//显式的拆包
        double d = a2.doubleValue();//显式的拆包
        int i = 10;//显式的初始化
    }

2.3 自动装箱(autoboxing)和自动拆箱(autounboxing)

在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。 自动装箱和自动拆箱是工作在编译期间的一种机制。

int b2 = a2.intValue();//显式的拆包
double d = a2.doubleValue();//显式的拆包

三、List 的使用

3.1 ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：

在这里插入图片描述

  • ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问。
  • ArrayList实现了Cloneable接口，表明ArrayList是可以clone的。
  • ArrayList实现了Serializable接口，表明ArrayList是支持序列化的。
  • 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList。
  • ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表。 3.2 ArrayList的构造
public static void main(String[] args) {
	// ArrayList创建，推荐写法
	// 构造一个空的列表
	List<Integer> list1 = new ArrayList<>();
	// 构造一个具有10个容量的列表
	List<Integer> list2 = new ArrayList<>(10);
	list2.add(1);
	list2.add(2);
	list2.add(3);
	// list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
	// list3构造好之后，与list2中的元素一致
	//使用另外一个ArrayList对list3进行初始化
    ArrayList<String> list3 = new ArrayList<>(list2);
	// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
	List list4 = new ArrayList();
	list4.add("111");
	list4.add(100);
}

3.3 ArrayList的遍历

ArrayList 可以使用三种方式遍历：for循环+下标、foreach、使用迭代器。

 public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("hello");
        list2.add("world");
        System.out.println(list2);//打印方式一
        System.out.println("============");
        for (int i = 0; i < list2.size(); i++) {//打印方式二
            System.out.print(list2.get(i)+" ");
        }
        System.out.println();
        System.out.println("==========");
        for (String s:list2) {//打印方式三
            System.out.print(s+" ");
        }
        System.out.println();
        System.out.println("====迭代器打印方式1======");
       Iterator<String> it = list2.iterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        System.out.println("=====迭代器打印方式2=====");
        ListIterator<String> it2 = list2.listIterator();//打印方式四，使用迭代器进行打印
        while (it2.hasNext()){
            System.out.print(it2.next()+" ");
        }
    }

输出结果：

在这里插入图片描述

3.4 ArrayList的常见操作

3.4.1 删除 index 位置元素(remove)

E remove(int index) //删除 index 位置元素

示例：

 public static void main(String[] args) {
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("hello");
        list2.add("bit");
        list2.add("haha");
        Iterator<String> it = list2.iterator();
        while (it.hasNext()) {
            String ret = it.next();
            if(ret.equals("hello")) {
                it.remove();//首先需要使用next方法迭代出集合中的元素 ，然后才能调用remove方法
            }else {
                System.out.print(ret + " ");
            }
        }

        System.out.println();
        System.out.println("========迭代器List相关打印==========");
        ListIterator<String> it2 = list2.listIterator();
        while (it2.hasNext()) {
            String ret = it2.next();
            if(ret.equals("hello")) {
                it2.remove();//首先需要使用next方法迭代出集合中的元素 ，然后才能调用remove方法
            }else {
                System.out.print(ret + " ");
            }
        }
    }

输出结果：

在这里插入图片描述

3.4.1尾插(add)

boolean add(E e) //尾插 e

示例：

 public static void main(String[] args) {
        ArrayList<String> list2 = new ArrayList<>();
        //CopyOnWriteArrayList<String> list2 = new CopyOnWriteArrayList<>();
        list2.add("hello");
        list2.add("bit");
        list2.add("haha");

       //Iterator迭代器没有add方法
       /* Iterator<String> it = list2.iterator();
        while (it.hasNext()) {
            String ret = it.next();
            if(ret.equals("hello")) {
                it.add();//没有add方法
            }else {
                System.out.print(ret + " ");
            }
        }*/
        
        //使用ListIterator迭代器的方法添加元素，会将元素添加到其紧跟着的后面
        ListIterator<String> it2 = list2.listIterator();
        while (it2.hasNext()) {
            String ret = it2.next();
            if(ret.equals("bit")) {
                it2.add("world");
           //若使用list2.add()就会抛出异常，
           //但是将上面的list2变成CopyOnWriteArrayList<String>类型就不会报错。
            //就可以使用list2.add()的方法就可以
           // list2.add("world");
            }else {
                System.out.print(ret + " ");
            }
        }
        System.out.println("=================");
        System.out.println(list2);
    }

运行结果：

在这里插入图片描述

  ArrayList<String> list2 = new ArrayList<>();//不是线程安全的
  迭代时使用的是it2.add("world");
 CopyOnWriteArrayList<String> list2 = new CopyOnWriteArrayList<>();//是线程安全的
  迭代时使用的是list2.add("world");

3.4.2将元素插入到list中的指定位置add

3.4.3 尾插一个ArrayList中的所有元素到另一个ArrayList当中(addAll)

方法：

void add(int index, E element) //将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c) //尾插 c 中的元素

示例：

public static void main(String[] args) {
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");
        list2.add("c");
        list2.add("d");
        list2.add("d");
        System.out.println(list2);//add方法默认将字符串放到数组的最后一个位置
        list2.add(0,"hello");//在list2的零下标位置加入字符串"hello"
        System.out.println(list2);
        ArrayList<String> list3 = new ArrayList<>();
        list3.add("加入");
        list2.addAll(list3);//将list3中的所有元素放到list2中
        System.out.println(list2);
    }

输出结果：

在这里插入图片描述

3.4.4 删除指定下标位置的元素remove(int index)

3.4.5删除list中第一次出现的某元素remove(Object o)

3.4.6 获取某下标位置的元素get()

3.4.7 将指定下标位置的元素设置为指定值set()

方法：

E remove(int index) //删除 index 位置元素
boolean remove(Object o) //删除遇到的第一个 o
E get(int index) //获取下标 index 位置元素
E set(int index, E element) //将下标 index 位置元素设置为 element

示例：

 public static void main(String[] args) {
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");
        list2.add("c");
        list2.add("d");
        list2.add("d");
        System.out.println(list2);//add方法默认放到数组的最后一个位置
         String ret = list2.remove(0);//删除0下标位置元素
        System.out.println(list2);

        boolean ret1 = list2.remove("d"); //删除遇到的第一个"d"
        //如果要删除的数list2中没有则返回false
        System.out.println(ret1); //true
        String ret2 = list2.get(2);//获取下标为2位置的元素
        System.out.println(ret2);//d
        String ret3 = list2.set(2,"hello");//将下标为2位置的元素改为"hello"
        System.out.println(ret3);//d
        System.out.println(list2);//[b, c, hello]

输出结果：

在这里插入图片描述

3.4.8 清空线性表中的元素clear()

3.4.9 判断线性表中是否包含某元素 contains()

3.4.10 返回第一个 o 所在下标位置 indexOf()

3.4.11 返回最后一个o出现的下标位置 lastIndexOf()

3.4.12 截取部分 list 中的部分元素 subList()

方法：

void clear() //清空
boolean contains(Object o) //判断 o是否在线性表中
int indexOf(Object o) //返回第一个 o 所在下标
int lastIndexOf(Object o) //返回最后一个 o 的下标
List<E> subList(int fromIndex, int toIndex) //截取部分 list

示例：

 public static void main(String[] args) {
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");
        list2.add("c");
        list2.add("d");
        list2.add("d");
        System.out.println(list2);//add方法默认放到数组的最后一个位置
        System.out.println(list2.indexOf("a"));//0 判断a的下标位置
        System.out.println(list2.lastIndexOf("d"));//4 判断最后一个d出现的下标位置
        List<String> sub = list2.subList(1,3);//[b, c] 截取下标为[1,3）位置的元素，截取的区间范围为左闭右开的
        System.out.println(sub);//[b, c]
        System.out.println(list2);//[a, b, c, d, d]
        System.out.println("===================");
        sub.set(0,"p");
        System.out.println(sub);//[p, c]
        System.out.println(list2);//[a, p, c, d, d]
       System.out.println(list2.contains("c"));//true //判断list2当中是否包含字符"c"
        list2.clear();//将list2中的元素清空
        System.out.println(list2);

输出结果：

在这里插入图片描述

四、ArrayList的扩容机制

如果ArrayList调用不带参数的构造方法，那么顺序表的大小为0，当第一次add的时候，整个顺序表才变为了10；当这个10放满了，开始扩容，以1.5倍的方式进行扩容。 如果调用的是给定容量的构造方法，那么顺序表的大小就是给定的容量，放满了还是以1.5倍进行扩容。

到此这篇关于Java中关于泛型、包装类及ArrayList的详细教程的文章就介绍到这了,更多相关java泛型包装类ArrayList内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 你真的了解Java的多线程方法吗

    你真的了解Java的多线程方法吗

    这篇文章主要为大家详细介绍了Java的多线程方法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助
    2022-03-03
  • Java泛型与数据库应用实例详解

    Java泛型与数据库应用实例详解

    这篇文章主要介绍了Java泛型与数据库应用,结合实例形式详细分析了java继承泛型类实现增删改查操作相关实现技巧,需要的朋友可以参考下
    2019-08-08
  • LinkedHashMap如何保证有序问题

    LinkedHashMap如何保证有序问题

    这篇文章主要介绍了LinkedHashMap如何保证有序问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-11-11
  • 实例讲解Java的Spring框架中的控制反转和依赖注入

    实例讲解Java的Spring框架中的控制反转和依赖注入

    这篇文章主要介绍了Java的Spring框架中的控制反转和依赖注入,Spring是Java的SSH三大web开发框架之一,需要的朋友可以参考下
    2016-02-02
  • SpringBoot中mapper.xml文件存放的两种实现位置

    SpringBoot中mapper.xml文件存放的两种实现位置

    这篇文章主要介绍了SpringBoot中mapper.xml文件存放的两种实现位置,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-01-01
  • 详解SpringBoot如何统一后端返回格式

    详解SpringBoot如何统一后端返回格式

    今天我们来聊一聊在基于SpringBoot前后端分离开发模式下，如何友好的返回统一的标准格式以及如何优雅的处理全局异常，感兴趣的可以了解一下
    2021-07-07
  • 详解Java中运算符及用法

    详解Java中运算符及用法

    这篇文章主要介绍了详解Java中运算符以及相关的用法讲解，一起跟着小编学习下吧。
    2017-12-12
  • Jenkins插件pipeline原理及使用方法解析

    Jenkins插件pipeline原理及使用方法解析

    这篇文章主要介绍了Jenkins插件pipeline原理及使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-11-11
  • Java8 Stream对两个 List 遍历匹配数据的优化处理操作

    Java8 Stream对两个 List 遍历匹配数据的优化处理操作

    这篇文章主要介绍了Java8 Stream对两个 List 遍历匹配数据的优化处理操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-08-08
  • Java中的FutureTask实现代码实例

    Java中的FutureTask实现代码实例

    这篇文章主要介绍了Java中的FutureTask手写代码实例,FutureTask是Future的实现,用来异步任务的获取结果,可以启动和取消异步任务,查询异步任务是否计算结束以及获取最终的异步任务的结果,需要的朋友可以参考下
    2023-12-12

最新评论