当前位置：移动技术网 > IT编程>开发语言>Java > Java容器ArrayList知识点总结

Java容器ArrayList知识点总结

2019年07月19日 | 移动技术网IT编程 | 我要评论

袁海贝贝,捷尔泰,儿歌大全串烧

arraylist

底层实现是数组，访问元素效率高 (查询快，插入、修改、删除元素慢)

与linkedlist相比，它效率高，但线程不安全。

arraylist数组是一个可变数组，可以存取包括null在内的所有元素

每个arraylist实例都有一个容量，该容量是指用来存储列表元素的数组的大小
随着向arraylist中不断增加元素，其容量自动增长
在添加大量元素前，应用程序也可以使用ensurecapacity操作来增加arraylist实例的容量，这样可以减少递增式再分配的数量。
所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多进行扩容操作而浪费时间、效率
源码分析

底层使用数组实现

transient object[] elementdata;

构造方法

private static final int default_capacity = 10;
private static final object[] empty_elementdata = {};
private static final object[] defaultcapacity_empty_elementdata = {};
transient object[] elementdata;
private int size;
 
// 构造一个空列表
public arraylist() {
    this.elementdata = defaultcapacity_empty_elementdata ;
  }
 
// 构造一个指定初始容量的空列表
public arraylist(int initialcapacity) {
    if (initialcapacity > 0) {
      this.elementdata = new object[initialcapacity];
    } else if (initialcapacity == 0) {
      this.elementdata = empty_elementdata;
    } else {
      throw new illegalargumentexception("illegal capacity: "+
                        initialcapacity);
    }
  }
 
 
// 构造一个指定collection元素的列表，这些元素按照connection元素的迭代返回顺序进行排列
public arraylist(collection<? extends e> c) {
    elementdata = c.toarray();
    if ((size = elementdata.length) != 0) {
      // c.toarray might (incorrectly) not return object[] (see 6260652)
      if (elementdata.getclass() != object[].class)
        elementdata = arrays.copyof(elementdata, size, object[].class);
    } else {
      // replace with empty array.
      this.elementdata = empty_elementdata;
    }
  }

存储

// 在列表的指定位置的元素用element替代，并且返回该位置原来的元素
public e set(int index, e element) {
    rangecheck(index); // 检查数组容量，抛出：indexoutofboundsexception
 
    e oldvalue = elementdata(index);
    elementdata[index] = element;
    return oldvalue;
  }
 
// 在列表的尾部添加指定元素
public boolean add(e e) {
    ensurecapacityinternal(size + 1); // 数组扩容
    elementdata[size++] = e;
    return true;
  }
 
// 在列表的指定位置添加元素
public void add(int index, e element) {
    rangecheckforadd(index);
 
    ensurecapacityinternal(size + 1); // increments modcount!!
 
    // src:源数组,srcpro:源数组中的起始位置
    // dest:目标数组，destpost:目标数组的起始位置，length:要复制的数组元素数量
       // 将当前位于该位置的元素以及所有后续元素后移一个位置
    system.arraycopy(elementdata, index, elementdata, index + 1,
             size - index);
    // 用element替换index位置的元素
    elementdata[index] = element;
    size++;
  }
 
// 在列表的尾部添加connection中的元素，元素顺序按照connection迭代器返回的顺序
public boolean addall(collection<? extends e> c) {
    object[] a = c.toarray(); // 转化为一个数组
 
    int numnew = a.length;
    ensurecapacityinternal(size + numnew); // increments modcount
 
    // increments modcount!!
    system.arraycopy(a, 0, elementdata, size, numnew);
    size += numnew;
    return numnew != 0;
  }
 
// 在列表的指定位置添加connection中的元素，元素顺序按照connection迭代器返回的顺序
public boolean addall(int index, collection<? extends e> c) {
    rangecheckforadd(index);
 
    object[] a = c.toarray();
    int numnew = a.length;
    ensurecapacityinternal(size + numnew); // increments modcount
 
    int nummoved = size - index;
    if (nummoved > 0)
      system.arraycopy(elementdata, index, elementdata, index + numnew,
               nummoved);
 
    system.arraycopy(a, 0, elementdata, index, numnew);
    size += numnew;
    return numnew != 0;
  }

