JAVA数据结构List的基本用法

Posted 波风张三

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA数据结构List的基本用法相关的知识，希望对你有一定的参考价值。

文章目录

一、简单认识泛型

1.什么是泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

怎么理解这句话呢？我们举个例子：

创建一个通用顺序表：

class MyArrayList
    private int[]elem;
    private int usedSize;

    public MyArrayList()
        this.elem=new int[10];
    

    public void add(int val)
        this.elem[usedSize]=val;
        usedSize++;
    
    public int get(int pos)
        return this.elem[pos];

上面的顺序表看起来好像没什么问题，但细究，我们会发现这个顺序表存在以下问题

  1. 不通用，它只能存放int类型的数据。
  2. 我们想的是所有类型的数据都能存放

有同学说，我们可以添加一个Object，Object不是所有类 的父类吗？

class MyArrayList
    private Object[]elem;
    private int usedSize;

    public MyArrayList()
        this.elem=new Object[10];
    

    public void add(Object val)
        this.elem[usedSize]=val;
        usedSize++;
    
    public Object get(int pos)
        return this.elem[pos];

这个顺序表貌似各种元素都能存放，但是也存在以下问题：

  1. 存放元素，不能指定存放什么元素，也就是说什么都可以放
  2. 每次取出数据，都需要强制类型转换。

但是我们想要的效果是这样的：

  1. 我们可以指定顺序表的类型
  2. 指定类型后，只能存放相应的数据类型
  3. 取数据的时候，不进行类型转换

很简单，使用泛型。

class MyArrayList<E>
		在顺序表上添加<E>，这代表当前类是一个泛型类，而这个E本质上仅仅是一个占位符

那么当我引用的时候，就变成了这样，可以把类型作为参数传递：

public static void main(String[] args) 
        MyArrayList<String> myArrayList1=new MyArrayList<>();
        MyArrayList<Integer> myArrayList2=new MyArrayList<>();

这就是一开始所说的，泛型把类型参数化了。

那么我们使用泛型之后，一开始的代码就需要更改了：

class MyArrayList<E>
    private E[]elem;
    private int usedSize;

    public MyArrayList()
        //this.elem=new E[10];//泛型不能实例化对象
    

    public void add(E val)
        this.elem[usedSize]=val;
        usedSize++;
    
    public E get(int pos)
        return this.elem[pos];

【注意】上面注释，泛型不能实例化

2.泛型的意义

  1. 增加编译期间的类型检查
  2. 取消类型转换的使用

3.泛型是如何编译的

  1. 泛型是一种编译时期的机制——擦除机制

Java 语言中的泛型，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（RawType，也称为裸类 型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的 Java 语言来说，ArrayList＜int＞与 ArrayList＜String＞就是同一 个类

将一段 Java 代码编译成 Class 文件，然后再用字节码反编译工具进行反编译后，将会发现泛型都不见了，程序又变回了 Java 泛型 出现之前的写法，因为泛型类型都变回了原生类型

—————————————————————————————

4.泛型总结

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

二、包装类

1.什么是包装类

我们知道，Object 引用可以指向任意类型的对象，但有例外出现了，8 种基本数据类型不是对象，那岂不是刚才的泛型机制要失效了？

实际上也确实如此，为了解决这个问题，java 引入了一类特殊的类，即这 8 种基本数据类型的包装类，在使用过程中，会将类似 int 这样的值包装到一个对象中去。

2.基本数据类型与对应的包装类型

基本数据类型包装类型
byteByte
booleanBoolean
shortShort
charCharacter
intInteger
longLong
floatFloat
doubleDouble

常用的包装类可以分为三类：Character、Number、Boolean，继承结构图如下：

3.装箱和拆箱

装箱：

基本类型向对应的包装类转换称为装箱，例如把 char包装成 Character类的对象。

Character i = Character.valueOf(1); //手动装箱
Character j = 1; //自动装箱

拆箱：
包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。

