ArrayList

一.简介

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

说明：

1.ArrayList是以泛型方式实现的，使用时必须先实例化

2.ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问

3.ArrayList实现了Cloneable接口，表明ArrayList是可以clone的

4.ArrayList实现了Serializable接口，表明ArrayList是支持序列化的

二.ArrayList使用

1.ArrayList的构造

public class Main {
    public static void main(String[] args) {
        //创建一个空的列表
        List<Integer>list1 = new ArrayList<>();
 
        //构造一个具有10个容量的列表
        List<Integer>list2 = new ArrayList<>(10);
        list2.add(1);
        list2.add(2);
        list2.add(3);
        //list2.add("hello");//编译失败，List<Integer>以及限定了，list2中只能存储整型元素
 
        //list3构造好之后，与list元素一致
        List<Integer>list3 = new ArrayList<>(list2);
        list3.add(4);
        System.out.println(list3);//输出1，2，3，4
 
        //避免省略类型，否则任意类型的元素都可以存放，使用时将是一场灾难
        List list4 = new ArrayList();
        list4.add("111");
        list4.add(100);
    }
}

2.ArrayList常见操作

1. add() ——将指定元素添加到此集合的末尾或者在此集合中的指定位置插入指定元素

2. addAll() ——将指定集合中的所有元素添加到此集合中，从指定位置开始

3.clear() ——删除集合 中所有元素

4.contains() ——判断此集合是否包含某个元素

5. forEach() ——增强for循环

6. get() ——返回此集合中指定下标的元素

7. indexOf() ——获取指定元素在此集合中第一次出现的下标，未找到则返回 -1

8. lastIndexOf() ——获取指定元素在此集合中最后一次出现的下标，未找到则返回 -1

9. isEmpty() ——判断集合元素是否为空

10. iterator() ——迭代器

11. listIterator() ——迭代器

12. remove(Object o) ——删除该集合中指定下标的元素/删除集合中第一次出现的指定元素

    list.remove(2); //此时只能删除2下标的值，不能删除2这个元素，
    因为remove接收的是一个object类型的
 
    list.remove(new Integer(2));  //此时就能删除2这个元素了

13. removeAll() ——从该集合中删除指定集合中包含的所有元素

14. retainAll() ——保留此集合在指定集合包含的所有元素

15. removeIf() ——删除满足调教的所有元素

16. set() ——将指定下标的元素替换成新元素

17. size() ——获取此集合的元素个数

18. sort() ——使用提供的 Comparator 对此集合进行排序

19. toArray() ——以原顺序返回一个包含此列表所有元素的数组 

20.sublist(int fromIndex, int toIndex)——截取部分list

 
        List<Integer>list2 = new ArrayList<>(10);
        list2.add(1);
        list2.add(2);
        list2.add(3);
        List<Integer> list3 = list2.sublist(0,1);
        list3.set(0,188);  //改变list3的值时，也会改变原来list2里面对应的值
        System.out.println(list2);  //这是因为sublist只是给了那个范围的引用
        //一般情况下，能够直接通过sout输出引用类型的内容的时候，一定重写了toString

3.ArrayList的遍历

ArrayList可以使用三种方式遍历：for循环+下标，foreach，使用迭代器

public class Main {
    public static void main(String[] args) {
        //创建一个空的列表
        List<Integer>list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //使用下标+for遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        //借助foreach遍历
        for (Integer x:list) {
            System.out.print(x+" ");
        }
        System.out.println();
        //迭代器
        Iterator<Integer>it = list.listIterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
    }
}

ArrayList最常使用的遍历方式是：for循环+下标以及foreach

4.ArrayList的扩容机制

ArrayList是一个动态类型的顺序表，在插入元素的过程中会自动扩容

5.ArrayList的具体使用

1.把str1中str2的元素删除

2.杨辉三角

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        List<List<Integer>>list = new ArrayList<>();
        List<Integer>list1 = new ArrayList<>();
        list1.add(1);
        list.add(list1);
        //第一行已经处理完
        //下面从第二行开始
        for (int i = 1; i < n; i++) {
            List<Integer>last = new ArrayList<>();
            //用来记录上一行
            List<Integer>middle = new ArrayList<>();
            //用来记录中间行
            middle.add(1);
            //新的一行的第一个值
            for (int j = 1; j < i; j++) {
                last = list.get(i-1);
                middle.add(last.get(j)+last.get(j-1));
            }
            middle.add(1);
            //新的一行的最后一个值
            list.add(middle);
        }
        for (List x:list) {
            System.out.println(x);
        }
 
    }
}

3.简单的洗牌算法

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;
    }
 
    @Override
    public String toString() {
        /*return "Card{" +
                "suit='" + suit + '\'' +
                ", rank=" + rank +
                '}';*/
        return suit+" "+rank;
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
/**
 * @Author 12629
 * @Description：
 */
public class CardList {
 
    private static final String[] SUITS = {"♦","♥","♠","♣"};
 
 
    public static List<Card> buyCards() {
        List<Card> list = new ArrayList<>();
        for(int i = 0;i < SUITS.length;i++) {
            for (int j = 1; j <= 13; j++) {
                //String suit = SUITS[i];
                //int rank = j;
                Card card = new Card(SUITS[i],j);
                list.add(card);
            }
        }
        return list;
    }
 
    public static void shuffle(List<Card> list ) {
        Random random = new Random();
        for (int i = list.size()-1 ; i > 0 ; i--) {
            int index = random.nextInt(i);
            swap(list,i,index);
        }
    }
 
    private static void swap(List<Card> list,int i,int j) {
        Card tmp = list.get(i);
        list.set(i,list.get(j));
        list.set(j,tmp);
    }
 
 
    public static void main(String[] args) {
        List<Card> list = buyCards();
        System.out.println(list);
 
        shuffle(list);
        System.out.println(list);
 
        List< List<Card> > hand = new ArrayList<>();
 
        List<Card> hand1 = new ArrayList<>();
        List<Card> hand2 = new ArrayList<>();
        List<Card> hand3 = new ArrayList<>();
 
        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);
 
        //i 控制次数
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                //揭牌的逻辑怎么写？
                Card card = list.remove(0);
                hand.get(j).add(card);
            }
        }
 
        System.out.println("第1个人的牌："+hand.get(0));
        System.out.println("第2个人的牌："+hand.get(1));
        System.out.println("第3个人的牌："+hand.get(2));
 
        System.out.println("剩下的牌："+list);
        /*for (int i = 0; i < 3; i++) {
            System.out.println(hand.get(i));
        }*/
 
    }
 
}

6.ArrayList的问题

优点：可以通过下标，进行随机访问

缺点：添加元素效率较低（往一个下标添加元素要移动后面所有的元素

扩容时，每次扩容扩1.5倍，会有浪费空间的情况

所以顺序表适合静态数据的查找和更新，不适合用来插入和删除数据，这些依赖链表来做