ArrayList与顺序表

最新推荐文章于 2024-05-01 19:17:00 发布
最新推荐文章于 2024-05-01 19:17:00 发布
阅读量1.1k 收藏 2
点赞数 2
文章标签： java 蓝桥杯 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62953336/article/details/123445036
版权

1. ArrayList简介

2. ArrayList使用

3.ArrayList的扩容机制

4.Arraylist的遍历：

5. ArrayList的模拟实现

新增元素,默认在数组最后新增 add

打印顺序表

在 pos 位置新增元素

判定是否包含某个元素查找某个元素对应的位置contains

查找某个元素对应的位置indexOf

获取 pos 位置的元素 get

给 pos 位置的元素设为 value

删除第一次出现的关键字key——remove

获取顺序表长度

6.应用

扑克牌

杨辉三角形

1. ArrayList简介

在集合框架中， ArrayList 是一个普通的类，实现了 List 接口。

2. ArrayList使用

// 构造一个空的列表
List<Integer> list1 = new ArrayList<>();//接口引用对象

// 构造一个具有10个容量的列表
 List<Integer> list2 = new ArrayList<>(10);

3.ArrayList的扩容机制

  1. ArrayList是一个动态类型的顺序表，顺序表底层是一个数组，即：在插入元素的过程中会自动扩容：检测是否真正需要扩容，如果是调用grow准备扩容
  2.  预估需要库容的大小
  • 初步预估按照1.5倍大小扩容
  • 如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
  • 真正扩容之前检测是否能扩容成功，防止太大导致扩容失败

   3. 使用copyOf进行扩容

4.Arraylist的遍历：

  public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list);//直接打印
        for (int i = 0; i < list.size(); i++) {//for循环
            System.out.print(list.get(i));//get获取下标index元素
        }
            for (Integer x: list) {//for-each方法
                System.out.print(x);
            }
        }

5. ArrayList的模拟实现

class MyArraylist {//顺序表
    public int[] elem;//底层是一个数组
    public int usedSize;//标记数组当中有效变量有几个

    public MyArraylist() {//构造方法
        this.elem = new int[5];//分配内存
    }

  • 新增元素,默认在数组最后新增 add

  //一、新增元素,默认在数组最后新增
    public void add(int data) {
        //1.判断是不是满的
        if (isFull()) {
            //2.如果是满的就进行扩容
            this.elem = copyOf(this.elem, 2 * this.elem.length);//给这个数组扩容2倍,重新赋给elem
        }
        this.elem[this.usedSize] = data;//将data元素放到usedSize位置
        usedSize++;
    }

    public boolean isFull() {//判断你的数组是不是满的，是否可以存放数据
        if (this.usedSize == this.elem.length) {
            return true;//满的
        }
        return false;
    }

  • 打印顺序表

  //二、打印顺序表
    public void MyToString() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
    }

  •   在 pos 位置新增元素

 //三、在 pos 位置新增元素
    public void add(int pos, int data) {
        //0.对pos位置进行判断
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法");
            return;
        }
        //1.判断是不是满的
        if (isFull()) {
            //2.如果是满的就进行扩容
            this.elem = copyOf(this.elem, 2 * this.elem.length);//给这个数组扩容2倍,重新赋给elem
        }
        //2.插入
        for (int i = usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

  • 判定是否包含某个元素查找某个元素对应的位置contains


    //四、判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (toFind == this.elem[i]) {
                return true;
            }
        }
        return false;
    }

  • 查找某个元素对应的位置indexOf 

 //五、查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i]==toFind){
                return i;
            }
        }
        return -1;
    }

  • 获取 pos 位置的元素 get

   //六、获取 pos 位置的元素
    public int get(int pos) {
        if (pos<0||pos>=this.usedSize){//判断pos位置
            System.out.println("pos位置不合法");
            throw new RuntimeException("pos位置不合法");//需要抛异常，自定义异常
        }
      return this.elem[pos];
    }

  • 给 pos 位置的元素设为 value

