java list介绍

zhangx1234_

674人浏览 · 2026-03-15 17:34:21

zhangx1234_ · 2026-03-15 17:34:21 发布

本文介绍了Java中List接口及其实现类的使用。List作为Collection的子接口，提供了线性表数据结构的基本操作，包括增删改查等方法。重点讲解了ArrayList的实现原理，包括动态扩容机制和使用方式。通过模拟实现List接口展示了顺序表的基本操作，如add、remove、contains等。文章还演示了ArrayList的实际应用场景，包括洗牌游戏和杨辉三角的实现，展示了List在集合框架中的灵活运用。最后比较了ArrayList与Vector的线程安全性差异，指出ArrayList适用于单线程环境。

什么是List 继承自Collection

Collection也是一个接口,容器里有常用的一些方法具体有

List使用

List是一个接口并不能直接用来实例化

如果要使用，必须去实例化List的实现类。在集合框架中，ArrayList和LinkedList都实现了List接口

线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结

构，常见的线性表：顺序表、链表、栈、队列...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物

理上存储时，通常以数组和链式结构的形式存储。

顺序表

用一段物理地址连续的存储单元依次存储数据的线性一般用数组存储

模拟实现List接口内的方法

import java.awt.*;
import java.awt.List;
import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 28931
 * Date: 2026-03-14
 * Time: 20:22
 */
public class fanxing extends List {
    public int[] array=new int[10];
    public int contt;
    private int pos;

    //在末尾新增元素
   public void add(int data){
       man();

        this.array[this.contt]=data;
        contt++;

    }
    //判断是否越界如果越界 数组扩容
    private void k(){
       array=Arrays.copyOf(array,2*array.length);
    }

    private void man(){
       if(contt==10){
           System.out.println("数组已满,扩容中");
           k();
       }
    }
    // 在 pos 位置新增元素
   public void add(int pos, int data){

       if(pos<0|pos>this.contt){
           throw new Zuobaio("数组越界");
       }
       man();
       for (int i = contt;i>=pos; i--) {
           array[i+1]=array[i];
       }
       array[pos]=data;
       contt++;
   }

//    // 判定是否包含某个元素; {  };
    public boolean contains(int toFind){
        for (int i = 0; i < this.contt; i++) {
            if(array[i]==toFind){
                return true;
            }
        }
        return false;
    }
//    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.contt; i++) {
            if(array[i]==toFind){
                return i;
            }
        }
        return -1;
    }
    // 获取 pos 位置的元素
    public int get(int pos) throws Zuobaio {

        for (int i = 0; i < contt; i++) {
            if(i==pos){
                return array[i];
            }

        }
        return -1;
    }

//    // 给 pos 位置的元素设为 value
    public  void set(int pos, int value) {
       if(pos<0|pos>this.contt){
           throw new Zuobaio("坐标buhefa");
       }
       array[pos]=value;
    }
//    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        for (int i = 0; i < this.contt; i++) {
            if(array[i]==toRemove){
                array[i]=0;
                return;
            }
        }
    }
    // 获取顺序表长度
   public int sizef(){
     return this.contt;
   }
//    // 清空顺序表
    public void clear(){
       this.contt=0;
    }
//    //打印
    public void dayin(){
        for (int i = 0; i < contt; i++) {
            System.out.print(array[i]+" ");
        }
    }

    public static void main(String[] args) {
        fanxing q=new fanxing();
        q.add(1);
        q.add(1);
       q.add(1,1);
        q.set(1,2);
        q.remove(2);
        q.dayin();
    }


}

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 28931
 * Date: 2026-03-15
 * Time: 10:12
 */
public  class Zuobaio extends RuntimeException{
     public  Zuobaio(){

     }
     public Zuobaio(String name){
          super(name);
     }
}

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 28931
 * Date: 2026-03-15
 * Time: 9:47
 */
public interface List {

        // 将顺序表的底层容量设置为initcapacity

