Java集合——List接口

什么是集合

计算机的优势在于处理大量的数据，在编程开发中，为处理大量的数据，必须具备相应的存储结构，数组可以用来存储并处理大量类型相同的数据，但是数组有长度、数据类型的限制，操作不方便。在实际开发中，为了操作方便，JDK中提供了集合数据存储结构。
集合是存储元素个数不受限制、元素类型不受限制的数据存储结构。Java中的集合使用Collection接口和Map接口表示，其中Collection接口下还有两个子接口，分别是List和Set。

1. Collection 接口存储一组不唯一，无序的对象。
2. List接口存储一组不唯一，有序的对象，有序是指有下标。
3. Set 接口存储一组唯一，无序的对象。
4. Map接口存储一组键值对象，提供key到value的映射。
   Java为以上接口提供了相应的子类，这些子类作为集合框架的实现类。集合中的接口及其相关类都位于java.util包中

List接口

List集合与数组的区别：

1. 数组长度在使用前必须确定，一旦确定不能改变。而List集合长度可变，无需定义。
2. 数组中必须存放同一类型的数据，List集合中可以存放不同类型的数据
   List集合在JDK中被封装称为接口，针对List接口，有若干种实现，常用的类有ArrayList、Vector、LinkedList、Stack。它们的功能与用法相同，但内部实现方式不同
   List集合常用方法：
   

ArrayList类

package collection.List;

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

/**
 * @author Una
 * @date 2022/9/13 20:32
 * @description:
 */


public class ArrayListTest {
    public static void main(String[] args) {
     // 定义集合对象arrayList
        //ArrayList<Object> arrayList=new ArrayList<>();
        List arrayList =new ArrayList();
        //添加元素
        arrayList.add(1);
        arrayList.add("你好！");
        arrayList.add('s');
        arrayList.add(3);
        arrayList.add(8888);
        arrayList.add("最后一个元素");
        for (Object o : arrayList) {
            System.out.print(o+",");
        }
        System.out.println();
        System.out.println("arrayList中是否为空："+arrayList.isEmpty());
        System.out.println("arrayList的大小为："+arrayList.size());
        arrayList.remove(2);
        System.out.print("删除索引为2的元素后：");
        for (Object o : arrayList) {
            System.out.print(o+",");
        }
        System.out.println();
        System.out.println("获取索引为0的元素"+arrayList.get(0));
        System.out.print("把ArrayList转换为数组："+ Arrays.toString(arrayList.toArray()));
    }
}

运行结果：

泛型集合

泛型是指类型参数化，即数据类型是可以变化的

  //使用泛型，可以是Boolean、Integer、String等
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        Iterator<Integer> integerIterator= list.iterator();
        System.out.println();
        System.out.println("使用泛型：");
        for (Integer integer:list){
            System.out.print(integer+",");
        }

运行结果：

使用数组封装动态数组

基于Java中的数组，进行二次封装，制作属于我们自己的数组（可变数组）

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

/**
 * Copyright (C)  ld All Rights Reserved.
 *
 * @description: 属于自己的动态数组
 * @author: ld
 * @create: 2022-05-28 10:15
 **/
public class MyArray {
    /**
     * 存放数据
     */
    private Object[] data;

    /**
     * 数组中元素的个数
     */
    private int size;

    /**
     * 获取数组中元素的个数
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 是否为空
     * @return
     */
    public boolean isEmpty(){
        return this.size ==0;
    }

    /**
     *往数组的头部添加元素
     * @param obj
     */
    public void addFirst(Object obj){
        add(obj,0);
    }

    /**
     * 往数组的尾部添加元素
     * @param obj
     */
    public void addLast(Object obj){
        add(obj,size);
    }

    /**
     * 往index处添加obj
     * @param obj
     * @param index
     */
    public void add(Object obj,int index){
        if(index<0||index>this.data.length){
            throw new ArrayIndexOutOfBoundsException("index 超出范围");
        }
        /*数组满了，进行扩容*/
        if(this.size == data.length){
            resize(data.length*2);
        }

        for(int i = size-1;i>=index;i--){
            this.data[i+1]=this.data[i];
        }

        this.data[index] = obj;
        this.size ++;

    }