//七、给 pos 位置的元素设为 value
    public void set(int pos, int value) {
        if (pos<0||pos>=this.usedSize){//判断pos位置
            System.out.println("pos位置不合法");
        }
        value=this.elem[pos];//覆盖原来的值
        }

  • 删除第一次出现的关键字key——remove

 //九、删除第一次出现的关键字key
    public void remove(int key) {
        if (isEmpty()){
            System.out.println("空的");
            return;
        }
        int index=indexOf(key);
        for (int i =index; i<this.usedSize-1; i++) {
                this.elem[i] =this.elem[i+1];
            }
        this.usedSize--;
//        this.elem[this.usedSize]=null;如果是引用数据类型一定要置为空
        }
        public boolean isEmpty(){
        if(this.usedSize==0){
            return true;
        }
        return false;
        }
    }

  • 获取顺序表长度 

    // 八、获取顺序表长度
    public int size() {
        return this.usedSize;
    }
  
 // 十、清空顺序表
    public void clear() {
        this.usedSize=0;
        /*for (int i = 0; i < this.usedSize; i++) {如果是引用类型，需要置为null；
            this.elem[i]=null;//一个对象要被回收，必须是没有人再引用他了，置为null
            this.usedSize=0;*/
        }
}
public class ArraylistDome {
    public static void main(String[] args) {
        MyArraylist myArraylist = new MyArraylist();
        myArraylist.add(1);
        myArraylist.add(2);
        myArraylist.add(3);
        myArraylist.add(4);
        myArraylist.add(5);
        myArraylist.add(6);
        myArraylist.MyToString();//1
        myArraylist.add(0, 70);//2
        myArraylist.MyToString();
        System.out.println(myArraylist.contains(3));//3
        System.out.println(myArraylist.indexOf(70));//4
      System.out.println(myArraylist.get(2));
    try{
        System.out.println(myArraylist.get(10));
       }catch (RuntimeException e){
           e.printStackTrace();
        }
        System.out.println("kkkkk");
        myArraylist.get(2);
        myArraylist.remove(4);
     myArraylist.MyToString();
    }
    }

6.应用

  • 扑克牌

import java.util.*;

class CardDome {//找对象 创建对象 使用对象
    private int rank;//牌面值
    private String suit;//花色

    public CardDome(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public String toString() {
        return "花色" + suit + "数字" + rank;
    }
}

public class SomeCard {
    private static final String[] SUITS = {"♥", "♠", "♦", "♣",};//花色都是不变的,定义为常量

    public static ArrayList<CardDome> buyCard() {//买牌 返回值ArrayList<CardDome>
        ArrayList<CardDome> cards = new ArrayList<>();//52张牌用Arraylist存放，

        for (int i = 0; i < 4; i++) {//4种花色
            for (int j = 1; j <= 13; j++) {//一次抽取13张牌
                String suit = SUITS[i];//实例化对象第一个有花色
                int rank = j;//牌数
                CardDome card=new CardDome(rank, suit);
                cards.add(card);//每张牌都放在cards中
                //cards.add(new Card(SUITS[i],j);
            }
        }
        return cards;
    }

    public static void shuffle( ArrayList<CardDome> cards){//洗牌,洗上面那副牌
        Random random=new Random();

        for (int i = cards.size()-1; i >0 ; i--) {
            int index=random.nextInt(i);//生成一个随机数
            CardDome tmp=cards.get(i);//get获取i下标的值
            cards.set(i,cards.get(index));//获取到Index的值；set：将获取的值放到i下标
            cards.set(index,tmp);//设置index的值等于tmp
        }
    }


    public static void main(String[] args) {
        ArrayList<CardDome> cardlist=buyCard();//接收buyCard方法
        System.out.println(cardlist);

        shuffle(cardlist);
        System.out.println("洗牌" + cardlist);


        System.out.println("揭牌 ");
        ArrayList<ArrayList<CardDome>> hands=new ArrayList();//hands是ArrayList<CardDome>,再放到ArrayList中

        ArrayList<CardDome> hand1=new ArrayList<>();
        ArrayList<CardDome> hand2=new ArrayList<>();
        ArrayList<CardDome> hand3=new ArrayList<>();

        hands.add(hand1);
        hands.add(hand2);
        hands.add(hand3);

        for (int i = 0; i < 5; i++) {//5轮揭牌

            for (int j = 0; j < 3; j++) {//3个人
                CardDome card=cardlist.remove(0);//每次都揭走0下标的牌，删除
                hands.get(j).add(card);//j为0是第一个人揭牌，add一张牌
            }
        }
        System.out.println("第1个人的牌"+hand1);
        System.out.println("第2个人的牌"+hand2);
        System.out.println("第3个人的牌"+hand3);
        System.out.println("剩下的牌"+cardlist);
    }
}

  • 杨辉三角形

import java.util.*;

 class Test {
     public static List<List<Integer>> generate(int numRows) {
         List<List<Integer>> ret = new ArrayList<>();//总的数据

         List<Integer> list = new ArrayList<>();//第一行
         list.add(1);
         ret.add(list);//拿到第一行

         for (int i = 1; i < numRows; i++) {
             List<Integer> curRow = new ArrayList<>();//当前行
             curRow.add(1);
             for (int j = 1; j < i; j++) {
                 List<Integer> perRow = ret.get(i - 1);//拿到上一行
                 int val = perRow.get(j) + perRow.get(j - 1);
                 curRow.add(val);
             }
             curRow.add(1);//最后一个数字
             ret.add(curRow);
         }
         return ret;
     }

