当前位置:   article > 正文

Java常用类库之ArrayList_引用什么库含有arraylist

引用什么库含有arraylist

ArrayList

类继承了 AbstractList 类。 AbstractList 是 List 接口的子类。 AbstractList 是个抽象类, 适配器设计模式。

采用数组结构存储,增加删除慢,查找快

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
  • 1
  • 2

1. 构造方法

  • ArrayList() -> 默认初始容量为10,到11个,原10长度会被丢弃,新建15长度(1.5倍扩容),如果需要大量数据,为避免空间浪费,尽量使用下面的含参构造方法。构造时使用的类型要用类,不能使用基本数据类型
ArrayList<Integer> data = new ArrayList<>();
  • 1

源码如下,DEFAULTCAPACITY_EMPTY_ELEMENTDATA={},所以构造新数组时实际长度是为0的,但文档中初始容量为何为10,这与扩容算法有关

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
  • 1
  • 2
  • 3
  • ArrayList​(int initialCapacity) 构造具有指定初始容量的空列表
  • ArrayList​(Collection<? extends E> c) 构造一个包含指定集合元素的列表

2. 方法

添加元素
  • public boolean add​(E e)将指定的元素追加到此列表的末尾。
  • public void add​(int index, E element)将指定元素插入此列表中的指定位置。 将当前位置的元素(如果有)和任何后续元素向右移动(将其添加到索引中)。
  • public boolean addAll​(int index, Collection<? extends E> c)从指定位置开始,将指定集合中的所有元素插入此列表。 将当前位置的元素(如果有)和任何后续元素向右移动(增加其索引)。
  • public boolean addAll​(Collection<? extends E> c)

add​(E e)源码分析:

public boolean add(E e) {
    modCount++;
    //add(插入元素,数组数据,有效数据的长度)
    add(e, elementData, size);
    //无论成功失败都会返回true!!!
    return true;
}

private void add(E e, Object[] elementData, int s) {
    //如果已有数据量达到数组最大长度,调用grow()扩容算法
    if (s == elementData.length)
        elementData = grow();
    //如果还有空间,直接加到末尾,有效数据长度加1
    elementData[s] = e;
    size = s + 1;
}

private Object[] grow() {
    //至少要加1长度
    return grow(size + 1);
}

private Object[] grow(int minCapacity) {
    //Arrays.copyof()把新长度数组拷贝到原数组
    return elementData = Arrays.copyOf(elementData,
                                        newCapacity(minCapacity));
}

private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //oldCapacity >> 1,二进制数右移一位,减小一半,即扩容1.5倍。注意:空数组和1元素的数组扩容无效
    int newCapacity = oldCapacity + (oldCapacity >> 1);

    //扩容后空间仍然小于最小需要的空间,即不够存
    if (newCapacity - minCapacity <= 0) {

        //如果原数组为空(即第一次存储),DEFAULTCAPACITY_EMPTY_ELEMENTDATA={},返回DEFAULT_CAPACITY=10和需求的空间的最大值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            return Math.max(DEFAULT_CAPACITY, minCapacity);

        //最小长度超过int最大值,溢出变成负数,抛出内存溢出异常
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();

        //如果既不是第一次添加数据也没有溢出,即添加一组数据时,如果扩容1.5倍无法满足,则返回最小需要的长度
        return minCapacity;
    }

    //扩容后的新长度够用,且如果小于MAX_ARRAY_SIZE=int最大值-8,返回新长度,不然跳转到hugeCapacity(minCapacity)
    return (newCapacity - MAX_ARRAY_SIZE <= 0)
        ? newCapacity
        : hugeCapacity(minCapacity);
}

