ArrayList和顺序表(下)

1. Java本身提供的ArrayList

在ArrayList和顺序表(上)那一节里面,我们自己实现了ArrayList的底层大部分代码,在这个基础上,我们就可以开始来了解Java本身提供的ArrayList.

1.1 ArrayList的三种构造方法

方法	解释
ArrayList()	无参构造
ArrayList(Collection<? extends E > c)	利用其他的Collection构造ArrayList
ArratList(int innitialCapacity)	指定顺序表初始容量

我们先来介绍第一和第三个

第一个构造方法,如果我们不设置任何参数,这里会直接给我们一个空的Object数组,里面没有大小.

第二个构造方法,我们指定的容量是合法的,我们就产生一个指定容量大小的数组,

第三个构造方法,我们必须要理解 Collection<? extends E > c 这个是什么意思

我们来举个例子

所以我们就晓得第二个构造方法的主要用法了:

1. 该集合类必须实现Collection接口

2. 在第一个<>设置的类型必须是第二个<>的子类或者它自己

这样就能实现直接把另一个实例的内容作为我新的实例的内容.

我们来看代码:

public static void main(String[] args) {
        //ArrayList第二个构造方法 ,要求必须实现Collection,并且放进去的东西是子类(这个搞清楚是谁的子类)
        ArrayList<Integer> list = new ArrayList<>();//TODO 虽然没有分配内存
        list.add(1);//TODO 结论1.但是第一次Add的时候会分配大小为10的内存
        list.add(2);//TODO 结论2.如果超过了,就会1.5倍自动扩容
        list.add(3);//添加元素
        list.add(0,99);
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        //相当于直接把一组数据放进来了
        ArrayList<Number> list2 = new ArrayList<>(list);//Integer是Number的子类,因此可以放进来
        LinkedList<Integer> list1 = new LinkedList<>();
        list1.add(1);
        list1.add(2);
        list1.add(4);
        ArrayList<Number> list3 = new ArrayList<>(list1);//Integer是Number的子类,因此可以放进来
        list3.add(1123);
        list3.add(1124);
        System.out.println(list3);
        System.out.println(list1);
}

我们主要要主要这个

我们可以来看看源码(了解即可)

结论:

1. 我们在创建ArrayList实例的时候,不设置参数,我们调用的是无参构造方法,里面是一个空的数组,没有分配内存.

2. 当第一次add的时候,我们才会分配大小为10的内存

3. 如果add方法检测出size大小等于数组大小,就会进行1.5倍的扩容

1.2 ArrayList方法的介绍

方法	解释
boolean add(E e)	在最后一个有效数据后面插入e
void add(int index,E e)	把插入到index位置
void 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,E e)	把下标index位置元素设置为e
E clear()	清空
boolean contains(Object o)	判断o是否在线性表里面
int indexOf(Object o)	返回第一个o所在的下标
int lastIndexOf(Object o)	返回最后一个o的下标
List<E> subList(int fromIndex,int toIndex)	截取部分list

我们来使用一下这些方法

public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    ArrayList<Number> list1 = new ArrayList<>();
    list.add(1);//TODO add的使用
    list.add(2);
    list.add(3);
    list.add(10);
    list.add(9);
    list.add(90);
    list.add(90);
    list.add(2,54);
    list1.addAll(list);
    //我们是可以直接通过list打印,因为它实现的一个接口重写了toString方法
    System.out.println("list:"+list);
    System.out.println("list1:"+list1);
    System.out.println("=============");
    list.remove(1);//TODO remove的使用
    list.remove(new Integer(3));
    System.out.println("list:"+list);
    System.out.println("==========");
    System.out.println(list.get(2));//TODO get的使用
    list.set(3,190);//TODO get的使用
    System.out.println("list:"+list);
    System.out.println("==========");
    System.out.println(list.contains(1));//TODO contains的使用
    System.out.println(list.indexOf(90));//TODO indexOf的使用
    System.out.println(list.lastIndexOf(90));//TODO lastIndexOf的使用
    System.out.println(list);
    list.clear();
    System.out.println(list);
}
list:[1, 2, 54, 3, 10, 9, 90, 90]
list1:[1, 2, 54, 3, 10, 9, 90, 90]
=============
list:[1, 54, 10, 9, 90, 90]
==========
10
list:[1, 54, 10, 190, 90, 90]
==========
true
4
5
[1, 54, 10, 190, 90, 90]
[]

我们需要注意的几个地方

addAll()里面我们放的是一个Number类型或者其子类的对象

remove里面,如果我们是想移除一个数,而不是移除下标的数,我们里面的参数就是引用类型的对象

list.remove(new Integer(3));

还有一个方法

List<E> subList(int fromIndex,int toIndex)

public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    List<Integer> list1 = list.subList(0,2);
    System.out.println("list1" + list1);
    System.out.println("list" + list);
    System.out.println("====");
    list1.add(123);
    list1.set(0,99);
    System.out.println("list1" + list1);
    System.out.println("list" + list);
}
list1[1, 2]
list[1, 2, 3, 4]
====
list1[99, 2, 123]
list[99, 2, 123, 3, 4]

我们可以得到一下几个结论:

1. subList的参数设置是[第一个参数,第二个参数)

2. subList的返回值是一个List类型的

3. 我们subList方法并不会产生一个新的对象,而是直接把list的地址传给了list2,因此我们操作list2的时候list也会发生改变

1.3 ArrayList的遍历

