棋牌游戏网站模板,微信公众号文章里好看的图片在哪个网站做,学校响应式网站模板下载,wordpress建好站了打不开首页Java集合介绍作为一个程序猿#xff0c;Java集合类可以说是我们在工作中运用最多、最频繁的类。相比于数组(Array)来说#xff0c;集合类的长度可变#xff0c;更加方便开发。Java集合就像一个容器#xff0c;可以存储任何类型的数据#xff0c;也可以结合泛型来存储具体的…Java集合介绍作为一个程序猿Java集合类可以说是我们在工作中运用最多、最频繁的类。相比于数组(Array)来说集合类的长度可变更加方便开发。Java集合就像一个容器可以存储任何类型的数据也可以结合泛型来存储具体的类型对象。在程序运行时Java集合可以动态的进行扩展随着元素的增加而扩大。在Java中集合类通常存在于java.util包中。Java集合主要由2大体系构成分别是Collection体系和Map体系其中Collection和Map分别是2大体系中的顶层接口。Collection主要有三个子接口分别为List(列表)、Set(集)、Queue(队列)。其中List、Queue中的元素有序可重复而Set中的元素无序不可重复。List中主要有ArrayList、LinkedList两个实现类Set中则是有HashSet实现类而Queue是在JDK1.5后才出现的新集合主要以数组和链表两种形式存在。Map同属于java.util包中是集合的一部分但与Collection是相互独立的没有任何关系。Map中都是以key-value的形式存在其中key必须唯一主要有HashMap、HashTable、treeMap三个实现类。List介绍在Collection中List集合是有序的可对其中每个元素的插入位置进行精确地控制可以通过索引来访问元素遍历元素。在List集合中我们常用到ArrayList和LinkedList这两个类。ArrayList集合1ArrayList底层通过数组实现随着元素的增加而动态扩容。2ArrayList是Java集合框架中使用最多的一个类是一个数组队列线程不安全集合。它继承于AbstractList实现了List, RandomAccess, Cloneable, Serializable接口。ArrayList实现List得到了List集合框架基础功能ArrayList实现RandomAccess获得了快速随机访问存储元素的功能RandomAccess是一个标记接口没有任何方法ArrayList实现Cloneable得到了clone()方法可以实现克隆功能ArrayList实现Serializable表示可以被序列化通过序列化去传输典型的应用就是hessian协议。ArrayList集合的特点容量不固定随着容量的增加而动态扩容(阈值基本不会达到)有序集合(插入的顺序输出的顺序)插入的元素可以为null增删改查效率更高(相对于LinkedList来说)线程不安全ArrayList的底层数据结构LinkedList集合LinkedList底层通过链表来实现随着元素的增加不断向链表的后端增加节点。LinkedList是一个双向链表每一个节点都拥有指向前后节点的引用。相比于ArrayList来说LinkedList的随机访问效率更低。它继承AbstractSequentialList实现了List, Deque, Cloneable, Serializable接口。LinkedList实现List得到了List集合框架基础功能LinkedList实现DequeDeque 是一个双向队列也就是既可以先入先出又可以先入后出说简单点就是既可以在头部添加元素也可以在尾部添加元素LinkedList实现Cloneable得到了clone()方法可以实现克隆功能LinkedList实现Serializable表示可以被序列化通过序列化去传输典型的应用就是hessian协议。List常用方法A:添加功能boolean add(E e):向集合中添加一个元素void add(int index, E element):在指定位置添加元素boolean addAll(Collection extends E c)向集合中添加一个集合的元素。B:删除功能void clear()删除集合中的所有元素E remove(int index)根据指定索引删除元素并把删除的元素返回boolean remove(Object o)从集合中删除指定的元素boolean removeAll(Collection c):从集合中删除一个指定的集合元素。C:修改功能E set(int index, E element):把指定索引位置的元素修改为指定的值返回修改前的值。D:获取功能E get(int index)获取指定位置的元素Iterator iterator():就是用来获取集合中每一个元素。E:判断功能boolean isEmpty()判断集合是否为空。boolean contains(Object o)判断集合中是否存在指定的元素。boolean containsAll(Collection c)判断集合中是否存在指定的一个集合中的元素。F:长度功能int size():获取集合中的元素个数G:把集合转换成数组Object[] toArray():把集合变成数组。ArrayList 基本操作public class ArrayListTest {public static void main(String[] agrs){//创建ArrayList集合List list new ArrayList();System.out.println(ArrayList集合初始化容量list.size());// ArrayList集合初始化容量0//添加功能list.add(Hello);list.add(world);list.add(2,!);System.out.println(ArrayList当前容量list.size());// ArrayList当前容量3//修改功能list.set(0,my);list.set(1,name);System.out.println(ArrayList当前内容list.toString());// ArrayList当前内容[my, name, !]//获取功能String element list.get(0);System.out.println(element);// my//迭代器遍历集合(ArrayList实际的跌倒器是Itr对象)Iterator iterator list.iterator();while(iterator.hasNext()){String next iterator.next();System.out.println(next);}/**myname!*///for循环迭代集合for(String str:list){System.out.println(str);}/**myname!*///判断功能boolean isEmpty list.isEmpty();boolean isContain list.contains(my);//长度功能int size list.size();//把集合转换成数组String[] strArray list.toArray(new String[]{});//删除功能list.remove(0);list.remove(world);list.clear();System.out.println(ArrayList当前容量list.size());// ArrayList当前容量0}}LinkedList 基本操作public class LinkedListTest {public static void main(String[] agrs){List linkedList new LinkedList();System.out.println(LinkedList初始容量linkedList.size());// LinkedList初始容量0//添加功能linkedList.add(my);linkedList.add(name);linkedList.add(is);linkedList.add(jiaboyan);System.out.println(LinkedList当前容量 linkedList.size());// LinkedList当前容量4//修改功能:linkedList.set(0,hello);linkedList.set(1,world);System.out.println(LinkedList当前内容 linkedList.toString());// LinkedList当前内容[hello, world, is, jiaboyan]//获取功能String element linkedList.get(0);System.out.println(element);// hello//遍历集合(LinkedList实际的迭代器是ListItr对象)Iterator iterator linkedList.iterator();while(iterator.hasNext()){String next iterator.next();System.out.println(next);}/**helloworldisjiaboyan*///for循环迭代集合for(String str:linkedList){System.out.println(str);}/**helloworldisjiaboyan*///判断功能boolean isEmpty linkedList.isEmpty();boolean isContains linkedList.contains(jiaboyan);//长度功能int size linkedList.size();//删除功能linkedList.remove(0);linkedList.remove(jiaboyan);linkedList.clear();System.out.println(LinkedList当前容量 linkedList.size());// LinkedList当前容量0}}ArrayList和LinkedList比较(1)元素新增性能比较网上很多说的是在做新增操作时ArrayList的效率远不如LinkedList因为Arraylist底层时数组实现的在动态扩容时性能会有所损耗而LinkedList不存在数组扩容机制所以LinkedList的新增性能较好。究竟时哪个好呢我们用实践得到结果。public class ListTest{// 迭代次数public static int ITERATION_NUM 100000;public static void main(String[] args) {try{insertPerformanceCompare();}catch (Exception e){}}//新增性能比较public static void insertPerformanceCompare() throws InterruptedException {Thread.sleep(5000);System.out.println(LinkedList新增测试开始);long start System.nanoTime();List linkedList new LinkedList();for (int x 0; x ITERATION_NUM; x) {linkedList.add(x);}long end System.nanoTime();System.out.println(end - start);System.out.println(ArrayList新增测试开始);start System.nanoTime();List arrayList new ArrayList();for (int x 0; x ITERATION_NUM; x) {arrayList.add(x);}end System.nanoTime();System.out.println(end - start);}}测试结果第一次LinkedList新增测试开始10873720ArrayList新增测试开始5535277第二次LinkedList新增测试开始13097503ArrayList新增测试开始6046139第三次LinkedList新增测试开始12004669ArrayList新增测试开始6509783结果与预想的有些不太一样ArrayList的新增性能并不低。原因 可能是经过JDK近几年的更新发展对于数组复制的实现进行了优化以至于ArrayList的性能也得到了提高。(2)元素获取比较由于LinkedList是链表结构没有角标的概念没有实现RandomAccess接口不具备随机元素访问功能所以在get方面表现的差强人意ArrayList再一次完胜。public class ListTest {//迭代次数集合大小public static int ITERATION_NUM 100000;public static void main(String[] agrs) {try{getPerformanceCompare();}catch (Exception e){}}//获取性能比较public static void getPerformanceCompare()throws InterruptedException {Thread.sleep(5000);//填充ArrayList集合List arrayList new ArrayList();for (int x 0; x ITERATION_NUM; x) {arrayList.add(x);}//填充LinkedList集合List linkedList new LinkedList();for (int x 0; x ITERATION_NUM; x) {linkedList.add(x);}//创建随机数对象Random random new Random();System.out.println(LinkedList获取测试开始);long start System.nanoTime();for (int x 0; x ITERATION_NUM; x) {int j random.nextInt(x 1);int k linkedList.get(j);}long end System.nanoTime();System.out.println(end - start);System.out.println(ArrayList获取测试开始);start System.nanoTime();for (int x 0; x ITERATION_NUM; x) {int j random.nextInt(x 1);int k arrayList.get(j);}end System.nanoTime();System.out.println(end - start);}}测试结果第一次LinkedList获取测试开始8190063123ArrayList获取测试开始8590205第二次LinkedList获取测试开始8100623160ArrayList获取测试开始11948919第三次LinkedList获取测试开始8237722833ArrayList获取测试开始6333427从结果可以看出ArrayList在随机访问方面表现的十分优秀比LinkedList强了很多。原因 这主要是LinkedList的代码实现所致每一次获取都是从头开始遍历一个个节点去查找每查找一次就遍历一次所以性能自然得不到提升。ArrayList源码分析接下来我们对ArrayList集合进行源码分析其中先来几个问题(1)ArrayList的构造(2)增删改查的实现(3)迭代器——modCount(4)为什么数组对象要使用transient修饰符(5)System.arraycopy()参数含义 Arrays.copyOf()参数含义我们通过上面几个问题对ArrayList的源码进行一步一步的解析。ArrayList构造器1在JDK1.7版本中ArrayList的无参构造方法并没有生成容量为10的数组。2elementData对象是ArrayList集合底层保存元素的实现。3size属性记录了ArrayList集合中实际元素的个数。public class ArrayList extends AbstractListimplements List, RandomAccess, Cloneable, java.io.Serializable {//实现Serializable接口生成的序列版本号private static final long serialVersionUID 8683452581122892189L;//ArrayList初始容量大小在无参构造中不使用了private static final int DEFAULT_CAPACITY 10;//空数组对象初始化中默认赋值给elementDataprivate static final Object[] EMPTY_ELEMENTDATA {};//ArrayList中实际存储元素的数组private transient Object[] elementData;//集合实际存储元素长度private int size;//ArrayList有参构造容量大小public ArrayList(int initialCapacity) {//即父类构造protected AbstractList() {}空方法super();//如果传递的初始容量小于0 抛出异常if (initialCapacity 0)throw new IllegalArgumentException(Illegal Capacity: initialCapacity);//初始化数据创建Object数组this.elementData new Object[initialCapacity];}//ArrayList无参构造public ArrayList() {//即父类构造protected AbstractList() {}空方法super();//初始化数组空数组容量为0this.elementData EMPTY_ELEMENTDATA;}//ArrayList有参构造Java集合public ArrayList(Collection extends E c) {//将集合转换为数组elementData c.toArray();//设置数组的长度size elementData.length;if (elementData.getClass() ! Object[].class)elementData Arrays.copyOf(elementData, size, Object[].class);}}add() 添加1在JDK1.7当中当第一个元素添加时ensureCapacityInternal()方法会计算ArrayList的扩容大小默认为10。2其中grow()方法最为重要如果需要扩容那么扩容后的大小是原来的1.5倍实际上最终调用了Arrays.copyOf()方法得以实现。//添加元素epublic boolean add(E e) {ensureCapacityInternal(size 1);//将对应角标下的元素赋值为eelementData[size] e;return true;}//得到最小扩容量private void ensureCapacityInternal(int minCapacity) {//如果此时ArrayList是空数组,则将最小扩容大小设置为10if (elementData EMPTY_ELEMENTDATA) {minCapacity Math.max(DEFAULT_CAPACITY, minCapacity);}//判断是否需要扩容ensureExplicitCapacity(minCapacity);}//判断是否需要扩容private void ensureExplicitCapacity(int minCapacity) {//操作数1modCount;//判断最小扩容容量-数组大小是否大于0if (minCapacity - elementData.length 0)//扩容grow(minCapacity);}//ArrayList动态扩容的核心方法:private void grow(int minCapacity) {//获取现有数组大小int oldCapacity elementData.length;//位运算得到新的数组容量大小为原有的1.5倍int newCapacity oldCapacity (oldCapacity 1);//如果新扩容的大小依旧小于传入的容量值那么将传入的值设为新容器大小if (newCapacity - minCapacity 0)newCapacity minCapacity;//如果新容器大小大于ArrayList最大长度if (newCapacity - MAX_ARRAY_SIZE 0)//计算出最大容量值newCapacity hugeCapacity(minCapacity);//数组复制elementData Arrays.copyOf(elementData, newCapacity);}// 计算ArrayList最大容量private static int hugeCapacity(int minCapacity) {if (minCapacity 0)throw new OutOfMemoryError();//如果新的容量大于MAX_ARRAY_SIZE。将会调用hugeCapacity将int的最大值赋给newCapacity:return (minCapacity MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;}remove() 删除1remove(int index)是针对于角标来进行删除不需要去遍历整个集合效率更高。2而remove(Object o)是针对于对象来进行删除需要遍历整个集合进行equals()方法比对所以效率较低。3不过无论是哪种形式的删除最终都会调用System.arraycopy()方法进行数组复制操作所以效率都会受到影响。//在ArrayList的移除index位置的元素public E remove(int index) {//检查角标是否合法不合法抛异常rangeCheck(index);//操作数1modCount;//获取当前角标的value:E oldValue elementData(index);//获取需要删除元素 到最后一个元素的长度也就是删除元素后后续元素移动的个数int numMoved size - index - 1;//如果移动元素个数大于0 也就是说删除的不是最后一个元素if (numMoved 0)// 将elementData数组index1位置开始拷贝到elementData从index开始的空间System.arraycopy(elementData, index1, elementData, index, numMoved);//size减1并将最后一个元素置为nullelementData[--size] null;//返回被删除的元素return oldValue;}//在ArrayList的移除对象为O的元素不返回被删除的元素public boolean remove(Object o) {//如果onull则遍历集合判断哪个元素为nullif (o null) {for (int index 0; index size; index)if (elementData[index] null) {//快速删除和前面的remove(index)一样的逻辑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) {//操作数1modCount;//获取需要删除元素 到最后一个元素的长度也就是删除元素后后续元素移动的个数int numMoved size - index - 1;//如果移动元素个数大于0 也就是说删除的不是最后一个元素if (numMoved 0)// 将elementData数组index1位置开始拷贝到elementData从index开始的空间System.arraycopy(elementData, index1, elementData, index, numMoved);//size减1并将最后一个元素置为nullelementData[--size] null;}set() 修改由于ArrayList实现了RandomAccess所以具备了随机访问特性调用elementData()可以获取到对应元素的值。//设置index位置的元素值了element返回该位置的之前的值public E set(int index, E element) {//检查index是否合法判断index是否大于sizerangeCheck(index);//获取该index原来的元素E oldValue elementData(index);//替换成新的元素elementData[index] element;//返回旧的元素return oldValue;}get() 获取元素通过elementData()方法获取对应角标元素在返回时候进行类型转换。//获取index位置的元素public E get(int index) {//检查index是否合法rangeCheck(index);//获取元素return elementData(index);}//获取数组index位置的元素返回时类型转换E elementData(int index) {return (E) elementData[index];}modCount含义1在Itr迭代器初始化时,将ArrayList的modCount属性的值赋值给了expectedModCount。2通过上面的例子中我们可以知道当进行增删改时modCount会随着每一次的操作而1modCount记录了ArrayList内发生改变的次数。3当迭代器在迭代时会判断expectedModCount的值是否还与modCount的值保持一致如果不一致则抛出异常。AbstractList类当中定义的变量protected transient int modCount 0;1ArrayList获取迭代器对象//返回一个Iterator对象Itr为ArrayList的一个内部类其实现了Iterator接口public Iterator iterator() {return new java.util.ArrayList.Itr();}迭代器实现//Itr实现了Iterator接口是ArrayList集合的迭代器对象private class Itr implements Iterator {//类似游标指向迭代器下一个值的位置int cursor;//迭代器最后一次取出的元素的位置。int lastRet -1;//Itr初始化时候ArrayList的modCount的值。int expectedModCount modCount;//利用游标与size之前的比较判断迭代器是否还有下一个元素public boolean hasNext() {return cursor ! size;}//迭代器获取下一个元素public E next() {//检查modCount是否改变checkForComodification();int i cursor;//游标不会大于等于集合的长度if (i size)throw new NoSuchElementException();Object[] elementData java.util.ArrayList.this.elementData;//游标不会大于集合中数组的长度if (i elementData.length)throw new ConcurrentModificationException();//游标1cursor i 1;//取出元素return (E) elementData[lastRet i];}public void remove() {if (lastRet 0)throw new IllegalStateException();//检查modCount是否改变防止并发操作集合checkForComodification();try {//删除这个元素java.util.ArrayList.this.remove(lastRet);//删除后重置游标和当前指向元素的角标 lastRetcursor lastRet;lastRet -1;//重置expectedModCountexpectedModCount modCount;} catch (IndexOutOfBoundsException ex) {throw new ConcurrentModificationException();}}//并发检查final void checkForComodification() {if (modCount ! expectedModCount)throw new ConcurrentModificationException();}}transient 修饰符1当我们序列化对象时如果对象中某个属性不进行序列化操作那么在该属性前添加transient修饰符即可实现。例如private transient Object[] elementData;那么问题来了为什么ArrayList不想对elementData属性进行序列化呢elementData可是集合中保存元素的数组啊如果不序列化elementData属性那么在反序列化时候岂不是丢失了原先的元素原因是 ArrayList在添加元素时可能会对elementData数组进行扩容操作而扩容后的数组可能并没有全部保存元素。例如我们创建了new Object[10]数组对象但是我们只向其中添加了1个元素而剩余的9个位置并没有添加元素。当我们进行序列化时并不会只序列化其中一个元素而是将整个数组进行序列化操作那些没有被元素填充的位置也进行了序列化操作间接的浪费了磁盘的空间以及程序的性能。所以ArrayList才会在elementData属性前加上transient修饰符。接下来我们来看下ArrayList的writeObject()、readObject()//序列化写入private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{int expectedModCount modCount;s.defaultWriteObject();s.writeInt(size);for (int i0; is.writeObject(elementData[i]);}if (modCount ! expectedModCount) {throw new ConcurrentModificationException();}}// 序列化读取private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {elementData EMPTY_ELEMENTDATA;s.defaultReadObject();s.readInt();if (size 0) {ensureCapacityInternal(size);Object[] a elementData;for (int i0; ia[i] s.readObject();}}}1ArrayList在序列化时会调用writeObject()直接将elementData写入ObjectOutputStream。2反序列化时则调用readObject()从ObjectInputStream获取elementData。Arrays.copyOf() 数组扩容该方法在内部创建了一个新数组底层实现是调用System.arraycopy()。public static T[] copyOf(U[] original, int newLength, Class extends T[] newType) {T[] copy ((Object)newType (Object)Object[].class)? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;}original - 要复制的数组newLength - 要返回的副本的长度newType - 要返回的副本的类型System.arraycopy()该方法是用了native关键字调用的为C编写的底层函数。public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);src - 源数组。srcPos - 源数组中的起始位置。dest - 目标数组。destPos - 目标数据中的起始位置。length - 要复制的数组元素的数量。LinkedList源码分析看到网上都说LinkedList是一个环形链表结构头尾相连。但当我开始看源码的时候发现并不是环形链表是一个直线型链表结构我一度以为是我理解有误。后来发现JDK1.7之前的版本是环形链表而到了JDK1.7以后进行了优化变成了直线型链表结构。集合基础结构1在LinkedList中内部类Node对象最为重要它组成了LinkedList集合的整个链表分别指向上一个点、下一个结点存储着集合中的元素。2成员变量中first表明是头结点last表明是尾结点。public class LinkedListextends AbstractSequentialListimplements List, Deque, Cloneable, java.io.Serializable {//LinkedList的元素个数transient int size 0;//LinkedList的头结点Node内部类transient java.util.LinkedList.Node first;//LinkedList尾结点Node内部类transient java.util.LinkedList.Node last;//空实现头尾结点均为null链表不存在public LinkedList() {}//调用添加方法public LinkedList(Collection extends E c) {this();addAll(c);}//节点的数据结构包含前后节点的引用和当前节点private static class Node {//结点元素E item;//结点后指针java.util.LinkedList.Node next;//结点前指针java.util.LinkedList.Node prev;Node(java.util.LinkedList.Node prev, E element, java.util.LinkedList.Node next) {this.item element;this.next next;this.prev prev;}}}add() 添加LinkedList的添加方法主要分为2种一是直接添加一个元素二是在指定角标下添加一个元素。(1)add(E e)底层调用linkLast(E e)方法就是在链表的最后面插入一个元素。(2)add(int index, E element)插入的角标如果size则插入到链表最后否则按照角标大小插入到对应位置。//添加元素添加到最后一个结点public boolean add(E e) {linkLast(e);return true;}//last节点插入新元素void linkLast(E e) {//将尾结点赋值个体L:final java.util.LinkedList.Node l last;//创建新的结点将新节点的前指针指向l:final java.util.LinkedList.Node newNode new java.util.LinkedList.Node(l, e, null);//新节点置为尾结点last newNode;//如果尾结点l为null则是空集合新插入if (l null)//头结点也置为 新节点first newNode;else//l节点的后指针指向新节点l.next newNode;//长度1size;//操作数1modCount;}//向对应角标添加元素public void add(int index, E element) {//检查传入的角标 是否正确checkPositionIndex(index);//如果插入角标集合长度则插入到集合的最后面if (index size)linkLast(element);else//插入到对应角标的位置获取此角标下的元素先linkBefore(element, node(index));}//在succ前插入 新元素evoid linkBefore(E e, java.util.LinkedList.Node succ) {//获取被插入元素succ的前指针元素final java.util.LinkedList.Node pred succ.prev;//创建新增元素节点前指针 和 后指针分别指向对应元素final java.util.LinkedList.Node newNode new java.util.LinkedList.Node(pred, e, succ);succ.prev newNode;//succ的前指针元素可能为null为null的话说明succ是头结点则把新建立的结点置为头结点if (pred null)first newNode;else//succ前指针不为null则将前指针的结点的后指针指向新节点pred.next newNode;//长度1size;//操作数1modCount;}对于LinkedList集合增加元素来说可以简单的概括为以下几点1将添加的元素转换为LinkedList的Node对象节点。2增加该Node节点的前后引用即该Node节点的prev、next属性让其分别指向哪一个节点)。3修改该Node节点的前后Node节点中pre/next属性使其指向该节点。remove() 删除元素LinkedList的删除也提供了2种形式其一是通过角标删除元素其二就是通过对象删除元素不过无论哪种删除最终调用的都是unlink来实现的。//删除对应角标的元素public E remove(int index) {checkElementIndex(index);//node()方法通过角标获取对应的元素在后面介绍return unlink(node(index));}//删除LinkedList中的元素可以删除为null的元素逐个遍历LinkedList的元素重复元素只删除第一个public boolean remove(Object o) {//如果删除元素为nullif (o null) {for (java.util.LinkedList.Node x first; x ! null; x x.next) {if (x.item null) {unlink(x);return true;}}} else {//如果删除元素不为nullfor (java.util.LinkedList.Node x first; x ! null; x x.next) {if (o.equals(x.item)) {unlink(x);return true;}}}return false;}//移除LinkedList结点remove()方法中调用E unlink(java.util.LinkedList.Node x) {//获取被删除结点的元素Efinal E element x.item;//获取被删除元素的后指针结点final java.util.LinkedList.Node next x.next;//获取被删除元素的前指针结点final java.util.LinkedList.Node prev x.prev;//被删除结点的 前结点为null的话if (prev null) {//将后指针指向的结点置为头结点first next;} else {//前置结点的 尾结点指向被删除的next结点prev.next next;//被删除结点前指针置为null:x.prev null;}//对尾结点同样处理if (next null) {last prev;} else {next.prev prev;x.next null;}x.item null;size--;modCount;return element;}set() 修改元素1LinkedList的set(int index, E element)方法与add(int index,E element)的设计思路基本一致都是创建新Node节点插入到对应的角标下修改前后节点的prev、next属性。2其中node(int index)方法至关重要通过对应角标获取到对应的集合元素。3可以看到node()中是根据角标的大小是选择从前遍历还是从后遍历整个集合。也可以间接的说明LinkedList在随机获取元素时性能很低每次的获取都得从头或者从尾遍历半个集合。//设置对应角标的元素public E set(int index, E element) {checkElementIndex(index);//通过node()方法获取到对应角标的元素java.util.LinkedList.Node x node(index);E oldVal x.item;x.item element;return oldVal;}//获取对应角标所属于的结点java.util.LinkedList.Node node(int index) {//位运算如果位置索引小于列表长度的一半则从头开始遍历否则从后开始遍历if (index (size 1)) {java.util.LinkedList.Node x first;//从头结点开始遍历遍历的长度就是index的长度获取对应的index的元素for (int i 0; i index; i)x x.next;return x;} else {//从集合尾结点遍历java.util.LinkedList.Node x last;//同样道理for (int i size - 1; i index; i--)x x.prev;return x;}}get() 获取元素get(int index)在通过node(int index)获取到对应节点后返回节点中的item属性该属性就是我们所保存的元素。//获取相应角标的元素public E get(int index) {//检查角标是否正确checkElementIndex(index);//获取角标所属结点的 元素值return node(index).item;}迭代器在LinkedList中并没有自己实现iterator()方法而是使用其父类AbstractSequentialList的iterator()方法。List linkedList new LinkedList();Iterator iterator linkedList.iterator();父类AbstractSequentialList中的 iterator():public abstract class AbstractSequentialList extends AbstractList {public Iterator iterator() {return listIterator();}}父类AbstractList中的 listIterator()public abstract class AbstractList extends AbstractCollection implements List {public ListIterator listIterator() {return listIterator(0);}}LinkedList中的 listIterator()public ListIterator listIterator(int index) {checkPositionIndex(index);return new ListItr(index);}private class ListItr implements ListIterator {}总结本篇文章简单介绍了Java中List集合由于纯手打难免会有纰漏如果发现错误的地方请第一时间告诉我这将是我进步的一个很重要的环节。