读取

// 移除此列表指定位置上的元素
public e remove(int index) {
    rangecheck(index);
 
    modcount++;
    e oldvalue = elementdata(index);
 
    int nummoved = size - index - 1;
    if (nummoved > 0)
      system.arraycopy(elementdata, index+1, elementdata, index,
               nummoved);
    elementdata[--size] = null; // clear to let gc do its work
 
    return oldvalue;
  }
 
// 移除此列表中的某个元素
public boolean remove(object o) {
    if (o == null) {
      for (int index = 0; index < size; index++)
        if (elementdata[index] == null) {
          fastremove(index);
          return true;
        }
    } else {
      for (int index = 0; index < size; index++)
        if (o.equals(elementdata[index])) {
          fastremove(index);
          return true;
        }
    }
    return false;
  }
 
private void fastremove(int index) {
    modcount++;
    int nummoved = size - index - 1;
    if (nummoved > 0)
      system.arraycopy(elementdata, index+1, elementdata, index,
               nummoved);
    elementdata[--size] = null; // clear to let gc do its work
  }

数组扩容

每当向数组中添加元素时，都需要去检查添加元素后元素的个数是否超出当前数组的长度，如果超出，数组将会进行扩容，以满足添加数据的需求。

public void ensurecapacity(int mincapacity) {
    int minexpand = (elementdata != defaultcapacity_empty_elementdata )   
      ? 0 : default_capacity;
 
    if (mincapacity > minexpand) {
      ensureexplicitcapacity(mincapacity);
    }
  }
 
private void ensurecapacityinternal(int mincapacity) {
    if (elementdata == defaultcapacity_empty_elementdata ) {
      mincapacity = math.max(default_capacity, mincapacity);
    }
 
    ensureexplicitcapacity(mincapacity);
  }
 
private void ensureexplicitcapacity(int mincapacity) {
    modcount++;
 
    // overflow-conscious code
    if (mincapacity - elementdata.length > 0)
      grow(mincapacity);
  }
 
private void grow(int mincapacity) {
    // overflow-conscious code
    int oldcapacity = elementdata.length;
    int newcapacity = oldcapacity + (oldcapacity >> 1);
    if (newcapacity - mincapacity < 0)
      newcapacity = mincapacity;
    if (newcapacity - max_array_size > 0)
      newcapacity = hugecapacity(mincapacity);
    // mincapacity is usually close to size, so this is a win:
    elementdata = arrays.copyof(elementdata, newcapacity);
  }
 
private static int hugecapacity(int mincapacity) {
    if (mincapacity < 0) // overflow
      throw new outofmemoryerror();
    return (mincapacity > max_array_size) ?
      integer.max_value :
      max_array_size;
  }

手写arraylist

public class myarraylist /*implements list<e>*/{
 private transient object[] elementdata;
 private int size; //元素个数
 
 public myarraylist(){
  this(10);
 }
 
 public myarraylist(int initialcapacity) {
  if (initialcapacity<0) {
   try {
    throw new exception();
   } catch (exception e) {
    e.printstacktrace();
   }
  }
  elementdata = new object[initialcapacity];
 }
 
 public int size() {
  return size;
 }
 
 public boolean isempty(){
  return size == 0;
 }
 //根据index删掉对象
 public void remove(int index) throws exception {
  rangecheck(index);
  int nummoved = size-index-1;
  if (nummoved > 0) {
   system.arraycopy(elementdata, index+1, elementdata, index, nummoved);
  }
  elementdata[--size] = null;
 }
 //删掉对象
 public boolean remove(object obj) throws exception {
  for (int i = 0; i < size; i++) {
   if (get(i).equals(obj)) {
    remove(i);
   }
   return true;
  }
  return true;
 }
 //修改元素
 public object set(int index , object obj ) throws exception{
  rangecheck(index);
  object oldvalue = elementdata[index];
  elementdata[index] = obj;
  return oldvalue;
 }
 //在指定位置插入元素
 public void add(int index,object obj) throws exception {
  rangecheck(index);
  ensurecapacity();
  system.arraycopy(elementdata, index, elementdata, index+1, size-index);
  elementdata[index] = obj;
  size ++;
 }
 public void add(object object) {
  ensurecapacity();
  /*elementdata[size] = object;
  size ++;*/
  elementdata[size++] = object; //先赋值，后自增
 }
 
