class MyArrayList{
private int[] elem;// 建立数组
private int usedSize;// 有效元素个数
public MyArrayList(){// 构造方法
this.elem = new int[10];// 默认数组初始容量为 10
}
public void add(int val){// 添加元素
this.elem[usedSize] = val;
}
public int get(int pos){// 得到指定位置的元素
return this.elem[pos];
}
}
public class Test {
}
但是这个代码并不通用,只能存储一种数据类型(int)。
基本数据类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
public class TestDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");// 添加List元素
System.out.println(list);
System.out.println("===============");
list.add(1,"g");// 在List指定位置中添加元素
System.out.println(list);
System.out.println("========");
List<String> list1 = new ArrayList<>();
list1.add("x");
list1.add("y");
list.addAll(list1);// 将一个list1 整体添加 list中
System.out.println(list);
}
}
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(i);
}
}
首先我们认为这个代码是没有缺陷的,但是因为ArrayList 底层的数组是有一定大小的,那么存放数组的过程中,一定会涉及到扩容,
前面我们讲到ArrayList 有三种方法,现在使用的是不带参数的,也就是说ArrayList 底层的数组初始容量为零。 那么第一个问题就出现了: 既然数组的容量是为零,那么它怎么还可以存入数据?
第二个问题: 假设数组初始化容量为10,超过了10,就需要扩容。而且扩容操作时在代码底层执行,是看不见的,也就是说ArrayList在存储数据,隐式的进行扩容操作,那么它的扩容机制是怎样的?
&ensp;
// E 是数据类型
方法 | 解释 |
---|---|
boolean add(E e) | 尾插 e |
void add(int index,E element) | 将e 插入到index位置 |
boolean addAll(Collection<? extends E> c) | 尾插 c 中的元素(将一个顺序表所有元素,尾插到另一个顺序表中) |
E remove(int index) | 删除 index 位置元素 |
boolean remove(Object o) | 删除遇到的第一个 o |
E get(int index) | 获取下标index位置元素 |
E set(int index,Eelement) | 将下标为index的元素,置换为 element |
void clear() | 清空 |
boolean contains(Object o) | 判断 o 是否在线性表中 |
int indexOf(Object o) | 从左往右 返回第一个 o 的下标 |
int lastIndexOf(Object o) | 返回最后一个o的下标 (从右往左 返回第一个 o 的下标) |
List subList(int fromIndex,int tolndex) | "截取"部分list |
&ensp;
效果图
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
class Card{
private int point;
private String flowerColor;
public Card(int point, String flowerColor) {
this.point = point;
this.flowerColor = flowerColor;
}
public int getPoint() {
return point;
}
public void setPoint(int point) {
this.point = point;
}
public String getFlowerColor() {
return flowerColor;
}
public void setFlowerColor(String flowerColor) {
this.flowerColor = flowerColor;
}
@Override
public String toString() {
return "{ " +flowerColor +" "+point+" }";
}
}
public class PlayingCard {
// 定义 扑克牌的花色
private static final String[] flowerColors = {"♥","♠","♦","♣"};
// 创建一副扑克
public static List<Card> newCard() {
ArrayList<Card> cards = new ArrayList<>();
for (int i = 0; i < 4; i++) {// 4种花色
for (int j = 1; j <= 13; j++) {// 尖 到 k 一共13个点数
cards.add(new Card(j,flowerColors[i]));
}
}
return cards;
}
// 洗牌
public static void shuffle(List<Card> list){
// 牌数是52,数组下标就是51
// 从最后一张牌开始,随机与 本身 或者 本身前面的任意一张牌 交换位置。
// 这样的做交换性 比 从开头洗 的 打乱顺序的 效率 高。
for (int i = list.size()-1; i >0 ; i--) {
// Random 是一个生成随机数的类
Random random = new Random();
// 通过 Random的引用 random 去调用 nextInt() 方法。
// random.nextInt() 方法,根据括号中的值,随机生成 0 ~ 括号中的值
int rand = random.nextInt(i);
// 将 第 i 张牌 , 与 自身 或者 自身前面的任意一张牌的下标 丢给 swap方法
// 让它去交换位置
swap(list,i,rand);
}
}
// 交互式洗牌模式
private static void swap(List<Card> list,int i,int j){
// 我们现在是面向对象,ArrayList虽然底层是一个数组,但是需要使用方法,才能操作数组的元素
// 并不能像数组一样,直接操作
// Card tmp = list[i];
Card tmp = list.get(i);// 获取 顺序表中,对应下标的元素
// list[i] = list[j];
list.set(i,list.get(j));// 将 j下标的元素,赋给 i 下标的元素,
// list[j] = tmp;
list.set(j,tmp);
}
public static void main(String[] args) {
System.out.println("======一副买来拆的牌==========");
List<Card> list = newCard();
System.out.println(list);
System.out.println("======== 洗牌 =========");
shuffle(list);
System.out.println(list);
System.out.println("======== 发牌,3个人轮着发,每个人5张牌=========");
ArrayList<ArrayList<Card>> player = new ArrayList<>();
// 这行代码 就是 一个二维数组,
// 首先我们有一个player, player 的每个元素 都是 ArrayList<Card> 类型。
// 也就是说每个元素就是一个顺序表,也可以说是一个一维数组。
// 你也可以这么理解 第一个 ArrayList 是用来记录有 玩家的方位/顺序表的地址/数组的地址
// 第二个ArrayList 就是 每个玩家手上牌的情况/数组的元素情况/顺序表的底层数组元素情况。
// 你可以 把 player 看作牌桌,等待三位玩家的入场。
// 打牌三人组
ArrayList<Card> playerOne = new ArrayList<>();
ArrayList<Card> playerTwo = new ArrayList<>();
ArrayList<Card> playerThree = new ArrayList<>();
// 将三位玩家的信息,加载到 player 当中
player.add(playerOne);
player.add(playerTwo);
player.add(playerThree);
for (int i = 0; i < 5; i++) {// 发 5 轮牌
for (int j = 0; j < 3; j++) {// 每个人 轮着发,最终每个人5张牌
Card card = list.remove(0);
player.get(j).add(card);
}
}
// 打印每个人的手牌
System.out.println("playerOne的手牌:"+ playerOne);
System.out.println("playerTwo的手牌:"+playerTwo);
System.out.println("playerThree的手牌:"+playerThree);
System.out.println("list 剩余的牌:"+list);
}
// public static void main1(String[] args) {
// Card card = new Card(3,"♠");
// System.out.println(card);
// }
}
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/DarkAndGrey/article/details/121687446
内容来源于网络,如有侵权,请联系作者删除!