Java--ArrayList(数据结构顺序表)

🕗 发布于 2024-09-27 18:15 java 数据结构 开发语言 前端笔记

前言：

Java中有线性表存储上数据，线性表分为：顺序表和链表(ArrayList、LinkedList)。

当然Java中也会模拟实现一遍顺序表(ArrayList)，包括里面的所有的方法

但是我的重心会放在对Java中自带的ArrayList中方法的使用，以及如何测试一些题目是否正确！

ArrayList的模拟实现：

创建自己的接口：

我们知道不论是顺序表还是链表都扩展了List接口，之后再顺序表或者链表中重写接口中的方法！

首先我们可以先看看Java中ArrayList的源代码：

1、Java中的ArrayList用的是泛型类(因为我们不知道该顺序表不知道要存放什么类型的数据！)

2、接口和父类的继承Java中做的比较全面，我们只需要模仿List接口即可。

我们做到以上两点即可。

MyList接口如下：

public interface MyList<T> {
    public void display();
    // 新增元素,默认在数组最后新增
    public void add(T data);
    /**
     * 判断当前的顺序表是不是满的！
     * @return true:满   false代表空
     */
    public boolean isFull();
    public boolean checkPosInAdd(int pos);
    // 判定是否包含某个元素
    public boolean contains(T toFind);
    // 查找某个元素对应的位置
    public int indexOf(T toFind);
    // 获取 pos 位置的元素
    public int get(int pos);
    public boolean isEmpty();
    // 给 pos 位置的元素设为【更新为】 value
    public void set(int pos, T val);
    /**
     * 删除第一次出现的关键字key
     * @param key
     */
    public void remove(T key) ;
    // 获取顺序表长度
    public int size() ;
    // 清空顺序表
    public void clear() ;
}

创建自己的MyArrayList：

public class MyArrayList<T> implements MyList<T>{
    private Object[] arrays;
    int size;
    private static final int DEFAULT_CAPACITY = 10;
    public MyArrayList() {
        super();
        arrays = new Object[DEFAULT_CAPACITY];
        size = 0;
    }
    @Override
    public void display() {
    for(int i = 0;i<size;i++) {
        System.out.print(arrays[i]+" ");
    }
        System.out.println();
    }

    @Override
    public void add(T data) {
    //第一步检查是否需要扩容
        if(isFull()) {
            Object[] newArrays = new Object[size+size>>1];//1.5倍扩容
            newArrays = Arrays.copyOf(arrays,size);
            arrays = newArrays;
        }
        arrays[size++] = data;
    }

    @Override
    public boolean isFull() {
        if(size == arrays.length) {
            return true;
        }
        return false;
    }

    @Override
    public boolean checkPosInAdd(int pos) {
        if(pos >= 0 && pos < arrays.length) {
            return true;
        }else {
            return false;
        }
    }

