• ArrayList

    一.简介

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

    说明：

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

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

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

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

    二.ArrayList使用

    1.ArrayList的构造

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

    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) ——删除该集合中指定下标的元素/删除集合中第一次出现的指定元素

    1.     list.remove(2); //此时只能删除2下标的值，不能删除2这个元素，
    2.     因为remove接收的是一个object类型的
    3.  
    4.     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

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

    3.ArrayList的遍历

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

    1. public class Main {
    2.     public static void main(String[] args) {
    3.         //创建一个空的列表
    4.         Listlist = new ArrayList<>();
    5.         list.add(1);
    6.         list.add(2);
    7.         list.add(3);
    8.         //使用下标+for遍历
    9.         for (int i = 0; i < list.size(); i++) {
    10.             System.out.print(list.get(i)+" ");
    11.         }
    12.         System.out.println();
    13.         //借助foreach遍历
    14.         for (Integer x:list) {
    15.             System.out.print(x+" ");
    16.         }
    17.         System.out.println();
    18.         //迭代器
    19.         Iteratorit = list.listIterator();
    20.         while (it.hasNext()){
    21.             System.out.print(it.next()+" ");
    22.         }
    23.         System.out.println();
    24.     }
    25. }

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

    4.ArrayList的扩容机制

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

    5.ArrayList的具体使用

    1.把str1中str2的元素删除

    2.杨辉三角

    1. public class Main {
    2.     public static void main(String[] args) {
    3.         Scanner scanner = new Scanner(System.in);
    4.         int n = scanner.nextInt();
    5.         List>list = new ArrayList<>();
    6.         Listlist1 = new ArrayList<>();
    7.         list1.add(1);
    8.         list.add(list1);
    9.         //第一行已经处理完
    10.         //下面从第二行开始
    11.         for (int i = 1; i < n; i++) {
    12.             Listlast = new ArrayList<>();
    13.             //用来记录上一行
    14.             Listmiddle = new ArrayList<>();
    15.             //用来记录中间行
    16.             middle.add(1);
    17.             //新的一行的第一个值
    18.             for (int j = 1; j < i; j++) {
    19.                 last = list.get(i-1);
    20.                 middle.add(last.get(j)+last.get(j-1));
    21.             }
    22.             middle.add(1);
    23.             //新的一行的最后一个值
    24.             list.add(middle);
    25.         }
    26.         for (List x:list) {
    27.             System.out.println(x);
    28.         }
    29.  
    30.     }
    31. }

    3.简单的洗牌算法

    1. public class Card {
    2.     private String suit;//花色
    3.     private int rank;//扑克的数字
    4.  
    5.     public Card(String suit, int rank) {
    6.         this.suit = suit;
    7.         this.rank = rank;
    8.     }
    9.  
    10.     public String getSuit() {
    11.         return suit;
    12.     }
    13.  
    14.     public void setSuit(String suit) {
    15.         this.suit = suit;
    16.     }
    17.  
    18.     public int getRank() {
    19.         return rank;
    20.     }
    21.  
    22.     public void setRank(int rank) {
    23.         this.rank = rank;
    24.     }
    25.  
    26.     @Override
    27.     public String toString() {
    28.         /*return "Card{" +
    29.                 "suit='" + suit + '\'' +
    30.                 ", rank=" + rank +
    31.                 '}';*/
    32.         return suit+" "+rank;
    33.     }
    34. }
    1. import java.util.ArrayList;
    2. import java.util.List;
    3. import java.util.Random;
    4.  
    5. /**
    6.  * @Author 12629
    7.  * @Description：
    8.  */
    9. public class CardList {
    10.  
    11.     private static final String[] SUITS = {"♦","♥","♠","♣"};
    12.  
    13.  
    14.     public static List buyCards() {
    15.         List list = new ArrayList<>();
    16.         for(int i = 0;i < SUITS.length;i++) {
    17.             for (int j = 1; j <= 13; j++) {
    18.                 //String suit = SUITS[i];
    19.                 //int rank = j;
    20.                 Card card = new Card(SUITS[i],j);
    21.                 list.add(card);
    22.             }
    23.         }
    24.         return list;
    25.     }
    26.  
    27.     public static void shuffle(List list ) {
    28.         Random random = new Random();
    29.         for (int i = list.size()-1 ; i > 0 ; i--) {
    30.             int index = random.nextInt(i);
    31.             swap(list,i,index);
    32.         }
    33.     }
    34.  
    35.     private static void swap(List list,int i,int j) {
    36.         Card tmp = list.get(i);
    37.         list.set(i,list.get(j));
    38.         list.set(j,tmp);
    39.     }
    40.  
    41.  
    42.     public static void main(String[] args) {
    43.         List list = buyCards();
    44.         System.out.println(list);
    45.  
    46.         shuffle(list);
    47.         System.out.println(list);
    48.  
    49.         List< List > hand = new ArrayList<>();
    50.  
    51.         List hand1 = new ArrayList<>();
    52.         List hand2 = new ArrayList<>();
    53.         List hand3 = new ArrayList<>();
    54.  
    55.         hand.add(hand1);
    56.         hand.add(hand2);
    57.         hand.add(hand3);
    58.  
    59.         //i 控制次数
    60.         for (int i = 0; i < 5; i++) {
    61.             for (int j = 0; j < 3; j++) {
    62.                 //揭牌的逻辑怎么写？
    63.                 Card card = list.remove(0);
    64.                 hand.get(j).add(card);
    65.             }
    66.         }
    67.  
    68.         System.out.println("第1个人的牌："+hand.get(0));
    69.         System.out.println("第2个人的牌："+hand.get(1));
    70.         System.out.println("第3个人的牌："+hand.get(2));
    71.  
    72.         System.out.println("剩下的牌："+list);
    73.         /*for (int i = 0; i < 3; i++) {
    74.             System.out.println(hand.get(i));
    75.         }*/
    76.  
    77.     }
    78.  
    79. }

    6.ArrayList的问题

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

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

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

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

  • 相关阅读:
    【每日一题】打卡 47
    P251——用RadialGradientBrush填充椭圆，并进行RotateTransform变换
    神经网络的图像识别技术,神经网络识别图像原理
    人工智能精品课程网站的设计与实现（Vue.js+Java+Spring Boot+MySQL）
    流媒体分析之srt 协议libsrt 实现
    lodash按需引入
    Visual Studio 2022新建项目时没有ASP.NET项目
    【HMS Core】AOSP11安装/预置HMS Core 可以关闭限制广告跟踪吗？
    Sql case函数
    ES6 Iterator 和 for...of 循环
  • 原文地址：https://blog.csdn.net/xkroy/article/details/138166354