        // 新增元素,默认在数组最后新增
         void add(int data);
        // 在 pos 位置新增元素
      void add(int pos, int data);
        // 判定是否包含某个元素; {  };
        public boolean contains(int toFind);
        // 查找某个元素对应的位置
      int indexOf(int toFind) ;
        // 获取 pos 位置的元素
         int get(int pos) ;
        // 给 pos 位置的元素设为 value
        void set(int pos, int value) ;
        //删除第一次出现的关键字key
       void remove(int toRemove) ;
        // 获取顺序表长度
       int sizef();
        // 清空顺序表
         void clear() ;
         //打印
    void dayin();
}

ArrayList简介

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

ArrayList是以泛型方式实现的，使用时必须要先实例化

2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问

3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的

4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的

5. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList

6. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

Arryay的使用

Arryay创建的对象可给接口List发生向上转型

List a=new Arryay();

public class Test {
    public static void main(String[] args) {
     ArrayList<Integer> a=new ArrayList(10);
     a.add(1);
      
    }
}

Aryyay的遍历

  //for循环
  for (int i = 0; i < a.size(); i++) {
      System.out.println(a.get(i));
  }
  //each
  for (Integer b:a){
      System.out.println(b);
  }

//迭代器

Iterator<Integer>it=list.listIterator();

while(it.hasNext()){

System.out.print(it.next()+"");

}

ArrayList的扩容机制

检测是否真正需要扩容，如果是调用grow准备扩容

预估需要库容的大小

初步预估按照1.5倍大小扩容

如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容

真正扩容之前检测是否能扩容成功，防止太大导致扩容失败

使用copyOf进行扩容

洗牌游戏

先创建牌这个对象

package pai;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 28931
 * Date: 2026-03-15
 * Time: 15:24
 */
public class wanpai {



    public wanpai(String yangzi,int pack) {
        this.yangzi = yangzi;
        this.pack=pack;
    }

    @Override
    public String toString(){
        return "["+yangzi+pack+"]";
    }

    public   int pack;



    public  String yangzi;
}

买牌发牌

package pai;

import org.jetbrains.annotations.NotNull;

import java.util.*;



/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 28931
 * Date: 2026-03-15
 * Time: 15:25
 */
public class guize {
    //买牌
    private static final String[] e={"♥","♠","♣","♦"};

//买牌
    public List<wanpai> mai(){
        List<wanpai> f=new ArrayList<>();
        for (int i = 0; i < 13; i++) {
            for (int j = 0; j< 4; j++) {
               String yangzi=e[j];
               int  pack=i+1;
                wanpai r=new wanpai(yangzi,pack);
                f.add(r);

            }

        }
       return f;
    }
    //洗牌
    public void xi(List<wanpai> f){
        Random a=new Random();

        for (int i =f.size()-1;i>0;i--){
            int j=a.nextInt(i);
            swp(f,i,j);
        }

    }
    public void swp(List<wanpai> a,int i,int j){
        wanpai tmp=a.get(i);
        a.set(i,a.get(j));
        a.set(j,tmp);
    }



}

主方法

package pai;

import org.jetbrains.annotations.NotNull;

import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 28931
 * Date: 2026-03-15
 * Time: 15:25
 */
public class main {
    public static void main(String[] args) {
        guize a = new guize();
        List<wanpai> f = a.mai();
        //买牌
        System.out.println(f);
        //洗牌
        a.xi(f);
        System.out.println(f);
        //发牌
        List<List<wanpai>> r = new ArrayList<>();
        r.add(new ArrayList<>());
        r.add(new ArrayList<>());
        r.add(new ArrayList<>());
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                r.get(j).add(f.remove(0));
            }

        }
        //剩下的牌
        System.out.println(f);
        //第一个人的牌
        System.out.println(r.get(0));
        //第二个人的牌
        System.out.println(r.get(1));
        //第三个人的牌
        System.out.println(r.get(2));
    }
}