Integer a= new Integer(1);
int a1= a; //自动拆箱
int a2= a.intValue(); //手动拆箱

4.关于拆箱和装箱常见面试题

equals方法比较的是真正的值，基本数据类型和包装类比较时，会先把基本数据类型包装成对应的包装类型，再进行比较。

double a= 0.1;
Double b= new Double(0.1);
Double c= new Double(0.1);
System.out.println(a.equals(b)); //true 2个包装类比较，比较的是包装的基本数据类型的值
System.out.println(b.equals(a)); //true 基本数据类型和包装类型比较时，会先把基本数据类型包装后再比较

==（双等号）

对于基本数据类型，（双等号）比较的是值，而对于包装类型，（双等号）比较的则是2个对象的内存地址。

double a= 0.1;
Double b= new Double(0.1);
Double c= new Double(0.1);
System.out.println(b== c);    //false ,new出来的都是新的对象
System.out.println(b== a);    //true ,基本数据类型和包装类比较，会先把包装类拆箱

new出来的都是新的对象。2个新的对象内存地址不同，那么==号比较的结果肯定是false。

基本数据类型和包装类型比较时，会先把包装类拆箱再进行值比较（和equals是反的）

3:

Double a= Double.valueOf(0.1);
Double b= Double.valueOf(0.1);
System.out.println(a== b); //false valueOf方法内部实际上也是new

valueOf内部也是用的new方法来构造对象的。2个new出来的对象，内存地址肯定是不一样的。

接着来看下一个陷阱：

public static void main(String[] args) 
        System.out.println(Integer.valueOf(1) ==Integer.valueOf(1)); //true
        System.out.println(Integer.valueOf(999) ==Integer.valueOf(999)); //false

看到结果，你可能很疑惑，我们看看源码：
1.查看Integer.valueOf方法的源码
可以看到，当i的值在low和high范围内是，返回的是一个cache里的Integer对象。

2.追踪IntegerCache.cache的源码：

可以看到从-128到到127之间的值都被缓存到cache里了。这个叫做包装类的缓存。

Java对部分经常使用的数据采用缓存技术，在类第一次被加载时换创建缓存和数据。当使用等值对象时直接从缓存中获取，从而提高了程序执行性能。（通常只对常用数据进行缓存）

Integer默认缓存是-128到127之间的对象，上限127可以通过修改JVM参数来更改。

回到我们的示例代码中，可以看到Integer.valueOf(1)是会直接从缓存中去取被缓存的同一个对象，所以比较的值是true。而Integer.valueOf(999)是缓存范围外的值，那么就会new一个新的对象出来，所以比较的结果是false。

实际上，包装类中整数型的类型基本上都有缓存数据。可以通过阅读源码了解。不过只有Integer类可以通过修改JVM参数来更改缓存上限。

其他类型的缓存范围为：

  1. Integer类型有缓存-128-127的对象。缓存上限可以通过配置jvm更改
  2. Byte,Short,Long类型有缓存(-128-127)
  3. Character缓存0-127
  4. Boolean缓存TRUE、FALSE

尤其需要特别注意的是，只有valueOf方法构造对象时会用到缓存，new方法等不会使用缓存！

这部分更详细的内容可以参考借鉴参考的文章：深入浅出JAVA包装类及面试题陷阱

三、List的使用

1.ArrayList简单介绍

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

  1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的 3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  3. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者
    CopyOnWriteArrayList
  4. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2.ArrayList使用

我们通过IDEA点击进去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构造好之后，与list中的元素一致
  ArrayList<Integer> list3 = new ArrayList<>(list2);
  
  // 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难 
  List list4 = new ArrayList();
  list4.add("111"); list4.add(100);

3.ArrayList的常见操作

ArrayList虽然提供的方法比较多，但是常用方法如下所示，需要用到其他方法时，同学们自行查看ArrayList的帮助文档。