ArrayList可以通过四种方式来进行遍历,直接打印对象名字,for循环,foreach,使用迭代器

1> 我们直接通过打印对象名

2> 我们通过for循环来打印

3> 我们通过foreach来打印

4> 我们通过迭代器进行打印

使用迭代器来遍历集合类,我们只需要实现Iterable接口即可

由下图可知,ArrayList是实现了Iterable接口的

因为迭代器写法我们比较陌生,我们再来看看它的形式

Iterator<引用数据类型> 对象名 = 实现了Iteratable接口的对象.Iterator();

whie(对象名.hasNext()) {
System.out.print(it.next()+" ");

}

2. 练习题

2.1 杨辉三角

题目:

我们在写这个题目之前先了解一下List的二维数组的写法

解题步骤

1. 我们先处理第一行的数据,第一行就是1,我们直接把一维数组的第一行数据设置为1,然后把第一行放到二维数组里面

2. 从第2行开始我们开始计算每个list中的数据

我们先准备当前行的数据,就需要一个List类型的一维数组,然后我们放入每一行的第一个元素,就是1,然后我们构造每一行中间的数据,我们需要获得上一行的数据,我们通过ret.get(i-1)获得上一行,然后构造下一行的中间数据,通过preRow.get(j-1),preRow.get(j)来获得上一行元素的前一个,和上一行的正上方一个,然后把他们相加就是本行数据的值,然后我们把它加入到当前行里面去.

3. 把1加入到当前行的最后一个位置

4. 把当前行加入到ret二维数组里面去

整体代码

class YangHuiTriangle {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        //TODO 1.先处理第一行的数据
        list.add(1);//每一行代表一个list,第一行放的元素是1
        ret.add(list);//把第一行放入二维数组
        //TODO　2．从第2行开始计算每个list中的数据
        for (int i = 1 ; i < numRows ;i++) {
            //TODO 3.先准备当前行数据
            List<Integer> curRow = new ArrayList<>();
            //TODO 4.当前行的第一个数据
            curRow.add(1);
            //TODO 5.准备当前行的中间元素:上一行的前一个,上一行的正上方一个
            //找到前一行
            List<Integer> preRow = ret.get(i - 1);
            //构造下一行
            for (int j = 1 ; j < i ; j++) {
                //通过get方法来获取顺序表里面的值
                int val = preRow.get(j)+preRow.get(j-1);
                //然后放进当前行里面
                curRow.add(val);
            }
            //TODO 6.准备当前行的最后一个数据
            curRow.add(1);
            //TODO 7.当前行放进ret二维数组里面
            ret.add(curRow);
        }
        return ret;
    }
}

2.2 简单的洗牌算法

主要的步骤

1. 生成一副扑克牌

2. 洗牌

3. 发牌

我们规定3个人来抓牌,每个人轮流抓5张(一共抓了15张牌

我们先构造出Card这个类,一个牌时由花色和数字组成的,我们在这个类里面设置这俩个属性,

并且提供相应的构造方法.又因为是private 修饰的,我们需要为这俩个属性设置set和get方法,并且我们重写了toString方法.

public class Card {
    private String suit;//花色
    private int rank;//数字

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

    public String getSuit() {
        return suit;
    }

    public void setSuit(String suit) {
        this.suit = suit;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }
    //打印牌,需要toString方法

    @Override
    public String toString() {
        return suit+": " + rank+" ";
    }
}

然后我们写一个cardDemo类来对Card进行构造



import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class  CardDemo {
    //四种花色
    private final String[] suits = {"♥","♠","♦","♣"};
    
    //买牌
    public List<Card> buyCard() {
        List<Card> cardList = new ArrayList<>();
        //TODO 1.生成牌
        for (int i = 0; i < 4; i++) {//花色
            for (int j = 1; j <= 13; j++) {//数字
                Card card = new Card(suits[i],j);//每一张花色产生13个数字
                cardList.add(card);//把创建出来的每一张牌都放进去
            }
        }
        return cardList;
    }
    //TODO 2.洗牌
    public List<Card> shuffle(List<Card> cardList) {
        Random random = new Random();
        //我们从最后面开始,第50张和前面49张进行随机交,然后第49张和前面48张进行交换
        for (int i = cardList.size() - 1; i > 0 ; i--) {
            int index = random.nextInt(i);
            // 我们把 index 和 i 进行交换
            swap(cardList,i,index);
        }
        return cardList;
    }
    private void swap(List<Card> cardList,int a,int b) {
        Card stm = cardList.get(a);
        cardList.set(a,cardList.get(b));
        cardList.set(b,stm);
    }
    //TODO 3.发牌,三个人,每人轮流揭牌5张
    public void getCard(List<Card> cardList) {
        //每个人相当于一个一维的Card数组
        List<Card> hand1 = new ArrayList<>();
        List<Card> hand2 = new ArrayList<>();
        List<Card> hand3 = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        hands.add(hand1);
        hands.add(hand2);
        hands.add(hand3);
        //3个人轮流抓五张
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                Card card = cardList.remove(0);//去除每一张摸走的牌
                hands.get(j).add(card);//发给每个人
            }
            System.out.println("第一个人的牌: ");
            System.out.println(hand1);
            System.out.println("第二个人的牌: ");
            System.out.println(hand2);
            System.out.println("第三个人的牌: ");
            System.out.println(hand3);
            System.out.println("剩下的牌: ");
            System.out.println(cardList);
        }

    }
}

我们分段进行解析这个代码:

1. 生成牌

我们需要四种花色