    public void resize(int newCapacity) {
        Object[] newData = new Object[newCapacity];
        System.arraycopy(this.data,0,newData,0,this.size);
        this.data = newData;
    }

    /**
     * 获得index处的元素
     * @param index
     * @return
     */

    public Object getByIndex(int index){
        if(index<0||index>this.data.length){
            throw new ArrayIndexOutOfBoundsException("index 超出范围");
        }
        return this.data[index];
    }

    /**
     * 数组中是否包含obj
     * @param obj
     * @return
     */
    public boolean isContains(Object obj){
        if(null==obj){
            return false;
        }
        for(int i=0;i<size;i++){
            if(this.data[i].equals(obj)){
                return true;
            }
        }
        return false;
    }

    /**
     * 修改index处的内容
     * @param index
     * @param obj
     */

    public void updataByIndex(int index,Object obj){
        if(index<0||index>this.data.length){
            throw new ArrayIndexOutOfBoundsException("index 超出范围");
        }
        this.data[index] = obj;
    }

    public void removeFirst(){
        remove(0);
    }

    public void removeLast(){
        remove(size-1);
    }

    /**
     * 删除index处的元素
     * @param index
     */
    public void remove(int index){
        if(index<0||index>this.data.length){
            throw new ArrayIndexOutOfBoundsException("index 超出范围");
        }
        for(int i=index;i<size-1;i++){
            this.data[i]= this.data[i+1];
        }
        this.size--;
        this.data[size] = null;

        /*对数组进行缩容*/
        if(data.length/4 == this.size){
            resize(data.length/2);
        }
    }




    @Override
    public boolean equals(Object o) {
        if (this == o) {return true;}
        if (o == null || getClass() != o.getClass()) {return false;}
        MyArray myArray = (MyArray) o;
        return size == myArray.size && Arrays.equals(data, myArray.data);
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(size);
        result = 31 * result + Arrays.hashCode(data);
        return result;
    }

    @Override
    public String toString() {
        return "MyArray{" +
                "data=" + Arrays.toString(data) +
                ", size=" + size +
                '}';
    }

    public MyArray(int capacity) {
        this.data = new Object[capacity];
        this.size = 0;
    }

    public MyArray() {
        this(10);
    }

    public Object[] getData() {
        return data;
    }

    public void setData(Object[] data) {
        this.data = data;
    }

    public void setSize(int size) {
        this.size = size;
    }
}

LinkedList（链表）

LinkedList的使用

import java.util.LinkedList;
import java.util.List;

/**
 * @author Una
 * @date 2022/9/13 21:03
 * @description:
 */


public class LinkedListTest {
    public static void main(String[] args) {
        List linkedList=new LinkedList();
        linkedList.add(1);
        linkedList.add("第二个");
        linkedList.add(3);
        linkedList.add('4');
        linkedList.add(1234567890);
        System.out.println("LinkedList是否为空"+linkedList.isEmpty());
        System.out.println("LinkedList大小："+linkedList.size());
        for (Object o:linkedList){
            System.out.print(o+",");
        }
        System.out.println();
        System.out.println("linkedList是否存在3"+linkedList.contains(3));
        //删除索引为3的数据
        linkedList.remove(3);
        for (Object o:linkedList){
            System.out.print(o+",");
        }
    }
}

运行结果：

Vector类

import java.util.List;
import java.util.Vector;

/**
 * @author Una
 * @date 2022/9/13 21:10
 * @description:
 */


public class VectorTest {
    public static void main(String[] args) {
        List vectorList=new Vector();
        vectorList.add(1);
        vectorList.add("索引为1的元素");
        vectorList.add(2);
        vectorList.add('A');
        for (Object o:vectorList){
            System.out.print(o+",");
        }
        System.out.println();
        System.out.println("vectorList是否存在2："+vectorList.contains(2));
        //删除2
        vectorList.remove(2);
        for (Object o:vectorList){
            System.out.print(o+",");
        }
        System.out.println();
        //清除vectorList中的元素
        vectorList.clear();
        System.out.println("vectorList是否为空："+vectorList.isEmpty());

    }
}

运行结果：