当前位置：首页 > article >正文

ArrayList类

article 2025/1/18 7:02:23

ArrayList类

一：概念
二：ArrayList的遍历
三：杨辉三角
四：简单的洗牌算法：

一：概念

在集合框架中，ArrayList是一个普通的类，实现了List接口。
说明：
1：ArrayList是以泛型形式实现的，使用时必须实例化。
2：ArrayList实现了Cloneable接口，说明ArrayList是可以clone的
3：ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

二：ArrayList的遍历

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        //第一种遍历方式
        System.out.println(list);
        //第2种遍历方式:for
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");//获得i下标的元素并输出
        }
        System.out.println();
        //第3种遍历方式:for-each
        for (int x: list) {
            System.out.print(x+" ");
        }
        //第4种遍历方式:Iterator
        System.out.println();
        Iterator iterator= list.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
        System.out.println();
        //第5种遍历方式ListIterator
        ListIterator it= list.listIterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        //第6种遍历方式:从后往前遍历
        ListIterator iterator1=list.listIterator(list.size());
        while (iterator1.hasPrevious()){
            System.out.print(iterator1.previous()+" ");
        }
    }
}

在这里插入图片描述

三：杨辉三角

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
杨辉三角的值可以分成两部分，第一列元素和最后一类元素均为1，中间元素等于上一行的当前列和上一行当前列的前一列：
在这里插入图片描述
比如上图中的第3行，第一个元素和最后一个元素都是1；第二个元素等于第2行的第2列（当前列）和第2行的第1列（前1列）数值之和，第3个元素等于第2行的第3列（当前列）和第二行的第2列（前2列）数值之和；
力扣链接：
https://leetcode.cn/problems/pascals-triangle/

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> num=new ArrayList<>();
        //因为每一行都是一组元素，这里定义了一个二维数组
        List <Integer> ret=new ArrayList<>();
        //第一一个一维数组ret ,存放第一行的元素
        ret.add(1);
        num.add(ret);//将第一行的元素添加到二维数组中
        for(int i=1;i<numRows;i++){
            List<Integer> curRows=new ArrayList<>();//每次循环定义一个一维数组，
            //                                        表示当前行
            curRows.add(1);//每一行的第一个元素添加为1
            //定义一个一维数组preRows
            // preRows=num.get(i-1), preRows表示上一行
             List <Integer> preRows=new ArrayList<>();
                preRows=num.get(i-1);
            for(int j=1;j<i;j++){
                int x=preRows.get(j)+preRows.get(j-1);
                //将上一行的当前列和上一行的前1列求和
                curRows.add(x);
                //将求的和添加到当前行
            }
            curRows.add(1);//每一行的最后一个元素添加为1
            num.add(curRows);//将每一行的元素添加到二维数组中          
        }
         return num;
    } 
}

四：简单的洗牌算法：

下面主要写三个方法：
1：买牌方法：
2：洗牌方法：
3：发牌方法：
在这里插入图片描述首先：一张牌就是我们研究的对象，它具有两个属性：花色和大小：

 public String suit;//颜色
    public int num;//数字

买牌操作就是将52张牌实例化出来（每张牌有花色和数字），那么这52张牌并不是单独的，我们创建一个数组，用于存放这52张牌；
买牌

 public String[] cards={"♥","♠","♣","♦"};//创建一个数组，便于实例化一张牌
    public List<Card> buyCard(){
        List<Card> cardList=new ArrayList<>();//存放所有的牌
        for (int i = 0; i < cards.length; i++) {
            for (int j = 1; j <=13; j++) {
                Card card=new Card(cards[i],j);
                cardList.add(card);//将每张实例化的牌添加到数组中
            }
        }
        return cardList;
    }