     public static void main(String[] args) {
         List<List<Integer>> triangle = generate(5);
         System.out.println(triangle);
     }
 }



//结果：[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
i

三角形

1list
1 11curRow
2121
         j12

Decision386
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
顺序表的链式存储封装ArrayList
03-08
学习数据结构，用C++封装的顺序表，用得链式存储结构
kotlin--3.集合操作
可爱的鸡仔的博客
11-17 850
在Kotlin中，Stream流操作提供了一种功能强大的方式来处理集合数据。可以使用扩展函数和lambda表达式来对集合进行处理。Kotlin中的Set集合是一种不允许重复元素的集合。由于Set集合中的元素是无序的，因此不能通过索引获取元素。在Kotlin中，Map集合用于存储键值对，其中键和值可以是任意类型。在上述案例中，我们有一个包含Person对象的人员列表。的人员，然后使用sortedByDescending函数按年。最终，我们将过滤和格式化后的结果打印出来。，最后使用map函数将。
kotlin List删除一个元素，添加一个元素
唯美，不是唯一
12-06 1万+
kotlin List移除一个元素，添加一个元素时没有 remove和add函数只有 -= 和 += 在kotlin ArrayList中才有remove和add函数 没有 -= 和 += kotlin List删除一个元素如下图 Kotlin之数组和集合 https://www.jianshu.com/p/6d95db6e9f87 ...
Kotlin学习：集合<1>.List的增、删、改、查
u011116275的博客
01-19 7888
kotlin中的List集合分为可变和不可变，如果对集合中的数据没有增、删、改的需求，那么两种方式都可用。但是如果有增、删、改的需求，就只能声明可变List(MutableList) 我们可以用 listof() 函数创建一个不可变List，它有3个重载函数，创建的List都是不可变的 public inline fun <T> listOf(): List<T> = em...
Kotlin学习笔记：ArrayList的使用
casual_clover的博客
02-28 2566
Kotlin中ArrayList的使用
Kotlin 1. Kotlin ArrayListOf 的使用案例
破浪会有时的博客
10-02 1845
介绍 Kotlin ArrayListOf 的使用。`arrayList()` 是 `Kotlin` `ArrayList` 类的函数，用于创建一个新的 `ArrayList`。 `ArrayList` 是可变的（mutable），这意味着我们可以修改 `ArrayList` 的内容。
Kotllin实现ArrayList的基本功能
qq_51626275的博客
08-20 357
上次面试时，手写ArrayList竟然翻车，忘了里面的扩容与缩容的条件，再次实现一次，加深印象。
Kotlin 集合
qq_34285557的博客
06-15 465
Kotlin 集合 增加了 "不可变" 集合框架的接口 没有另起炉灶, 复用Java API 的所有实现类型 提供了丰富的方法，例如 forEach/map/flatMap 等高阶函数 运算符级别的支持，简化集合框架的访问 1. Kotlin VS Java 集合 类型 Kotlin Java 不可变List List List 可变List MutableList List 不可变Map Map<K,V> Map<K,V> 可变M
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
剑指Offer #03 从尾到头打印链表（递归）
01-20
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 题目解析 方法一： 因为题目要求返回的顺序是从尾到头，所以我们可以采用递归的形式访问链表，在回归的过程才将节点的值存入ArrayList中，以达到逆序的目的...
ArrayList和Linkedlist1
08-08
1.List是接口类，ArrayList和LinkedList是List的实现类 2.ArrayList是动态数组（顺序表）的数据结构 3.LinkedList
深入理解Java中的ArrayList和LinkedList
01-20
杂谈基本数据结构–线性表: ... 　ArrayList和LinkedList是顺序存储结构和链式存储结构的表在java语言中的实现. 　ArrayList提供了一种可增长数组的实现，使用ArrayList，因为内部使用数组实现，所以，它
入门Kotlin编程 — 《第一行代码》学习笔记 01
chrismurphy的博客
03-24 270
入门 Kotlin 编程 /** We declare a package-level function main which returns Unit and takes an Array of strings as a parameter. Note that semicolons are optional. **/ import kotlin.math.max fun main(){ val a = 37 val b = 40 val value = largerNumber
【数据结构】ArrayList与顺序表
qq_74455045的博客
05-10 652
List接口；线性表；顺序表；ArrayList常用方法及其实现；ArrayList的构造方法、遍历、扩容；CVTE面试题：删除相同字符；洗牌算法；杨辉三角；ArrayList的优缺点
Kotlin中的List排序
热门推荐
Android菜鸟的专栏
09-04 1万+
一、排序的简单用法 在Java中，对List进行排序可以使用Collections.sort()方法，在Kotlin中有更简单的语法糖，所以这里记录一下，开发中尽量用简单的方式，方便维护。 一段未排序的示例代码如下： data class User(val name: String, val isOnline: Boolean) fun main() { val user1 = User("001", false) val user2 = User("002", false) va
数据结构：ArrayList与顺序表
Dreadnaught的博客
04-09 182
带你一篇文章了解ArrayList的底层原理，以及ArrayList的使用方法。
Spring Cloud——LoadBalancer
最新发布
????
05-01 1995
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
ArrayList是顺序表还是广义表
06-09
ArrayList是一种顺序表，它是Java中内置的动态数组实现。顺序表是一种常见的数据结构，它将数据元素存储在连续的存储空间中，并通过线性索引来访问元素。因此，顺序表支持随机访问，可以在O(1)的时间复杂度内访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值