制作简单的小游戏 当前位置:首页>制作简单的小游戏>正文

制作简单的小游戏

发布时间:2019-04-19

原标题:java容器类分析:Collection,List,ArrayList,LinkedList深入解读

如遇【线上娱乐站】不能自动打开,请复制 http://da8.us 到浏览器,注册自动送8-88试 ̶̶̶̶̶̶̶̶̶̶玩 ̷̷̷̷̷̷̷̷̷̷金。体验各种类的线上PT/DT/MG/PNG ̶̶̶̶̶̶̶̶̶̶老 ̷̷̷̷̷̷̷̷̷̷虎 ̷̷̷̷̷̷̷̷̷̷机、 ̷̷̷̷̷̷̷̷̷̷真* ̷̷̷̷̷̷̷̷̷̷人* ̶̶̶̶̶̶̶̶̶̶百* ̶̶̶̶̶̶̶̶̶̶家 ̷̷̷̷̷̷̷̷̷̷*乐*游戏等免费试玩、优惠活动,7*24小时专业服务

比例这一招时乘六龙,六掌齐发,六龙齐出,叠加在一起一波接一波密不透风,每一掌都是带有万斤巨力,连续六次重击,就算是火云邪神也不好受。

橙光游戏攻略大全

自从看到白沉香在空中极速飞行的样子,这位船长对众人也恭敬了许多。
“王小民,你瞎跑什么啊!呼呼……累死我了。”萧童这时气喘吁吁的追了上来,生气的问道,不过她心底又有些惊奇。

这时王小民从身后拥住了丽莎柔软的娇躯,说道:“是不是还想继续咱们之前的事情?”

1、 Iterable 与 Iterator

Iterable 是个接口,实现此接口使集合对象可以通过迭代器遍历自身元素.

public interface Iterable<T>

修饰符和返回值 方法名 描述
Iterator<T> iterator() 返回一个内部元素为T类型的迭代器
default void forEach(Consumer<? super T> action) 对内部元素进行遍历,并对元素进行指定的操作
default Spliterator<T> spliterator() 创建并返回一个可分割迭代器

第一个接口iterator()是jdk1.5引入的,需要子类实现一个内部迭代器Iterator遍历元素。

后两个接口是JDK1.8后新添加的,forEach(Consumer action)是为了方便遍历操作集合内的元素,spliterator()则提供了一个可以并行遍历元素的迭代器,以适应现在cpu多核时代并行遍历的需求.

其中我们可以看default修饰符,这也是Java 8后新出现的,我们知道,如果我们给一个接口新添加一个方法,那么所有他的具体子类都必须实现此方法,为了能给接口拓展新功能,而又不必每个子类都要实现此方法,Java 8新加了default关键字,被其修饰的方法可以不必由子类实现,并且由dafault修饰的方法在接口中有方法体,这打破了Java之前对接口方法的规范.

Iterator 为迭代器类,用于遍历容器。

public interface Iterator<E>

修饰符和返回值 方法名 描述
boolean hasNext() 判断迭代器所指元素是否为最后一个
E next() 下一个元素
default Void remove() 移除迭代器只想的当前元素
default Void forEachRemaining(Consumer<? super E> action) 遍历迭代器指向元素后面的所有元素

AbstartList中实现了Iterator类作为List内部的迭代器,用于访问内部元素,其代码如下:

  1 private class Itr implements Iterator<E> {
  2         /**
  3          * Index of element to be returned by subsequent call to next.
  4          */
  5         int cursor = 0;
  6 
  7         /**
  8          * Index of element returned by most recent call to next or
  9          * previous.  Reset to -1 if this element is deleted by a call
 10          * to remove.
 11          */
 12         int lastRet = -1;
 13 
 14         /**
 15          * The modCount value that the iterator believes that the backing
 16          * List should have.  If this expectation is violated, the iterator
 17          * has detected concurrent modification.
 18          */
 19         int expectedModCount = modCount;
 20 
 21         public boolean hasNext() {
 22             return cursor != size();
 23         }
 24 
 25         public E next() {
 26             checkForComodification();
 27             try {
 28                 int i = cursor;
 29                 E next = get(i);
 30                 lastRet = i;
 31                 cursor = i + 1;
 32                 return next;
 33             } catch (IndexOutOfBoundsException e) {
 34                 checkForComodification();
 35                 throw new NoSuchElementException();
 36             }
 37         }
 38 
 39         public void remove() {
 40             if (lastRet < 0)
 41                 throw new IllegalStateException();
 42             checkForComodification();
 43 
 44             try {
 45                 AbstractList.this.remove(lastRet);
 46                 if (lastRet < cursor)
 47                     cursor--;
 48                 lastRet = -1;
 49                 expectedModCount = modCount;
 50             } catch (IndexOutOfBoundsException e) {
 51                 throw new ConcurrentModificationException();
 52             }
 53         }
 54 
 55         final void checkForComodification() {
 56             if (modCount != expectedModCount)
 57                 throw new ConcurrentModificationException();
 58         }
 59     }
 60 
