【Java语言面向对象】（56）ArrayList

ArrayList底层使用数组实现，从而达到可以动态添加元素。

ArrayList的源码分析

添加一个元素之前先检测内部的缓冲区是否充足，如果不足：动态扩容。

缓冲区一般在程序中使用buffer单词表示，其本质就是内存中一个数组而已。

看源码 --à查看本类中所有的成员 --à alt + 7   或ctrl + F12

ArrayList优缺点

优点

       连续的空间，遍历非常方便，且快，通过数组的下标直接定位。

缺点

1. 插入数据，导致后面的数据后移，有时间上的消耗。
2. 删除数据，导致后面的数据前移，有时间上的消耗。

如果数据量不大，移动的时间表现的不明显，可以忽略不计。

ArrayList使用场景

当数据量海量，且频繁的做插入和删除操作，不建议使用ArrayList，其他都可以。

ArrayList的使用

package com.njwbhz.March.week1.part0301;

import java.util.ArrayList;
import java.util.List;

/**
 * @author FairyKunKun
 * @since 2022/3/1
 */
public class TestArrayList1 {
    public static void main(String[] args) {
        //作为一个集合容器，起码具备可以保存任何数据的能力
        //先研究的是接口，然后才是具体实现
        //意识：面向接口编程、
        List list = new ArrayList();
        //查询元素的个数
        System.out.println(list.size());//0 size是真实的个数
        //添加元素
        //add(data)
        list.add("hello");
        list.add("world");

//        System.out.println(list.size());//2

        System.out.println(list);//[hello, world]
        //这说明了在ArrayList的一个父类中重写了祖父类中toString()的方法
    }
}

package com.njwbhz.March.week1.part0301;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TestArrayList2 {
    public static void main(String[] args) {
        //创建一个集合容器datas
        List datas = new ArrayList();

        //在datas中添加元素
        datas.add("aa");
        datas.add("bb");
        datas.add("cc");
        datas.add("dd");

        //使用对象名.get()方法检索集合容器中的数据
        System.out.println(datas.get(0));//aa
        System.out.println(datas.size());//4
//        System.out.println(datas.get(8));
        //如果指定的位置中不存在元素，运行时将报错：数组越界（越界异常）
        //Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 8, Size: 4

        //清空集合（清空集合容器中的所有元素）
//        datas.clear();

        //判断一个元素是否在集合中
        System.out.println(datas.contains("aa"));//true
        //如果存在返回boolean类型true，否则返回false

        //查询指定元素在集合中首次出现的位置，如果不存在，返回-1
        System.out.println(datas.indexOf("bbb"));//-1

        //判断集合容器是否为空
        System.out.println(datas.isEmpty());
        //如果没有元素存在返回boolean类型true，否则返回false

        //查询指定元素在集合中最后一次出现的位置
        System.out.println(datas.lastIndexOf("bb"));//1

        //删除在集合容器中首次出现的元素
        datas.remove("bb");
        System.out.println(datas);//[aa, cc, dd]

        //取集合元素中的子列表、
        List subList = datas.subList(0,3);
        //不包含末尾元素
        System.out.println(subList);//[aa, cc, dd]

        //由于ArrayList的底层代码是使用数组来实现的，所有数组和集合容器之间是可以相互转换的
        //使用对象名.toArray()方法将集合容器转成数组
        Object [] arrs = datas.toArray();
        for (int i = 0 ; i < arrs.length ; i++) {
            System.out.print(arrs[i]);//aaccdd
        }
        System.out.println();

        //用Arrays.asList()的类方法将数组转换成集合容器
        List arrToList = Arrays.asList(arrs);
        System.out.println(arrToList);//[aa, cc, dd]
    }
}

集合的遍历

方法1：借助get(int index)

方法2：

方法3：迭代器

方法4.Jdk1.8新特性

package com.njwbhz.March.week1.part0301;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;

/**
 * @author FairyKunKun
 * @since 2022/3/1
 */
public class TestArrayList3 {
    public static void main(String[] args) {
        List datas = new ArrayList();
        datas.add("aa");
        datas.add("bb");
        datas.add("cc");
        datas.add("dd");

        //集合的遍历
        //方法1:：借助get(int index)
        for (int i = 0 ; i < datas.size() ; i ++) {
            System.out.print(datas.get(i) + "\t");
        }
        //aa	bb	cc	dd
        System.out.println();

        //方法2：使用增强的for循环
        for (Object data : datas) {
            //for(集合中的每一个元素 : 集合)
            System.out.print(data + "\t");
        }
        //aa	bb	cc	dd
        System.out.println();

        //方法3：迭代器
        Iterator iterable = datas.iterator();
        while(iterable.hasNext()){
            System.out.print(iterable.next() + "\t");
        }
        //aa	bb	cc	dd

        System.out.println();
        //方法4：JDK1.8的新特性
        Consumer consumer = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.print(o + "\t");
            }
        };
        datas.forEach(consumer);//aa	bb	cc	dd
        System.out.println();
        datas.forEach((o) -> System.out.print(o + "\t"));//aa	bb	cc	dd
        System.out.println();
        datas.forEach(System.out::print);//aabbccdd
        System.out.println();




    }
}

在JDK1.8中提出了新的方法----流式操作。

ArrayList也拥有stream方法 ，获取到Stream对象

Stream可以大大提高代码的简洁度。

package com.njwbhz.March.week1.part0302;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

public class TestArrayList {
    public static void main(String[] args) {
        //存储多个姓名
        List names = new ArrayList();
        names.add("张三丰");
        names.add("赵敏");
        names.add("置若");
        names.add("赵潇");
        names.add("完颜阿骨打");

        //要求：将names中姓名长度为2的存储到一个心集合中并输出
//        List newNames = new ArrayList();
//        Iterator iterator = names.iterator();
//        while (iterator.hasNext()) {
//            String name = (String)iterator.next();//调用含有返回值的方法时可以对象名.方法.var回车会自动生成左侧部分
//            if (name.length() == 2) {
//                newNames.add(name);
//            }
//        }
//        System.out.println(newNames);

        //得到Stream流
        Stream stream = names.stream();

        stream.filter(data -> {
            String string = (String)data;
            return string.length() == 2 ? true : false;
        }).forEach(System.out::print);
        //Stream中间可以引入很多操作
        //大大提高代码的简洁度
    }
}