diff --git "a/Java\347\233\270\345\205\263/ArrayList.md" "b/Java\347\233\270\345\205\263/ArrayList.md" new file mode 100644 index 0000000000000000000000000000000000000000..e459c4775281e27ebb946e5395245df1c644b2f6 --- /dev/null +++ "b/Java\347\233\270\345\205\263/ArrayList.md" @@ -0,0 +1,727 @@ +### **目录：** + 0-0-1. 前言 + 0-0-2. 集合框架知识回顾 +0-0-3. ArrayList简介 +0-0-4. ArrayList核心源码 + 0-0-5. ArrayList源码剖析 + 0-0-6. ArrayList经典Demo + +### **前言：** + 　　这篇文章，其实几天前就已经在图书馆写出来了，不过手一抖几个删除键就都没有了，所以一直拖到了现在。这篇文章在分析ArrayList的时候对ArrayList源码中用到的比较好的语法也会作以陈述。希望通过这篇文章可以让你从本质上认识ArrayList，笔者愚笨，如若遇到错误敬请告知。 +### **集合框架知识回顾：** +**总体知识脉络** +![集合框架](https://ws1.sinaimg.cn/large/006rNwoDgy1flk1g7h1lzj318a0sjac8.jpg) +### **ArrayList简介：** +　　ArrayList 的底层是数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。它继承于**AbstractList**，实现了**List**, **RandomAccess**, **Cloneable**, **java.io.Serializable**这些接口。 + 　　在我们学数据结构的时候就知道了线性表的顺序存储，插入删除元素的时间复杂度为**O（n）**,求表长以及增加元素，取第 i 元素的时间复杂度为**O（1）** +　　ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。 +　　ArrayList 实现了**RandmoAccess接口**，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供**快速访问功能**的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。 +　　ArrayList 实现了**Cloneable接口**，即覆盖了函数clone()，**能被克隆**。 +　　ArrayList 实现**java.io.Serializable接口**，这意味着ArrayList**支持序列化**，**能通过序列化去传输**。 +　　和Vector不同，**ArrayList中的操作不是线程安全的**！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。 +### **ArrayList核心源码：** +```java +package java.util; + +import java.util.function.Consumer; +import java.util.function.Predicate; +import java.util.function.UnaryOperator; + + +public class ArrayList extends AbstractList + implements List, RandomAccess, Cloneable, java.io.Serializable +{ + private static final long serialVersionUID = 8683452581122892189L; + + /** + * 默认初始容量大小 + */ + private static final int DEFAULT_CAPACITY = 10; + + /** + * 空数组（用于空实例）。 + */ + private static final Object[] EMPTY_ELEMENTDATA = {}; + + //用于默认大小空实例的共享空数组实例。 + //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。 + private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; + + /** + * 保存ArrayList数据的数组 + */ + transient Object[] elementData; // non-private to simplify nested class access + + /** + * ArrayList 所包含的元素个数 + */ + private int size; + + /** + * 带初始容量参数的构造函数。（用户自己指定容量） + */ + public ArrayList(int initialCapacity) { + if (initialCapacity > 0) { + //创建initialCapacity大小的数组 + this.elementData = new Object[initialCapacity]; + } else if (initialCapacity == 0) { + //创建空数组 + this.elementData = EMPTY_ELEMENTDATA; + } else { + throw new IllegalArgumentException("Illegal Capacity: "+ + initialCapacity); + } + } + + /** + *默认构造函数，其默认初始容量为10 + */ + public ArrayList() { + this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; + } + + /** + * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。 + */ + public ArrayList(Collection c) { + // + elementData = c.toArray(); + //如果指定集合元素个数不为0 + if ((size = elementData.length) != 0) { + // c.toArray 可能返回的不是Object类型的数组所以加上下面的语句用于判断， + //这里用到了反射里面的getClass()方法 + if (elementData.getClass() != Object[].class) + elementData = Arrays.copyOf(elementData, size, Object[].class); + } else { + // 用空数组代替 + this.elementData = EMPTY_ELEMENTDATA; + } + } + + /** + * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。 + */ + public void trimToSize() { + modCount++; + if (size < elementData.length) { + elementData = (size == 0) + ? EMPTY_ELEMENTDATA + : Arrays.copyOf(elementData, size); + } + } +//下面是ArrayList的扩容机制 +//ArrayList的扩容机制提高了性能，如果每次只扩充一个， +//那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。 + /** + * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量 + * @param minCapacity 所需的最小容量 + */ + public void ensureCapacity(int minCapacity) { + int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) + // any size if not default element table + ? 0 + // larger than default for default empty table. It's already + // supposed to be at default size. + : 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方法进行扩容，调用此方法代表已经开始扩容了 + grow(minCapacity); + } + + /** + * 要分配的最大数组大小 + */ + private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; + + /** + * ArrayList扩容的核心方法。 + */ + private void grow(int minCapacity) { + // oldCapacity为旧容量，newCapacity为新容量 + int oldCapacity = elementData.length; + //将oldCapacity 右移一位，其效果相当于oldCapacity /2， + //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍， + int newCapacity = oldCapacity + (oldCapacity >> 1); + //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量， + if (newCapacity - minCapacity < 0) + newCapacity = minCapacity; + //再检查新容量是否超出了ArrayList所定义的最大容量， + //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE， + //如果minCapacity大于最大容量，则新容量则为ArrayList定义的最大容量，否则，新容量大小则为 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); + } + //比较minCapacity和 MAX_ARRAY_SIZE + private static int hugeCapacity(int minCapacity) { + if (minCapacity < 0) // overflow + throw new OutOfMemoryError(); + return (minCapacity > MAX_ARRAY_SIZE) ? + Integer.MAX_VALUE : + MAX_ARRAY_SIZE; + } + + /** + *返回此列表中的元素数。 + */ + public int size() { + return size; + } + + /** + * 如果此列表不包含元素，则返回 true 。 + */ + public boolean isEmpty() { + //注意=和==的区别 + return size == 0; + } + + /** + * 如果此列表包含指定的元素，则返回true 。 + */ + public boolean contains(Object o) { + //indexOf()方法：返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1 + return indexOf(o) >= 0; + } + + /** + *返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1 + */ + public int indexOf(Object o) { + if (o == null) { + for (int i = 0; i < size; i++) + if (elementData[i]==null) + return i; + } else { + for (int i = 0; i < size; i++) + //equals()方法比较 + if (o.equals(elementData[i])) + return i; + } + return -1; + } + + /** + * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。. + */ + public int lastIndexOf(Object o) { + if (o == null) { + for (int i = size-1; i >= 0; i--) + if (elementData[i]==null) + return i; + } else { + for (int i = size-1; i >= 0; i--) + if (o.equals(elementData[i])) + return i; + } + return -1; + } + + /** + * 返回此ArrayList实例的浅拷贝。 （元素本身不被复制。） + */ + public Object clone() { + try { + ArrayList v = (ArrayList) super.clone(); + //Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度 + v.elementData = Arrays.copyOf(elementData, size); + v.modCount = 0; + return v; + } catch (CloneNotSupportedException e) { + // 这不应该发生，因为我们是可以克隆的 + throw new InternalError(e); + } + } + + /** + *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。 + *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。 + *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。 + */ + public Object[] toArray() { + return Arrays.copyOf(elementData, size); + } + + /** + * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; + *返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。 + *否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。 + *如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。 + *（这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。） + */ + @SuppressWarnings("unchecked") + public T[] toArray(T[] a) { + if (a.length < size) + // 新建一个运行时类型的数组，但是ArrayList数组的内容 + return (T[]) Arrays.copyOf(elementData, size, a.getClass()); + //调用System提供的arraycopy()方法实现数组之间的复制 + System.arraycopy(elementData, 0, a, 0, size); + if (a.length > size) + a[size] = null; + return a; + } + + // Positional Access Operations + + @SuppressWarnings("unchecked") + E elementData(int index) { + return (E) elementData[index]; + } + + /** + * 返回此列表中指定位置的元素。 + */ + public E get(int index) { + rangeCheck(index); + + return elementData(index); + } + + /** + * 用指定的元素替换此列表中指定位置的元素。 + */ + public E set(int index, E element) { + //对index进行界限检查 + rangeCheck(index); + + E oldValue = elementData(index); + elementData[index] = element; + //返回原来在这个位置的元素 + return oldValue; + } + + /** + * 将指定的元素追加到此列表的末尾。 + */ + public boolean add(E e) { + ensureCapacityInternal(size + 1); // Increments modCount!! + //这里看到ArrayList添加元素的实质就相当于为数组赋值 + elementData[size++] = e; + return true; + } + + /** + * 在此列表中的指定位置插入指定的元素。 + *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大； + *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。 + */ + public void add(int index, E element) { + rangeCheckForAdd(index); + + ensureCapacityInternal(size + 1); // Increments modCount!! + //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己 + System.arraycopy(elementData, index, elementData, index + 1, + size - index); + elementData[index] = element; + size++; + } + + /** + * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。 + */ + 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; + } + + /** + * 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。 + *返回true，如果此列表包含指定的元素 + */ + 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 remove method that skips bounds checking and does not + * return the value removed. + */ + 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 clear() { + modCount++; + + // 把数组中所有的元素的值设为null + for (int i = 0; i < size; i++) + elementData[i] = null; + + size = 0; + } + + /** + * 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。 + */ + public boolean addAll(Collection c) { + Object[] a = c.toArray(); + int numNew = a.length; + ensureCapacityInternal(size + numNew); // Increments modCount + System.arraycopy(a, 0, elementData, size, numNew); + size += numNew; + return numNew != 0; + } + + /** + * 将指定集合中的所有元素插入到此列表中，从指定的位置开始。 + */ + public boolean addAll(int index, Collection 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; + } + + /** + * 从此列表中删除所有索引为fromIndex （含）和toIndex之间的元素。 + *将任何后续元素移动到左侧（减少其索引）。 + */ + protected void removeRange(int fromIndex, int toIndex) { + modCount++; + int numMoved = size - toIndex; + System.arraycopy(elementData, toIndex, elementData, fromIndex, + numMoved); + + // clear to let GC do its work + int newSize = size - (toIndex-fromIndex); + for (int i = newSize; i < size; i++) { + elementData[i] = null; + } + size = newSize; + } + + /** + * 检查给定的索引是否在范围内。 + */ + private void rangeCheck(int index) { + if (index >= size) + throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); + } + + /** + * add和addAll使用的rangeCheck的一个版本 + */ + private void rangeCheckForAdd(int index) { + if (index > size || index < 0) + throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); + } + + /** + * 返回IndexOutOfBoundsException细节信息 + */ + private String outOfBoundsMsg(int index) { + return "Index: "+index+", Size: "+size; + } + + /** + * 从此列表中删除指定集合中包含的所有元素。 + */ + public boolean removeAll(Collection c) { + Objects.requireNonNull(c); + //如果此列表被修改则返回true + return batchRemove(c, false); + } + + /** + * 仅保留此列表中包含在指定集合中的元素。 + *换句话说，从此列表中删除其中不包含在指定集合中的所有元素。 + */ + public boolean retainAll(Collection c) { + Objects.requireNonNull(c); + return batchRemove(c, true); + } + + + /** + * 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。 + *指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。 + *返回的列表迭代器是fail-fast 。 + */ + public ListIterator listIterator(int index) { + if (index < 0 || index > size) + throw new IndexOutOfBoundsException("Index: "+index); + return new ListItr(index); + } + + /** + *返回列表中的列表迭代器（按适当的顺序）。 + *返回的列表迭代器是fail-fast 。 + */ + public ListIterator listIterator() { + return new ListItr(0); + } + + /** + *以正确的顺序返回该列表中的元素的迭代器。 + *返回的迭代器是fail-fast 。 + */ + public Iterator iterator() { + return new Itr(); + } + + +``` +### **ArrayList源码分析：** +##### **System.arraycopy()和Arrays.copyOf()方法** +　　通过上面源码我们发现这两个实现数组复制的方法被广泛使用而且很多地方都特别巧妙。比如下面add(int index, E element)方法就很巧妙的用到了arraycopy()方法让数组自己复制自己实现让index开始之后的所有成员后移一个位置: +```java + /** + * 在此列表中的指定位置插入指定的元素。 + *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大； + *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。 + */ + public void add(int index, E element) { + rangeCheckForAdd(index); + + ensureCapacityInternal(size + 1); // Increments modCount!! + //arraycopy()方法实现数组自己复制自己 + //elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量； + System.arraycopy(elementData, index, elementData, index + 1, size - index); + elementData[index] = element; + size++; + } +``` +又如toArray()方法中用到了copyOf()方法 +```java + + /** + *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。 + *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。 + *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。 + */ + public Object[] toArray() { + //elementData：要复制的数组；size：要复制的长度 + return Arrays.copyOf(elementData, size); + } +``` +##### **两者联系与区别：** +**联系：** +看两者源代码可以发现copyOf()内部调用了System.arraycopy()方法 +**区别：** +1，arraycopy()需要目标数组，将原数组拷贝到你自己定义的数组里，而且可以选择拷贝的起点和长度以及放入新数组中的位置 +2，copyOf()是系统自动在内部新建一个数组，并返回该数组。 +#### **ArrayList核心扩容技术** +```java +//下面是ArrayList的扩容机制 +//ArrayList的扩容机制提高了性能，如果每次只扩充一个， +//那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。 + /** + * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量 + * @param minCapacity 所需的最小容量 + */ + public void ensureCapacity(int minCapacity) { + int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) + // any size if not default element table + ? 0 + // larger than default for default empty table. It's already + // supposed to be at default size. + : 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++; + + // 如果说minCapacity也就是所需的最小容量大于保存ArrayList数据的数组的长度的话，就需要调用grow(minCapacity)方法扩容。 + //这个minCapacity到底为多少呢？举个例子在添加元素(add)方法中这个minCapacity的大小就为现在数组的长度加1 + if (minCapacity - elementData.length > 0) + //调用grow方法进行扩容，调用此方法代表已经开始扩容了 + grow(minCapacity); + } + +``` +```java + /** + * ArrayList扩容的核心方法。 + */ + private void grow(int minCapacity) { + //elementData为保存ArrayList数据的数组 + ///elementData.length求数组长度elementData.size是求数组中的元素个数 + // oldCapacity为旧容量，newCapacity为新容量 + int oldCapacity = elementData.length; + //将oldCapacity 右移一位，其效果相当于oldCapacity /2， + //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍， + int newCapacity = oldCapacity + (oldCapacity >> 1); + //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量， + if (newCapacity - minCapacity < 0) + newCapacity = minCapacity; + //再检查新容量是否超出了ArrayList所定义的最大容量， + //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE， + //如果minCapacity大于最大容量，则新容量则为ArrayList定义的最大容量，否则，新容量大小则为 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); + } + +``` +　　扩容机制代码已经做了详细的解释。另外值得注意的是大家很容易忽略的一个运算符：**移位运算符** +　　**简介**：移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种:<<(左移)、>>(带符号右移)和>>>(无符号右移)。 +　　**作用**：**对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源** +　　比如这里：int newCapacity = oldCapacity + (oldCapacity >> 1); +右移一位相当于除2，右移n位相当于除以2的n次方。这里oldCapacity 明显右移了1位所以相当于oldCapacity /2。 + +**另外需要注意的是：** + +1. java中的**length属性**是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了length这个属性. + +2. java中的**length()方法**是针对字 符串String说的,如果想看这个字符串的长度则用到length()这个方法. + +3. .java中的**size()方法**是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看! + + +#### **内部类** +```java + (1)private class Itr implements Iterator + (2)private class ListItr extends Itr implements ListIterator + (3)private class SubList extends AbstractList implements RandomAccess + (4)static final class ArrayListSpliterator implements Spliterator +``` +　　ArrayList有四个内部类，其中的**Itr是实现了Iterator接口**，同时重写了里面的**hasNext()**，**next()**，**remove()**等方法；其中的**ListItr**继承**Itr**，实现了**ListIterator接口**，同时重写了**hasPrevious()**，**nextIndex()**，**previousIndex()**，**previous()**，**set(E e)**，**add(E e)**等方法，所以这也可以看出了**Iterator和ListIterator的区别:**ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。具体可以参考http://blog.csdn.net/a597926661/article/details/7679765。其中的**SubList继承AbstractList，实现了RandmAccess接口**，类内部实现了对子序列的增删改查等方法，但它同时也充分利用了内部类的优点，就是共享ArrayList的全局变量，例如检查器变量modCount，数组elementData等，所以SubList进行的增删改查操作都是对ArrayList的数组进行的，并没有创建新的数组。(内部类这里参考了这位老兄的博客http://blog.csdn.net/ljcitworld/article/details/52041836) +### **ArrayList经典Demo：** + +```java +package list; +import java.util.ArrayList; +import java.util.Iterator; + +public class ArrayListDemo { + + public static void main(String[] srgs){ + ArrayList arrayList = new ArrayList(); + + System.out.printf("Before add:arrayList.size() = %d\n",arrayList.size()); + + arrayList.add(1); + arrayList.add(3); + arrayList.add(5); + arrayList.add(7); + arrayList.add(9); + System.out.printf("After add:arrayList.size() = %d\n",arrayList.size()); + + System.out.println("Printing elements of arrayList"); + // 三种遍历方式打印元素 + // 第一种：通过迭代器遍历 + System.out.print("通过迭代器遍历:"); + Iterator it = arrayList.iterator(); + while(it.hasNext()){ + System.out.print(it.next() + " "); + } + System.out.println(); + + // 第二种：通过索引值遍历 + System.out.print("通过索引值遍历:"); + for(int i = 0; i < arrayList.size(); i++){ + System.out.print(arrayList.get(i) + " "); + } + System.out.println(); + + // 第三种：for循环遍历 + System.out.print("for循环遍历:"); + for(Integer number : arrayList){ + System.out.print(number + " "); + } + + // toArray用法 + // 第一种方式(最常用) + Integer[] integer = arrayList.toArray(new Integer[0]); + + // 第二种方式(容易理解) + Integer[] integer1 = new Integer[arrayList.size()]; + arrayList.toArray(integer1); + + // 抛出异常，java不支持向下转型 + //Integer[] integer2 = new Integer[arrayList.size()]; + //integer2 = arrayList.toArray(); + System.out.println(); + + // 在指定位置添加元素 + arrayList.add(2,2); + // 删除指定位置上的元素 + arrayList.remove(2); + // 删除指定元素 + arrayList.remove((Object)3); + // 判断arrayList是否包含5 + System.out.println("ArrayList contains 5 is: " + arrayList.contains(5)); + + // 清空ArrayList + arrayList.clear(); + // 判断ArrayList是否为空 + System.out.println("ArrayList is empty: " + arrayList.isEmpty()); + } +} +``` + diff --git "a/Java\347\233\270\345\205\263/HashMap.md" "b/Java\347\233\270\345\205\263/HashMap.md" new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git "a/Java\347\233\270\345\205\263/Java IO\344\270\216NIO.md" "b/Java\347\233\270\345\205\263/Java IO\344\270\216NIO.md" index 365c3ab425b0b00d3a9a3c68e0b3fd16fb5a1053..1e608da591b43c9f04813dac03fb47bfaf3d0bc2 100644 --- "a/Java\347\233\270\345\205\263/Java IO\344\270\216NIO.md" +++ "b/Java\347\233\270\345\205\263/Java IO\344\270\216NIO.md" @@ -1,10 +1,30 @@ + -Java面试通关手册（Java学习指南） Github地址：[https://github.com/Snailclimb/Java_Guide](https://github.com/Snailclimb/Java_Guide) -> # IO流学习总结 +- [IO流学习总结](#io流学习总结) + - [一　Java IO，硬骨头也能变软](#一-java-io，硬骨头也能变软) + - [二　java IO体系的学习总结](#二-java-io体系的学习总结) + - [三　Java IO面试题](#三-java-io面试题) +- [NIO与AIO学习总结](#nio与aio学习总结) + - [一 Java NIO 概览](#一-java-nio-概览) + - [二 Java NIO 之 Buffer\(缓冲区\)](#二-java-nio-之-buffer缓冲区) + - [三 Java NIO 之 Channel（通道）](#三-java-nio-之-channel（通道）) + - [四 Java NIO之Selector（选择器）](#四-java-nio之selector（选择器）) + - [五 Java NIO之拥抱Path和Files](#五-java-nio之拥抱path和files) + - [六 NIO学习总结以及NIO新特性介绍](#六-nio学习总结以及nio新特性介绍) + - [七 Java NIO AsynchronousFileChannel异步文件通](#七-java-nio-asynchronousfilechannel异步文件通) + - [八 高并发Java（8）：NIO和AIO](#八-高并发java（8）：nio和aio) +- [推荐阅读](#推荐阅读) + - [在 Java 7 中体会 NIO.2 异步执行的快乐](#在-java-7-中体会-nio2-异步执行的快乐) + - [Java AIO总结与示例](#java-aio总结与示例) + + + + + +## IO流学习总结 ### [一　Java IO，硬骨头也能变软](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483981&idx=1&sn=6e5c682d76972c8d2cf271a85dcf09e2&chksm=fd98542ccaefdd3a70428e9549bc33e8165836855edaa748928d16c1ebde9648579d3acaac10#rd) -### 主要内容： **（1） 按操作方式分类结构图：** ![按操作方式分类结构图：](https://user-gold-cdn.xitu.io/2018/5/16/16367d4fd1ce1b46?w=720&h=1080&f=jpeg&s=69522) @@ -29,12 +49,11 @@ Java面试通关手册（Java学习指南） Github地址：[https://github.com/ ### [三　Java IO面试题](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483985&idx=1&sn=38531c2cee7b87f125df7aef41637014&chksm=fd985430caefdd26b0506aa84fc26251877eccba24fac73169a4d6bd1eb5e3fbdf3c3b940261#rd) -> # NIO学习总结 +## NIO与AIO学习总结 -### [一　Java NIO 概览](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483956&idx=1&sn=57692bc5b7c2c6dfb812489baadc29c9&chksm=fd985455caefdd4331d828d8e89b22f19b304aa87d6da73c5d8c66fcef16e4c0b448b1a6f791#rd) +### [一 Java NIO 概览](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483956&idx=1&sn=57692bc5b7c2c6dfb812489baadc29c9&chksm=fd985455caefdd4331d828d8e89b22f19b304aa87d6da73c5d8c66fcef16e4c0b448b1a6f791#rd) -### 主要内容: 1. **NIO简介**: Java NIO 是 java 1.4, 之后新出的一套IO接口NIO中的N可以理解为Non-blocking，不单纯是New。 @@ -54,9 +73,8 @@ Java面试通关手册（Java学习指南） Github地址：[https://github.com/ - **Selectors** -### [二　Java NIO 之 Buffer(缓冲区)](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483961&idx=1&sn=f67bef4c279e78043ff649b6b03fdcbc&chksm=fd985458caefdd4e3317ccbdb2d0a5a70a5024d3255eebf38183919ed9c25ade536017c0a6ba#rd) +### [二 Java NIO 之 Buffer(缓冲区)](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483961&idx=1&sn=f67bef4c279e78043ff649b6b03fdcbc&chksm=fd985458caefdd4e3317ccbdb2d0a5a70a5024d3255eebf38183919ed9c25ade536017c0a6ba#rd) -### 主要内容: 1. **Buffer(缓冲区)介绍:** - Java NIO Buffers用于和NIO Channel交互。 我们从Channel中读取数据到buffers里，从Buffer把数据写入到Channels； - Buffer本质上就是一块内存区； @@ -89,8 +107,8 @@ Java面试通关手册（Java学习指南） Github地址：[https://github.com/ 说实话，NIO编程真的难，通过后面这个测试例子，你可能才能勉强理解前面说的Buffer方法的作用。 -### [三　Java NIO 之 Channel（通道）](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483966&idx=1&sn=d5cf18c69f5f9ec2aff149270422731f&chksm=fd98545fcaefdd49296e2c78000ce5da277435b90ba3c03b92b7cf54c6ccc71d61d13efbce63#rd) -### 主要内容: +### [三 Java NIO 之 Channel（通道）](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483966&idx=1&sn=d5cf18c69f5f9ec2aff149270422731f&chksm=fd98545fcaefdd49296e2c78000ce5da277435b90ba3c03b92b7cf54c6ccc71d61d13efbce63#rd) + 1. **Channel（通道）介绍** - 通常来说NIO中的所有IO都是从 Channel（通道） 开始的。 @@ -107,8 +125,8 @@ Java面试通关手册（Java学习指南） Github地址：[https://github.com/ - transferTo() :transferTo方法把FileChannel数据传输到另一个channel -### [四　Java NIO之Selector（选择器）](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483970&idx=1&sn=d5e2b133313b1d0f32872d54fbdf0aa7&chksm=fd985423caefdd354b587e57ce6cf5f5a7bec48b9ab7554f39a8d13af47660cae793956e0f46#rd) -### 主要内容: +### [四 Java NIO之Selector（选择器）](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483970&idx=1&sn=d5e2b133313b1d0f32872d54fbdf0aa7&chksm=fd985423caefdd354b587e57ce6cf5f5a7bec48b9ab7554f39a8d13af47660cae793956e0f46#rd) + 1. **Selector（选择器）介绍** - Selector 一般称 为选择器 ，当然你也可以翻译为 多路复用器 。它是Java NIO核心组件中的一个，用于检查一个或多个NIO Channel（通道）的状态是否处于可读、可写。如此可以实现单线程管理多个channels,也就是可以管理多个网络链接。 @@ -139,8 +157,8 @@ Java面试通关手册（Java学习指南） Github地址：[https://github.com/ -### [五 　Java NIO之拥抱Path和Files](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&tempkey=OTU3X2k5RHFXbjA4MHhzcC9DN0F6TU1OdlgzVno5ZkhYV29GSEZURmktTWJRUkFib2FKNnRwZGE2RHdPTDJMUXl5cVVwMVJWUUVodU4zWlg4YUw1ZURPVXRXakJLcXhDN0VaenkyYjdJdm9uRVJrcWROcGh3d2c2NWNsQjFNWld5N2lNNmxVUWJ1enlad1dUNVoyNFBPaEJyU05KMmpaZEJCLVFSUWllbGd%2Bfg%3D%3D&chksm=7d9854254aefdd33a40a4bad918bdc54cc64450bc3d4597ee53151fdedcdbd2ce722fc8aca4d#rd) -### 主要内容 +### [五 Java NIO之拥抱Path和Files](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&tempkey=OTU3X2k5RHFXbjA4MHhzcC9DN0F6TU1OdlgzVno5ZkhYV29GSEZURmktTWJRUkFib2FKNnRwZGE2RHdPTDJMUXl5cVVwMVJWUUVodU4zWlg4YUw1ZURPVXRXakJLcXhDN0VaenkyYjdJdm9uRVJrcWROcGh3d2c2NWNsQjFNWld5N2lNNmxVUWJ1enlad1dUNVoyNFBPaEJyU05KMmpaZEJCLVFSUWllbGd%2Bfg%3D%3D&chksm=7d9854254aefdd33a40a4bad918bdc54cc64450bc3d4597ee53151fdedcdbd2ce722fc8aca4d#rd) + **一 文件I/O基石：Path：** - 创建一个Path - File和Path之间的转换，File和URI之间的转换 @@ -157,22 +175,21 @@ Java面试通关手册（Java学习指南） Github地址：[https://github.com/ - 遍历一个文件夹 - Files.walkFileTree()遍历整个目录 -### [六 　NIO学习总结以及NIO新特性介绍](https://blog.csdn.net/a953713428/article/details/64907250) +### [六 NIO学习总结以及NIO新特性介绍](https://blog.csdn.net/a953713428/article/details/64907250) - **内存映射：** 这个功能主要是为了提高大文件的读写速度而设计的。内存映射文件(memory-mappedfile)能让你创建和修改那些大到无法读入内存的文件。有了内存映射文件，你就可以认为文件已经全部读进了内存，然后把它当成一个非常大的数组来访问了。将文件的一段区域映射到内存中，比传统的文件处理速度要快很多。内存映射文件它虽然最终也是要从磁盘读取数据，但是它并不需要将数据读取到OS内核缓冲区，而是直接将进程的用户私有地址空间中的一部分区域与文件对象建立起映射关系，就好像直接从内存中读、写文件一样，速度当然快了。 -### [七　Java NIO AsynchronousFileChannel异步文件通](http://wiki.jikexueyuan.com/project/java-nio-zh/java-nio-asynchronousfilechannel.html) +### [七 Java NIO AsynchronousFileChannel异步文件通](http://wiki.jikexueyuan.com/project/java-nio-zh/java-nio-asynchronousfilechannel.html) Java7中新增了AsynchronousFileChannel作为nio的一部分。AsynchronousFileChannel使得数据可以进行异步读写。 -### [八　高并发Java（8）：NIO和AIO](http://www.importnew.com/21341.html) - +### [八 高并发Java（8）：NIO和AIO](http://www.importnew.com/21341.html) -> ## 推荐阅读 +## 推荐阅读 ### [在 Java 7 中体会 NIO.2 异步执行的快乐](https://www.ibm.com/developerworks/cn/java/j-lo-nio2/index.html) diff --git "a/Java\347\233\270\345\205\263/LinkedList.md" "b/Java\347\233\270\345\205\263/LinkedList.md" new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391