View Code

2、Collection

Collection 是容器类的接口,里面可以存放很多Elements,很多容器都实现了该接口。

public interface Collection<E> extends Iterable<E>

修饰符和返回值 方法名 描述
int size() 判断容器的大小
boolean isEmpty() 判空
boolean contains(Object o) 是否包含某元素
Object[] toArray() 转化为数组
<T> T[] toArray(T[] a) 将容器中所有元素拷贝到a中,如果a不够大,则拷贝到返回的数组中。(见AbstactCollection中实现)
boolean add(E e) 添加元素
boolean remove(Object o) 移除容器中第一个出现Object对象,如果Object为null,则移除第一个出现的null。如果没有Object对象返回false
boolean containsAll(Collection<?> c) 包含c中所有元素
boolean addAll(Collection<? extends E> c); 将c中所有元素添加到容器中
boolean removeAll(Collection<?> c) 如果容器中包含c中的元素,删除。(调用remove(Object))
default boolean removeIf(Predicate<? super E> filter) 移除所有符合条件的元素(JDK1.8中引入)
boolean retainAll(Collection<?> c) 保留在c中出现的元素,其它全部移除
boolean clear()  
boolean equals(Object o) 与o中所有元素都相等则相等
int  hashCode() c1.equals(c2) 那么他们的hashCode()一定相等,反之不成立 
default Spliterator<E> spliterator() 在所有元素之上创建一个Spliterator
default Stream<E> stream()  
default Stream<E> parallelStream()  

上述很多函数的实现可以参考 AbstactList中的实现。

3. List

List是一个接口,继承了Collection中的所有接口,并且添加了自身相关接口和具体实现。

由上图可以看出,Collection分成了三个分支,List就是其中一个,下面我们具体分析一下增加的接口。

public interface List<E> extends Collection<E>

修饰符和返回值 方法名 描述
  Collection中的所有接口  
default void  replaceAll(UnaryOperator<E> operator) 将运算操作后的结果替换List中原有元素
default void sort(Comparator<? super E> c) 将List中所有元素排序
E  get(int index);  
E  set(int index, E element)  
E  remove(int index)  
int indexOf(Object o) o在List中第一次出现的位置
int lastIndexOf(Object o) o在List中最后一次出现的位置
ListIterator<E> listIterator() 获取List的迭代器
ListIterator<E> listIterator(int index) 获取从某个位置开始的迭代器,index为迭代器起始位置
List<E> subList(int fromIndex, int toIndex) 子List

上表可以看出,增加了 和index相关的接口,根据index对List进行的get、set、remove等操作。另一类添加的接口是ListIteator相关的,获取List的迭代器。

3.1 ListIterator

public interface ListIterator<E> extends Iterator<E>

ListIterator 不光包含Iterator中的三个接口还增加了作为一个List迭代器应该有的接口,如 next(),previous()等

修饰符和返回值 方法名 描述
  Iterator中的所有接口  
boolean  hasNext()  
E next()  
boolean  hasPrevious()  
E previous()  
int nextIndex()  
int previousIndex()  
void  remove() 删除next()返回元素
void  set(E e) 替换next()返回的元素
void  add(E e) 在nextIndex()后插入元素

首先需要明确ListIterator迭代器的作用:

  1. 允许我们向前、向后两个方向遍历 List;
  2. 在遍历时修改 List 的元素;
  3. 遍历时获取迭代器当前游标所在位置。
注意,迭代器 没有当前所在元素一说,它只有一个游标( cursor )的概念,这个游标总是在元素之间,比如这样:

迭代器的初始位置:

这里写图片描述

调用next()后迭代器的位置这里写图片描述

调用 previous() 游标就会回到之前位置。当向后遍历完元素,游标就会在元素 N 的后面

这里写图片描述

也就是说长度为 N 的集合会有 N+1 个游标的位置。

3.2 AbstractCollection / AbstractList

        在上面的继承关系图中并没有显示出AbstractCollect和AbstractList的存在,但是在阅读源码的时候经常遇到这两个类,下面讲一下这两个类的作用。

      首先需要明确的一点是AbstractCollect和AbstractList都是抽象类而不是接口,它们分别实现了Collection和List接口中的部分函数。这样继承者直接继承AbstractXXXX 而不需要自己重复实现里面的所有接口。这两个抽象类抽离了公共部分,进行了实现,减少后续类的工作量。

       ArrayList 和LinkedList都直接或者间接继承了AbstartList类。下图为这两个类的继承关系:

这里写图片描述

        具体这两个类里面实现了哪些接口,请自己阅读源码不再讲解。

LinkedList中modCount和expectedModCount作用

在AbstractList中可以看到这两个变量,它们用于表示List被修改的次数,这其中包括了调用集合本身的add等方法等修改方法时进行的修改和调用集合迭代器的修改方法进行的修改。而expectedModCount则是表示迭代器对集合进行修改的次数。

那么知道这两个值有什么作用呢?

如果创建多个迭代器对一个集合对象进行修改的话,那么就会有一个modCount和多个expectedModCount,且modCount的值之间也会不一样,这就导致了moCount和expectedModCount的值不一致,从而产生异常。

https://www.cnblogs.com/zhangcaiwang/p/7131035.html

3.3 ArrayList

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
我们看到ArrayList的定义的时候很可能会出现一个疑问,为什么它已经继承了AbstractList了还需要去实现List<E>接口? 答案是,后面的List<E>可以去掉,这里只是让阅读者明白ArrayList是个List。 终于好不容易到了开发者常用的类了,有点窃喜:transient Object[] elementData;这个很重要的成员变量elementData数组用来存放ArrayList中的元素,当第一个元素添加进来后,它的默认长度变为10。(java中“transient”关键字修饰的成员变量在类序列化的过程中不会被持久化到文件中,保证该成员变量保存信息的安全。)
ArrayList的构造函数中可以直接指定elementData数组的长度,那么问题来了,当数组已经完全被占用再向ArrayList中添加元素时,如何再分配更大长度的数组?如何把旧数据拷贝到新数组中?答案见下面这段源码

  1 private void grow(int minCapacity) {  //最少需要的容量 
  2         // overflow-conscious code
  3         int oldCapacity = elementData.length;
  4         int newCapacity = oldCapacity + (oldCapacity >> 1);   // 分配最小容量的 1.5倍
  5         if (newCapacity - minCapacity < 0)       
  6             newCapacity = minCapacity;
  7         if (newCapacity - MAX_ARRAY_SIZE > 0)
  8             newCapacity = hugeCapacity(minCapacity);   // 最大容量比较(Inter.MAX_VALUE)
  9         // minCapacity is usually close to size, so this is a win:
 10         elementData = Arrays.copyOf(elementData, newCapacity);  // 将旧数据拷贝到新数组中
 11     }

其它接口不再细说。

3.4 LinkedList


  1 public class LinkedList<E>
  2     extends AbstractSequentialList<E>
  3     implements List<E>, Deque<E>, Cloneable, java.io.Serializable

作为一个链表类型,首先需要熟悉一下节点类:Node(LinkedList静态内部类)

  1 private static class Node<E> {
  2         E item;
  3         Node<E> next;
  4         Node<E> prev;
  5 
  6         Node(Node<E> prev, E element, Node<E> next) {
  7             this.item = element;
  8             this.next = next;
  9             this.prev = prev;
 10         }
 11     }

在LinkedList中有三个主要成员变量:

  • transient int size = 0;      // 链表长度
  • transient Node<E> first;  // 链表的首节点
  • transient Node<E> last;  // 链表的末节点

LinkedList构造方法:

  1  /**
  2      * Constructs an empty list.
  3      */
  4     public LinkedList() {
  5     }
  6 
  7     /**
  8      * Constructs a list containing the elements of the specified
  9      * collection, in the order they are returned by the collection"s
 10      * iterator.
 11      *
 12      * @param  c the collection whose elements are to be placed into this list
 13      * @throws NullPointerException if the specified collection is null
 14      */
 15     public LinkedList(Collection<? extends E> c) {
 16         this();
 17         addAll(c);
 18     }

clear()方法:遍历LinkedList 置null

 public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }
View Code

public E set(int index, E element):将某个Index指向的Node置变为element
public E 

编辑:杜公

发布时间:2019-04-19 01:40:03

当前文章:http://6066655.cn/2019-02-11/e8bve.html

炉石安卓记牌器 三个老k手机版下载 手机棋牌怎么经营 蓝洞棋牌2019官网下载 牛总管技巧攻略 手机棋牌游戏排名 弈城围棋 世界泳联锦标赛25米

37414 99771 65628 15883 82347 2325082978 73018 92807

责任编辑:龙扁平文

随机推荐