 public object get(int index) throws exception {
  rangecheck(index);
  return elementdata[index];
 }
 public void rangecheck(int index) throws exception {
  if (index<0 || index >=size) {
   throw new exception();
  }
 }
 //扩容
 public void ensurecapacity() {
  //数组扩容和内容拷贝
  if (size==elementdata.length) {
   //elementdata = new object[size*2+1]; 这么写原来数组里的内容丢失
   object[] newarray = new object[size*2+1];
   //拷贝数组里的内容
   /*for (int i = 0; i < newarray.length; i++) {
    newarray[i] = elementdata[i];
   }*/
   system.arraycopy(elementdata, 0, newarray, 0, elementdata.length);
   elementdata = newarray;
  }
 }
 // 测试
 public static void main(string[] args) {
  myarraylist myarraylist = new myarraylist(3);
  myarraylist.add("111");
  myarraylist.add("222");
  myarraylist.add("333");
  myarraylist.add("444");
  myarraylist.add("555");
  
  try {
   myarraylist.remove(2);
   myarraylist.add(3, "新值");
   myarraylist.set(1, "修改");
  } catch (exception e1) {
   // todo auto-generated catch block
   e1.printstacktrace();
  }
  system.out.println(myarraylist.size());
  for (int i = 0; i < myarraylist.size(); i++) {
   try {
    system.out.println(myarraylist.get(i));
   } catch (exception e) {
    e.printstacktrace();
   }
  }
 }
}

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！点击进行留言回复

快速了解JAVA中的Random()函数

java中存在着两种random函数：一、java.lang.math.random;　　调用这个math.random()函数能够返回带正号的double值，... [阅读全文]
JAVA.io读写文件方式汇总

一、java把这些不同来源和目标的数据都统一抽象为数据流。　　java语言的输入输出功能是十分强大而灵活的。　　在java类库中，io部分的内容是很庞大的，因为... [阅读全文]
SpringBoot加载应用事件监听器代码实例

利用 spring 工厂加载机制，实例化 applicationlistener 实现类，并排序对象集合创建应用事件监听器创建类实现接口applicationl... [阅读全文]
详解JAVA中接口的定义和接口的实现

1.接口的定义使用interface来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。定义接口的基本... [阅读全文]
SpringBoot上下文初始器加载过程详解

利用 spring 工厂加载机制，实例化 applicationcontextinitializer 实现类，并排序对象集合。关键方法private <t... [阅读全文]
深入了解JAVA Jersey框架

java jersey的详情概述jersey是一个restful请求服务java框架，与常规的java编程使用的struts框架类似，它主要用于处理业务逻辑层。... [阅读全文]
apollo与springboot集成实现动态刷新配置的教程详解

分布式apollo简介apollo（阿波罗）是携程框架部门研发的开源配置管理中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并... [阅读全文]
SpringBoot基于Shiro处理ajax请求代码实例

写一个shiro的过滤器import cn.erika.demo.common.model.vo.message;import com.alibaba.fast... [阅读全文]
如何在JAVA中使用Synchronized

《编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程》一文详细讲述了线程、进程的关系及在操作系统中的表现，这是多线程学习必须了解的基础。本文将接着... [阅读全文]
Java静态泛型使用方法实例解析

前言：当工具类对多个模型类进行排序，比较等操作的时候，需要书写大量重复代码，因为懒人总要想怎么省事的，所以考虑使用泛型这个玩意简化代码案例：当前存在两个模型类，... [阅读全文]

网友评论


验证码：

Java容器ArrayList知识点总结

2019年07月19日 | 移动技术网IT编程 | 我要评论

您可能感兴趣的文章:

相关文章:

网友评论