private static int hugeCapacity(int minCapacity) {
    //首先没有溢出
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    //如果所需长度大于int最大值-8
    return (minCapacity > MAX_ARRAY_SIZE)
    //返回int最大值
        ? Integer.MAX_VALUE
    //不然返回int最大值-8
        : MAX_ARRAY_SIZE;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

使用:

ArrayList<Integer> data = new ArrayList<>();
data.add(100);
data.add(99);
data.add(98);
System.out.println(data.toString());
//[100, 99, 98]

data.add(2,44);
System.out.println(data.toString());
//[100, 99, 44, 98]

ArrayList<Integer> data1 = new ArrayList<>();
data1.add(23);
data1.add(43);
data1.add(56);
data.addAll(2, data1);
System.out.println(data.toString());
//[100, 99, 23, 43, 56, 44, 98]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
删除元素
  • public E remove​(int index)删除此列表中指定位置的元素,并返回该元素。 将任何后续元素向左移位(从索引中减去一个元素)。
  • public boolean remove​(Object o)从该列表中删除指定元素的第一个匹配项(如果存在)。 如果列表不包含该元素,则不会更改。
System.out.println(names.remove(2));
//王五
System.out.println(names);
//[张三, 李四]
System.out.println(names.remove("赵六"));
//false
System.out.println(names.remove("李四"));
//true
System.out.println(names);
//[张三]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • public boolean removeIf​(Predicate<? super E> filter)删除此集合中满足给定过滤条件的所有元素。
ArrayList<String> names = new ArrayList<>(3);
names.add("张三");
names.add("李四");
names.add("王五");
System.out.println("Names:"+names);
//Names:[张三, 李四, 王五]
names.removeIf(s -> s.contains("李"));
System.out.println(names);
//[张三, 王五]

ArrayList<Integer> data = new ArrayList<>();
data.add(100);
data.add(99);
data.add(98);
data.add(97);
data.add(96);
data.add(95);
System.out.println(data);
//[100, 99, 98, 97, 96, 95]

//是偶数则删除
data.removeIf(integer -> (integer % 2) == 0);
System.out.println("Odd numbers:" + data);
//Odd numbers:[99, 97, 95]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • public boolean removeAll​(Collection<?> c)从此列表中删除指定集合中包含的所有元素。
//data = [100, 99, 98, 97, 96, 95]

//删除指定的数组中的元素
data.removeAll(data);
System.out.println(data);
//[]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • protected void removeRange​(int fromIndex, int toIndex)从此列表中删除索引介于fromIndex (含)和toIndex (独占)之间的所有元素。 将任何后续元素向左移动(降低其索引)。 此调用通过(toIndex - fromIndex)元素缩短列表。 (如果toIndex==fromIndex ,此操作无效。)
    • removeRange() 方法是受保护的(Protected),所以如果要使用需要继承 ArrayList 类,继承后我们就可以使用Demo3类来创建一个动态数组
    • 因此使用ArrayList.subList(int fromIndex, int toIndex).clear()更方便
public class Demo3 extends  ArrayList<Integer>{
    public static void main(String[] args) {
        Demo3 data = new Demo3();
        data.add(100);
        data.add(99);
        data.add(98);
        data.add(97);
        data.add(96);
        data.add(95);
        System.out.println(data);
        //[100, 99, 98, 97, 96, 95]
        data.removeRange(1, 3);
        System.out.println(data);
        //[100, 97, 96, 95]
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • public boolean retainAll​(Collection<?> c)仅保留此列表中包含在指定集合中的元素。 换句话说,从该列表中删除未包含在指定集合中的所有元素。
//data = [100, 99, 98, 97, 96, 95]

//只保留索引为[2,4)的元素
data.retainAll(data.subList(2,4));
System.out.println(data);
//[98, 97]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • public void clear()
//接上
data.clear();
System.out.println(data.toString());
//[]
  • 1
  • 2
  • 3
  • 4
public Object clone()
  • 功能:clone() 方法用于拷贝一份动态数组,属于浅拷贝

浅拷贝只复制指向某个对象的指针,而不复制对象本身,新旧对象还是共享同一块内存, 所以如果其中一个对象改变了这个地址,就会影响到另一个对象

浅拷贝对应的就是深拷贝,深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象。

data1 = (ArrayList<Integer>)data.clone();
System.out.println(data.clone());
//[100, 99, 23, 43, 56, 44, 98]
System.out.println(data1.toString());
//[100, 99, 23, 43, 56, 44, 98]
  • 1
  • 2
  • 3
  • 4
  • 5

这里clone()的返回值是Object,所以需要ArrayList)进行类型转换为整数型的动态数组

参考来源 http://www.w3school.me/java/java-arraylist-clone.html

public boolean contains​(Object o)
  • 功能:如果此列表包含指定的元素,则返回true。
Integer i = 100;
System.out.println(data.contains(i));
//true
  • 1
  • 2
  • 3
public void ensureCapacity​(int minCapacity)
  • 功能:增加此 ArrayList实例的容量,以确保它至少可以容纳由minimum capacity参数指定的元素数。虽然ArrayList会动态扩容,但是手动确定数组长度可以减少自动扩容花费的时间
ArrayList<String> names = new ArrayList<>();
names.ensureCapacity(3);
names.add("张三");
names.add("李四");
names.add("王五");
System.out.println("Names:"+names);
//Names:[张三, 李四, 王五]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
public void forEach​(Consumer<? super E> action)
  • 功能:对Iterable每个元素执行给定操作,直到处理Iterable所有元素或操作引发异常。 如果指定了该顺序,则按迭代顺序执行操作。没有返回值,原数组内容不变
//将lamda表达式传递给forEach
names.forEach((e)->{
    e = e + "是傻子";
    System.out.println(e);
});
// 张三是傻子
// 李四是傻子
// 王五是傻子
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
public E get​(int index)
  • 功能:返回此列表中指定位置的元素
System.out.println(names.get(2));
//王五
  • 1
  • 2
public int indexOf​(Object o)
  • 功能:返回此列表中第一次出现的指定元素的索引,如果此列表不包含该元素,则返回-1。
System.out.println(names.indexOf("王五"));
//2
System.out.println(names.indexOf("赵六"));
//-1
  • 1
  • 2
  • 3
  • 4
  • 类似的 public int lastIndexOf​(Object o)
public boolean isEmpty()
  • 功能:判断数组是否为空
ArrayList<String> names1 = new ArrayList<>();
System.out.println(names1.isEmpty());
//true
  • 1
  • 2
  • 3
public Iterator<E> iterator()
  • 返回迭代器
Iterator<String> iterator = names.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());
}
  • 1
  • 2
  • 3
  • 4