2：洗牌就是将这些牌的顺序打乱：
这里采取的是将某一张牌与它前面的任意一张牌进行交换。
洗牌

  public List<Card> shuffle(List<Card> ret){
        Random random=new Random();//随机数
        for (int i = ret.size()-1; i>0; i--) {
            int index=random.nextInt(i);//产生0-(i-1)随机数
            swap(ret,i,index);//将i下标的牌与index下标的牌进行交换
        }
        return ret;
    }
    public void swap(List<Card> cardList,int i,int index){
        Card tmp=cardList.get(i);//定义中间变量tmp
        cardList.set(i,cardList.get(index));
        cardList.set(index,tmp);
    }

发牌：
这里的场景是有三个人，轮流摸5张牌。
因为每个人拿了5张牌，可以为每个人创建一个数组，用存放每个人拿到的牌。
我们把这3个玩家放在一个数组中，发牌的时候可以根据下边来进行遍历，从而进行发牌操作。
我们玩牌的时候:每个人拿的都是最上面的牌：因为当玩家把最上面的牌拿走后，意味着将这张牌从一堆牌中移除了，在这里借助的也是这个思想，

  public List<List<Card>> getCardList(List<Card> ret){
        List<Card> hand1=new ArrayList<>();//玩家1，hand1
        List<Card> hand2=new ArrayList<>();//玩家2，hand2
        List<Card> hand3=new ArrayList<>();//玩家3，hand3
        List<List<Card>> hand=new ArrayList<>(3);
        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);
        for (int i = 0; i <5; i++) {
            for (int j = 0; j < hand.size(); j++) {
                Card card=ret.remove(0);//获得第一张牌，并移除
                hand.get(j).add(card);//j下标的人拿到牌
            }
        }
        return hand;

    }

代码实现：

//Card类
public class Card {
    public String suit;//颜色
    public int num;//数字

    public Card(String suit, int num) {
        this.suit = suit;
        this.num = num;
    }

    @Override
    public String toString() {
        return suit+" "+num;
    }
}
//CardList类 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

public class CardList {
    public String[] cards={"♥","♠","♣","♦"};//创建一个数组，便于实例化一张牌
    public List<Card> buyCard(){
        List<Card> cardList=new ArrayList<>();//存放所有的牌
        for (int i = 0; i < cards.length; i++) {
            for (int j = 1; j <=13; j++) {
                Card card=new Card(cards[i],j);
                cardList.add(card);//将每张实例化的牌添加到数组中
            }
        }
        return cardList;
    }
    public List<Card> shuffle(List<Card> ret){
        Random random=new Random();//随机数
        for (int i = ret.size()-1; i>0; i--) {
            int index=random.nextInt(i);//产生0-(i-1)随机数
            swap(ret,i,index);//将i下标的牌与index下标的牌进行交换
        }
        return ret;
    }
    public void swap(List<Card> cardList,int i,int index){
        Card tmp=cardList.get(i);//定义中间变量tmp
        cardList.set(i,cardList.get(index));
        cardList.set(index,tmp);
    }
    public List<List<Card>> getCardList(List<Card> ret){
        List<Card> hand1=new ArrayList<>();//玩家1，hand1
        List<Card> hand2=new ArrayList<>();//玩家2，hand2
        List<Card> hand3=new ArrayList<>();//玩家3，hand3
        List<List<Card>> hand=new ArrayList<>(3);
        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);
        for (int i = 0; i <5; i++) {
            for (int j = 0; j < hand.size(); j++) {
                Card card=ret.remove(0);//获得第一张牌，并移除
                hand.get(j).add(card);//j下标的人拿到牌
            }
        }
        return hand;

    }


}
//Test类：
import java.util.List;

public class Test {
    public static void main(String[] args) {
        CardList cardList=new CardList();
        List<Card> ret=cardList.buyCard();
        System.out.println("买牌:");
        System.out.println(cardList.buyCard());
        System.out.println("洗牌:");
        System.out.println(cardList.shuffle(ret));

        System.out.println("揭牌：");
        List<List<Card>> hand = cardList.getCardList(ret);
        for (int i = 0; i < hand.size(); i++) {
            System.out.println("第 "+(i+1)+" 个人的牌："+hand.get(i));
        }


    }
}