方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为 element
void clear()清空
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个o的下标
List subList(int fromIndex, int toIndex)截取部分list
public static void main(String[] args) 
 List<String> list = new ArrayList<>(); 
 list.add("JavaSE"); 
 list.add("JavaWeb");
 list.add("JavaEE"); 
 list.add("JVM"); 
 list.add("测试课程"); 
 System.out.println(list); 
 // 获取list中有效元素个数
  System.out.println(list.size());

 // 获取和设置index位置上的元素，注意index必须介于[0, size)间
 System.out.println(list.get(1)); 
 list.set(1, "JavaWEB"); 
 System.out.println(list.get(1)); 
// 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置 
list.add(1, "Java数据结构"); 
System.out.println(list); 

// 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置 
list.remove("JVM"); System.out.println(list);

 // 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常 
list.remove(list.size()-1); 
System.out.println(list); 

// 检测list中是否包含指定元素，包含返回true，否则返回false
if(list.contains("测试课程"))
 list.add("测试课程"); 
 
 
// 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找 
list.add("JavaSE");
 System.out.println(list.indexOf("JavaSE")); System.out.println(list.lastIndexOf("JavaSE")); 

// 使用list中[0, 4)之间的元素构成一个新的ArrayList返回 
List<String> ret = list.subList(0, 4); 
 System.out.println(ret);
 list.clear();
 System.out.println(list.size());

4.ArrayList的遍历

public static void main(String[] args) 
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("我");
        list2.add("无敌");
        list2.add("存在");
        System.out.println(list2);
        System.out.println("================");
        // 使用下标+for遍历
        for (int i = 0; i < list2.size(); i++) 
            System.out.print(list2.get(i) + " ");
        
        System.out.println();
        System.out.println("==================");

			// 借助foreach遍历
        for (String s : list2) 
            System.out.print(s + " ");
        

			//迭代器打印
        System.out.println();
        System.out.println("========迭代器打印==========");
        Iterator<String> it = list2.iterator();
        while (it.hasNext()) 
            System.out.print(it.next() + " ");
        

		//迭代器List相关打印
        System.out.println();
        System.out.println("========迭代器List相关打印==========");
        ListIterator<String> it2 = list2.listIterator();
        while (it2.hasNext()) 
            System.out.print(it2.next() + " ");

有同学看到上面可能有疑问，Iterator与ListIterator都可以迭代输出，那么二者有什么区别呢？

Iterator和ListIterator主要区别在以下方面：

  1. ListIterator有add()方法，可以向List中添加对象，而Iterator不能

  2. ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。

  3. ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

  4. 都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

因为ListIterator的这些功能，可以实现对LinkedList等List数据结构的操作。其实，数组对象也可以用迭代器来实现。

更详细内容可以参考这篇文章：Iterator和ListIterator区别

这里还有一个点需要注意：
我们在用迭代删除(Iterator.remove())时，可能会因为没有“it.next();”这一行， 抛出java.lang.IllegalStateException异常，原因是通过Iterator来删除集合中某一个不满足条件的元素时，

首先需要使用next方法迭代出集合中的元素 ，然后才能调用remove方法，否则集合可能会因为对同一个Iterator remove了多次而抛出java .lang.IllegalStateException异常。

public static void main(String[] args) 
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("我");
        list2.add("无敌");
        list2.add("存在");
        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 + " ");

5.ArrayList的扩容机制

ArrayList是List接口的实现类，它是支持根据需要而动态增长的数组。java中标准数组是定长的，在数组被创建之后，它们不能被加长或缩短。这就意味着在创建数组时需要知道数组的所需长度，但有时我们需要动态程序中获取数组长度。ArrayList就是为此而生的。
详细内容参照：ArrayList的扩容机制

因此，了解它的扩容机制对使用它尤为

以上是关于JAVA数据结构List的基本用法的主要内容，如果未能解决你的问题，请参考以下文章

java8 .stream().sorted().filter().map().collect()用法

Java List 用法

python基本数据类型的用法和区别

Java学习笔记之ArrayList基本用法

go语言从零学起--list结构基本用法

创建片段而不从 java 代码实例化它