    @Override
    public boolean contains(T toFind) {
        for(int i = 0;i<size;i++) {
          if(arrays[i].equals(toFind)) {
          return true;
          }
        }
        return false;
    }
    @Override
    public int indexOf(T toFind) {
        for(int i = 0;i<size;i++) {
            if(arrays[i].equals(toFind)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public T get(int pos) {
        if(pos<0 || pos>=size) {
            return null;
        }
        return (T)arrays[pos];
    }

    @Override
    public boolean isEmpty() {
        if(size >0) return false;
        else return true;
    }

    @Override
    public void set(int pos, T data) {
        if(isFull()) {
            Object[] newArrays = new Object[size+size>>1];//1.5倍扩容
            newArrays = Arrays.copyOf(arrays,size);
            arrays = newArrays;
        }
        arrays[pos] = data;
    }

    @Override
    public void remove(T key) {
    int pos = indexOf(key);
    if(pos == -1) {
        return ;
    } else{
        for(int i = pos;i<size-1;i++) {
            arrays[i] = arrays[i-1];
        }
    }
    }

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

    @Override
    public void clear() {
    arrays = null;
    }
}

main方法中使用：

可以传不同的包装类：

Integer类：

public class Main {
    public static void main(String[] args) {
        MyArrayList<Integer> list = new MyArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(7);
        list.set(2,9);
        System.out.println(list.contains(7));
        list.display();
    }
}

Character类：

    public static void main(String[] args) {
        MyArrayList<Character> list = new MyArrayList<>();
        list.add('a');
        list.add('b');
        list.add('c');
        list.add('d');
        list.add('e');
        list.display();
    }

大家写好可以自己去测！！

洗牌算法：

规则：

不算大小王，一共有52张牌，每种花色有12张，有三个人，需要摸牌。一共摸5轮，每轮每人摸一张。(注意52张牌需要打乱顺序)。

创建Card类：

我们应该先描述一张牌的特性：

public class Card {
    private int val;
    private String ch;

    public Card(int val, String ch) {
        this.val = val;
        this.ch = ch;
    }

    @Override
    public String toString() {
      return ch+""+val;
    }
}

注意：

我在这里重写了toString方法，方便等会打印的时候打印对应的内容。

创建CardDemo类：

里面包含了初始化52张牌，洗牌等操作：

public class CardDemo {
    public static final String[] SUITS = {"♠", "♥", "♣", "♦"};
    private static final int DEFAULT = 52;
    public static List<Card> buyCards() {
        List<Card> deck = new ArrayList<>(DEFAULT);
        for(int i = 0;i< 4;i++) {
            for (int j = 1; j <= 13; j++) {
                String tmp = SUITS[i];
                Card card = new Card(j,tmp);
                deck.add(card);
            }
        }
        return deck;
    }
    public static void swap(List<Card> deck,int cur,int tmp){
        Card card = deck.get(cur);
        deck.set(cur,deck.get(tmp));
        deck.set(tmp,card);
    }
    public static void randCards(List<Card> deck){
        Random r = new Random(100);
        for(int i = deck.size()-1;i>0;i--) {
            int tmp = r.nextInt(i);
            swap(deck,i,tmp);
        }
    }
}

测试类Main：

包括初始化牌，三个人轮流摸牌等操作：

public class Main {
    public static void main(String[] args) {
        List<Card> deck = CardDemo.buyCards();
        System.out.println("买回来牌");
        System.out.println(deck);
        System.out.println();
        CardDemo.randCards(deck);
        System.out.println("洗过的牌");
        System.out.println(deck);
        List<List<Card>> hands = new ArrayList<>();
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());
        for(int i = 0;i<5;i++) {
            for (int j = 0; j <3 ; j++) {
                hands.get(j).add(deck.remove(0));
            }
        }
        System.out.println("剩余的牌:");
        System.out.println(deck);
        System.out.println("A 手中的牌:");
        System.out.println(hands.get(0));
        System.out.println("B 手中的牌:");
        System.out.println(hands.get(1));
        System.out.println("C 手中的牌:");
        System.out.println(hands.get(2));
    }
}

原文地址：https://blog.csdn.net/m0_75235246/article/details/142555714

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：THREE.JS法线Shader
下一篇：WebSocket消息防丢ACK和心跳机制对信息安全性的作用及实现方法

vue3 + element-plus 的 upload + axios + django 文件上传并保存
之前在网上搜了好多教程，一直没有找到合适自己的，要么只有前端部分没有后端，要么就是写的不是很明白。所以还得靠自己摸索出来后，来此记录一下整个过程。环境安装什么的就不讲了，直接上代码好吧，这个是样式图。
阅读更多2024-11-06
Cuebric：用AI重新定义3D创作的未来
Cuebric 是一家成立于2022年夏天的好莱坞创新公司，致力于为电影、电视、游戏和时尚等行业提供先进的AI多模态SaaS平台。自2024年1月正式推出以来，Cuebric 已经在市场上获得了广泛的
阅读更多2024-11-06
easyui+vue 数据表更新问题的解决
数据的增删改查可以实时刷新出来,不建议在封装组件。nextTick 保证DOM 渲染完成。
阅读更多2024-11-06
软件测试基础：单元测试与集成测试
单元测试和集成测试是软件测试的基础，它们的重要性不言而喻。通过对软件的不同部分进行有序的测试，可以提高软件质量、减少后期维护成本，保证软件的可靠性和稳定性。软件开发者和测试人员应当重视并深入理解单元测
阅读更多2024-11-06
RxJS基本介绍以及与Promise的区别
Promise 适合处理单一的异步操作，具有更简单的 API，但缺乏灵活性和对多值的支持。RxJS (Observable) 适合处理复杂的异步流和多事件流，具有更多的操作符、错误处理机制和强大的组合
阅读更多2024-11-06
第三节 Vim编辑器与Shell命令脚本
这里的脚本主要使用 ping 命令来测试与对方主机的网络连通性，而 Linux 系统中的 ping 命令不像 Windows 一样尝试 4 次就结束，因此为了避免用户等待时间过长，需要通过-c 参数来
阅读更多2024-11-06
【JavaEE初阶 — 多线程】线程安全问题＆ synchronized
【JavaEE初阶 — 多线程】线程安全问题＆ Synchronized观察线程安全问题，分析了造成线程安全问题造成的三个原因：线程的随机调度，多个线程修改共享数据（修改同一个变量），以及原子性问题
阅读更多2024-11-06
十月末补充（？
【代码】十月末补充（？
阅读更多2024-11-06
13-鸿蒙开发中的综合实战：华为登录界面
通过本文，你已经学会了如何在鸿蒙开发中实现一个简单的登录界面，涵盖了输入框组件、按钮组件、文本组件和布局容器的使用。这个实战项目不仅帮助你巩固了基础知识，还提供了一个实际的应用场景。希望这篇文章对你有
阅读更多2024-11-06
python全栈开发《59.集合的增删改》
目录1.集合的add函数2.集合的update函数3.集合的remove函数4.集合的clear函数5.用del删除集合6.重要说明7.代码1.集合的add函数1.1add的功能用于集合中添加一个元素
阅读更多2024-11-06