ArrayList与LinkedList常用操作

本文主要内容：
1.ArrayList的常用操作
2.随机数的简单介绍
3.Java自定义相等性的比较
4.迭代器简单介绍
5.Iterable与foreach的关系
6.LinkedList的常用操作
7.instanceOf简单说明
8.ArrayList练习（洗牌）
9.LinkedList常用操作练习
1.ArrayList常用操作：
（1）构造方法
ArrayList(); 构造空的顺序表，容量为默认容量
ArrayList(int capacity); 构造空的顺序表，容量为capacity
ArrayList(Collection c); 构造一个顺序表，把c中所有的元素放到顺序表中

List<Integer> origin = Arrays.asList(1,2,3,4,5);
ArrayList<Integer> list = new Arraylist<>(origin);

（2）常用方法：
add(E element)： 尾插数据
add(int index,E element) ：把元素插到index位置
remove(Object o)： 删除顺序表中第一个o
remove(int index)： 删除顺序表中下标为index的位置
contains(E e)： 判断e是否在顺序表中
indexOf(E e)： 返回出现e的第一次下标
lastIndexOf(E e)： 返回出现e的最后一次下标
get(int index)： 返回下标元素
set(int index,E e) ： 更改下标元素
2.随机数
java.util.Random包下：
Random();与Random(long seed);
nextInt(bound)[0,bound)【bound不能为0】
伪随机，种子固定的情况下，随机产生是固定的，为了避免随机固定，引入时间作为种子，Rogue-Like
3.Java中自定义类相等性比较
（1）对于引用类型 == 判断的不是对象相等，而是引用相等，两个引用指向同一个对象
（2）Object类中有一个equals方法，在自定义类中覆写该方法，去调用该对象的equals方法
（3）自定义对象时：toString()、equals()推荐全部覆写
4.迭代器：Iterator
（1）重要方法：
boolean hasNext():判断是否有更多的元素
E next():返回迭代中的下一个元素
void remove():删除此迭代器返回的最后一个元素
5.Iterable和foreach关系：
foreach：for(int a:容器){};
ListIterator（双向迭代接口）：方法中有previous：可以返回前一个元素。是一个可以沿一个方向遍历列表的迭代器，在迭代期间修改列表，并得到列表中迭代器当前的位置。
只要类实现了Iterable接口，就可以被foreach语法使用了
6.LinkedList
（1）LinkedList实现了List/Deque，,Deque(双端队列，具有队列和栈性质的数据结构)
（2）构造方法：LinkedList();
LinkedList(Collection c);
（3）方法：void addFirst(E e):在该链表的开头插入指定元素
void addLast(E e):将指定元素插入列表的末尾
E getFirst():返回链表的第一个元素
E getLast():返回链表中最后一个元素
E peek():检索但不删除列表的头
E peekFirst():检索但不删除链表的第一个元素
E peekLast():检索但不删除链表的最后一个元素
E poll():检索并删除链表的头
E pollFirst():检索并删除链表的第一个元素
E pollLast():检索并删除链表的最后一个元素
void push(E e):将该元素推送到由列表表示的栈上
E pop():从此列表中栈上弹出一个元素
List<E> subList(int fromIndex,int toIndex):返回fromIndex（含）和toIndex之前的
视图
7.instanceOf
a instanceOf b:a对象能否被b数据类型的引用所指向，即a对象类型是不是b类型的小类型。
8.ArrayList练习（洗牌）