public E set​(int index, E element)
  • 用指定的元素替换此列表中指定位置的元素。
//data = [100, 99, 98, 97, 96, 95]

data.set(2,250);
System.out.println(data);
//[100, 99, 250, 97, 96, 95]
  • 1
  • 2
  • 3
  • 4
  • 5
public int size()
  • 返回此列表中的有效元素数
System.out.println(data.size());
  • 1
public List<E> subList​(int fromIndex, int toIndex)
  • 返回指定的fromIndex (包含)和toIndex (独占)之间的此列表部分的视图。 (如果fromIndex和toIndex相等,则返回的列表为空。)返回的列表由此列表支持,因此返回列表中的非结构更改将反映在此列表中,反之亦然。 返回的列表支持所有可选的列表操作
//data = [100, 99, 98, 97, 96, 95]
List<Integer> data1 = data.subList(2, data.size());
System.out.println(data1);
//[98, 97, 96, 95]
  • 1
  • 2
  • 3
  • 4
public Object[] toArray()
  • 以适当的顺序(从第一个元素到最后一个元素)返回包含此列表中所有元素的数组。
//data = [100, 99, 98, 97, 96, 95]
Object[] it = data.toArray();
System.out.println(Arrays.toString(it));
//[100, 99, 98, 97, 96, 95]
  • 1
  • 2
  • 3
  • 4
public <T> T[] toArray​(T[] a)
  • 以适当的顺序返回包含此列表中所有元素的数组(从第一个元素到最后一个元素); 返回数组的运行时类型是指定数组的运行时类型。
Integer[] it = new Integer[(data.size())];
data.toArray(it);
System.out.println(Arrays.toString(it));
//[100, 99, 98, 97, 96, 95]
  • 1
  • 2
  • 3
  • 4
public void trimToSize()
  • 将此ArrayList实例的容量调整为列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/77260
推荐阅读
相关标签
  

闽ICP备14008679号