//首先定义一个porkCard类
public class PorkCard {
    private int value;
    private String color;
    public PorkCard(){
    }
    public PorkCard(String color,int value){
        this.color = color;
        this.value = value;
    }
    public int getValue(){
        return value;
    }
    public void setValue(int value){
        this.value = value;
    }
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
    @Override
    public String toString(){
        return "["+this.color+","+this.value+"]";
    }
    @Override
    public boolean equals(Object o){
        if(o==null){
            return false;
        }
        //PorkCard类型的引用是否指向o对象
        if(!(o instanceof PorkCard)){
            return false;
        }
        PorkCard porkCard = (PorkCard) o;
        return this.value==porkCard.value&&this.color.equals(porkCard.color);
    }
}
//其次定义playCards类，完成各个操作
public class PlayCards {
    public static void temp(ArrayList<PorkCard> arrayList,int i,int j){
        PorkCard temp1 = arrayList.get(i);
        PorkCard temp2 = arrayList.get(j);
        arrayList.set(i,temp2);
        arrayList.set(j,temp1);
    }
    public static void main(String[] args) {
        //写出52张牌
        ArrayList<PorkCard> arrayList = new ArrayList<>(52);
        //定义一个数组放入各种花色
        String[] cardColor = {"红桃","黑桃","方块","梅花"};
        //52张牌中有4中花色,每种花色13张
        for(int i = 0;i < 4;i++){
            for(int j = 0;j < 13;j++){
                PorkCard porkCard = new PorkCard(cardColor[i],j);
                arrayList.add(porkCard);
            }
        }
        System.out.println(arrayList);
        System.out.println("--------------------------------------");
        //洗牌->取出第52张牌，在前51张随机抽取一张后，两张牌交换(第一张牌例外)
        Random random = new Random(20190820);
        for(int i = 51;i >0;i--){
            //i = 51时，bound的范围[0,51)
            int num = random.nextInt(i);
            temp(arrayList,i,num);
        }
        System.out.println(arrayList);
        System.out.println("--------------------------------------");
        //给三个人分别发五张牌
        ArrayList<PorkCard> A = new ArrayList<>(5);
        ArrayList<PorkCard> B = new ArrayList<>(5);
        ArrayList<PorkCard> C = new ArrayList<>(5);
        for(int i = 1;i<16;i++){
            PorkCard porkCard = arrayList.get(arrayList.size()-1);
            switch (i%3){
                case 0:
                    A.add(porkCard);
                    break;
                case 1:
                    B.add(porkCard);
                    break;
                case 2:
                    C.add(porkCard);
                    break;
                default:
                    break;
            }
            arrayList.remove(porkCard);
        }
        System.out.println(A);
        System.out.println(B);
        System.out.println(C);
        System.out.println("------------------------------------");
        //查看A中有没有梅花4，如果有则删除，如果没有则返回
        PorkCard porkCard = new PorkCard("梅花",4);
        System.out.println(A);
        for(int i = 0;i<A.size();i++){
            if(porkCard.equals(A.get(i))){
                A.remove(porkCard);
                System.out.println(A);
            }
        }
        System.out.println("------------------------------------");
        Iterator<PorkCard> iterator = A.iterator();
        System.out.println(A);
        PorkCard porkCard1 = new PorkCard("红桃",4);
        while (iterator.hasNext()){
            PorkCard porkCard2 = iterator.next();
            if(porkCard1.equals(porkCard2)){
                iterator.remove();
                //在迭代器、foreach循环中使用集合提供的remove(),就会出现异常，而Iterator.remove()不会出现异常
            }
        }
        System.out.println(A);
        System.out.println("------------------------------------");
        if (A.contains(porkCard1)) {
            System.out.println("包含");
        } else {
            System.out.println("不包含");
        }
        System.out.println("--------------------------------------");
        ListIterator<PorkCard> listIterator = A.listIterator();
        System.out.println(listIterator.next());
        System.out.println(listIterator.next());
        System.out.println(listIterator.previous());
        System.out.println(listIterator.previous());
    }
}

运行结果：

[[红桃,0], [红桃,1], [红桃,2], [红桃,3], [红桃,4], [红桃,5], [红桃,6], [红桃,7], [红桃,8], [红桃,9], [红桃,10], [红桃,11], [红桃,12], [黑桃,0], [黑桃,1], [黑桃,2], [黑桃,3], [黑桃,4], [黑桃,5], [黑桃,6], [黑桃,7], [黑桃,8], [黑桃,9], [黑桃,10], [黑桃,11], [黑桃,12], [方块,0], [方块,1], [方块,2], [方块,3], [方块,4], [方块,5], [方块,6], [方块,7], [方块,8], [方块,9], [方块,10], [方块,11], [方块,12], [梅花,0], [梅花,1], [梅花,2], [梅花,3], [梅花,4], [梅花,5], [梅花,6], [梅花,7], [梅花,8], [梅花,9], [梅花,10], [梅花,11], [梅花,12]]
--------------------------------------
[[方块,1], [方块,7], [方块,3], [黑桃,12], [黑桃,8], [梅花,5], [红桃,7], [红桃,5], [红桃,10], [梅花,1], [红桃,12], [黑桃,11], [梅花,12], [方块,8], [黑桃,6], [梅花,11], [红桃,8], [黑桃,2], [方块,0], [方块,9], [梅花,3], [红桃,6], [方块,12], [红桃,3], [梅花,2], [梅花,10], [方块,6], [方块,11], [方块,4], [红桃,9], [红桃,1], [黑桃,10], [黑桃,0], [黑桃,7], [梅花,6], [红桃,0], [黑桃,4], [梅花,0], [黑桃,3], [梅花,9], [方块,10], [黑桃,5], [红桃,11], [梅花,8], [黑桃,1], [方块,5], [红桃,4], [红桃,2], [黑桃,9], [梅花,4], [梅花,7], [方块,2]]
--------------------------------------
[[梅花,4], [红桃,4], [梅花,8], [方块,10], [梅花,0]]
[[方块,2], [黑桃,9], [方块,5], [红桃,11], [梅花,9]]
[[梅花,7], [红桃,2], [黑桃,1], [黑桃,5], [黑桃,3]]
------------------------------------
[[梅花,4], [红桃,4], [梅花,8], [方块,10], [梅花,0]]
[[红桃,4], [梅花,8], [方块,10], [梅花,0]]
------------------------------------
[[红桃,4], [梅花,8], [方块,10], [梅花,0]]
[[梅花,8], [方块,10], [梅花,0]]
------------------------------------
不包含
--------------------------------------
[梅花,8]
[方块,10]
[方块,10]
[梅花,8]

9.LinkedList常用操作练习

public class MyLinkedList {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
        System.out.print(list.peek()+" ");
        System.out.print(list.peekFirst()+" ");
        System.out.println(list.peekLast());
        System.out.print(list.poll()+" ");
        System.out.print(list.pollFirst()+" ");
        System.out.println(list.pollLast());
        System.out.println(list);
        list.push(1);
        list.push(2);
        list.push(3);
        System.out.println(list);
        System.out.println(list.pop());
    }
}

运行结果：

[1, 2, 3]
1 1 3
1 2 3
[]
[3, 2, 1]
3