深入学习java源码之ArrayList.spliterator()与ArrayList.subList()

深入学习java源码之ArrayList.spliterator()与ArrayList.subList()

抽象类

面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类。这两者有太多相似的地方，又有太多不同的地方。

抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。

　　包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：

　　1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

　　2）抽象类不能用来创建对象；

　　3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

　　在其他方面，抽象类和普通的类并没有区别。 接口，英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数。从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。

接口中可以含有变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误），并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。 要让一个类遵循某组特地的接口需要使用implements关键字，具体格式如下： 允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口，就必须实现该接口中的所有方法。对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法。

抽象类和接口的区别 　　1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；

　　2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；

　　3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

　　4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。 什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。 而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

网上流传最广泛的例子：门和警报的例子：门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：

abstract class Door {
    public abstract void open();
    public abstract void close();
}

interface Door {
    public abstract void open();
    public abstract void close();
}

但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路：

　　1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；

　　2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。

从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。 因此最好的解决办法是单独将报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

interface Alram {
    void alarm();
}
 
abstract class Door {
    void open();
    void close();
}
 
class AlarmDoor extends Door implements Alarm {
    void oepn() {
      //....
    }
    void close() {
      //....
    }
    void alarm() {
      //....
    }
}

抽象类的使用

public abstract class AbsOpeWorker{
	protected String[] synSqls = null;
	protected String[] intoSqls = null;
	protected String ruleCode = null;
	
	public abstract String[] initSynSqls();
	
	
	public abstract String[] initIntoSqls();
	
	public abstract String initRuleCode();
	
	public abstract void synData();
}

抽象类继承抽象类并且实现里面的方法

public abstract class AbsOpeByTimeWorker extends AbsOpeWorker{

	protected PrSynRule prSynRule = null;
	protected Date startDate = null;
	protected Date endDate = null;
	public void init() {
		this.ruleCode = initRuleCode();
		this.synSqls = initSynSqls();
		this.intoSqls = initIntoSqls();
	}
	@Override
	public String[] initSynSqls() {
		List ruleList = prSynRuleService.querySynRuleList(prSynRule);
		if(ruleList!=null && ruleList.size()>0){
			prSynRule = ruleList.get(0);
			startDate = startTime();
		}
		return new String[]{prSynRule.getContent()};
	}
	
	public abstract Date startTime();
	
	public abstract Date endTime();
	
	@Override
	public String[] initIntoSqls() {
		return null;
	}
	@Override
	public void synData() {
		String startTime = prSynRule.getPointer();
		endDate = endTime();
		this.init();
    }
	@Override
	public String initRuleCode() {
		String ruleCode = setRuleCode();//"";
		if(prSynRule==null){
			prSynRule = new PrSynRule();
		}
		prSynRule.setRuleCode(ruleCode);
		return ruleCode;
	}
	public abstract String setRuleCode();
	
	public abstract int insertObject(List t);
	
	public abstract Class getEntityClass();
}

继承抽象类并调通过this和super用抽象类中的方法

public class PipOperationWorker extends AbsOpeByTimeWorker{

	public PipOperationWorker(String ruleCode) {
		this.ruleCode = ruleCode;
	}
	private String ruleCode = "";
	private int insertCount = 8000;
	
	@Override
	public int insertObject(List t) {
	
	}
	@Override
	public String setRuleCode() {
		return ruleCode;
	}
	@Override
	public Date startTime() {
		return DateUtil.parse(prSynRule.getPointer(), "yyyy-MM-dd HH:mm:ss", null);
	}
	@Override
	public void synData() {
		this.init();
		if("1".equals(prSynRule.getType())){
			super.synData();
		}else if("2".equals(prSynRule.getType())){
			new PipType2Worker(prSynRule.getRuleCode()).synData();
		}else if("3".equals(prSynRule.getType()))
		{
			new PipType3Worker(prSynRule.getRuleCode()).synData();
		}
	}
	@Override
	public Date endTime() {
		Date now = new Date();
		String lastTime = "";
		if(prSynRule!=null && !StringUtil.isEmpty(prSynRule.getPointer())){
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(startDate);
			if(prSynRule.getTimeInterval()==1){
				calendar.add(Calendar.DAY_OF_MONTH, 1);
			}else if(prSynRule.getTimeInterval()==2){
				calendar.add(Calendar.MONTH, 1);
			}else if(prSynRule.getTimeInterval()==4){
				calendar.add(Calendar.YEAR, 1);
			}else if(prSynRule.getTimeInterval() == 5 && "1".equals(prSynRule.getIsOldData())) {
				calendar.add(Calendar.HOUR, 1);
				SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
				now = DateUtil.parse(df.format(calendar.getTime()), "yyyy-MM-dd HH:mm:ss", null);
				return now;
			}
			lastTime = calendar.get(Calendar.YEAR)+"-"+(calendar.get(Calendar.MONTH)+1)+"-"+calendar.get(Calendar.DAY_OF_MONTH);
			lastTime = lastTime+ " 00:00:00";
			now = DateUtil.parse(lastTime, "yyyy-MM-dd HH:mm:ss", null);
		}
		if(prSynRule!=null && !"1".equals(prSynRule.getIsOldData())) {
			now = new Date();
		}
		return now;
	}
	@Override
	public Class getEntityClass() {
		Class _class = null;
		try {
			_class = Class.forName(prSynRule.getModeClass());
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
			logger.error(MessageFormat.format("====sys worker {0} create ModeClass exception====", ruleCode),e);
		}
		return _class;
	}
	public PipOperationWorker setRuleCode(String ruleCode) {
		this.ruleCode = ruleCode;
		return this;
	}
}

调用方法

new PipOperationWorker("pr_data").synData();

 

ArrayList的接口的实现

Modifier and TypeMethod and DescriptionvoidforEach(Consumer c)

如果此集合包含指定 集合中的所有元素，则返回true。

booleanisEmpty()

如果此集合不包含元素，则返回 true 。

abstract Iteratoriterator()

返回包含在该集合中的元素的迭代器。

booleanremove(Object o)

从该集合中删除指定元素的单个实例（如果存在）（可选操作）。

booleanremoveAll(Collection c)

删除指定集合中包含的所有此集合的元素（可选操作）。

booleanretainAll(Collection c)

仅保留此集合中包含在指定集合中的元素（可选操作）。

abstract intsize()

返回此集合中的元素数。

Object[]toArray()

返回一个包含此集合中所有元素的数组。

T[]toArray(T[] a)

返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

StringtoString()

返回此集合的字符串表示形式。

package java.util;


public abstract class AbstractCollection implements Collection {

    protected AbstractCollection() {
    }

    // Query Operations
    public abstract Iterator iterator();

    public abstract int size();

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean contains(Object o) {
        Iterator it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];
        Iterator it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    @SuppressWarnings("unchecked")
    public  T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator it = iterator();

        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) { // fewer elements than expected
                if (a == r) {
                    r[i] = null; // null-terminate
                } else if (a.length < i) {
                    return Arrays.copyOf(r, i);
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            r[i] = (T)it.next();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    @SuppressWarnings("unchecked")
    private static  T[] finishToArray(T[] r, Iterator it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {
                int newCap = cap + (cap >> 1) + 1;
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    // Modification Operations
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    public boolean remove(Object o) {
        Iterator it = iterator();
        if (o==null) {
            while (it.hasNext()) {
                if (it.next()==null) {
                    it.remove();
                    return true;
                }
            }
        } else {
            while (it.hasNext()) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }


    // Bulk Operations
    public boolean containsAll(Collection c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

    public boolean addAll(Collection c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    public boolean retainAll(Collection c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    public void clear() {
        Iterator it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }


    //  String conversion
    public String toString() {
        Iterator it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

}

 

List

有序集合（也称为序列 ）。 该界面的用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。  与集合不同，列表通常允许重复的元素。 更正式地，列表通常允许元素e1和e2成对使得e1.equals(e2) ，并且如果它们允许空元素，它们通常允许多个空元素。 有人可能希望实现一个禁止重复的列表，当用户尝试插入时会抛出运行时异常，但是我们预计这种使用是罕见的。 

该List接口放置额外的约定，超过在Collection指定接口上的iterator，add，remove，equals和hashCode方法合同。 其他继承方法的声明也包括在这里以方便。 

List接口提供四种位置（索引）访问列表元素的方法。 列表（如Java数组）为零。 请注意，这些操作可能与某些实现的索引值（例如LinkedList类）成时执行。 因此，如果调用者不知道实现，则通过迭代列表中的元素通常优先于索引。 

所述List接口提供了一个特殊的迭代器，称为ListIterator，其允许元件插入和更换，并且除了该Iterator接口提供正常操作的双向访问。 提供了一种方法来获取从列表中的指定位置开始的列表迭代器。 

List接口提供了两种方法来搜索指定的对象。 从性能角度来说，谨慎使用这些方法。 在许多实现中，它们将执行昂贵的线性搜索。 

List接口提供了两种方法来有效地插入和删除列表中任意一点的多个元素。 

注意：虽然列表允许将其自身作为元素，但建议您非常小心： equals和hashCode方法在这样的列表中不再被很好地定义。 

某些列表实现对它们可能包含的元素有限制。 例如，一些实现禁止空元素，有些实现对元素的类型有限制。 尝试添加不合格元素会引发未经检查的异常，通常为NullPointerException或ClassCastException 。 尝试查询不合格元素的存在可能会引发异常，或者可能只是返回false; 一些实现将展现出前者的行为，一些实现将展现出后者。 更一般来说，对于不完成不会导致将不合格元素插入到列表中的不合格元素的操作，可能会在执行选项时抛出异常或成功。 此异常在此接口的规范中标记为“可选”。 

Modifier and TypeMethod and Descriptionbooleanadd(E e)

将指定的元素追加到此列表的末尾（可选操作）。

voidadd(int index, E element)

将指定的元素插入此列表中的指定位置（可选操作）。

booleanaddAll(Collection c)

如果此列表包含指定 集合的所有元素，则返回true。

booleanequals(Object o)

将指定的对象与此列表进行比较以获得相等性。

Eget(int index)

返回此列表中指定位置的元素。

inthashCode()

返回此列表的哈希码值。

intindexOf(Object o)

返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

booleanisEmpty()

如果此列表不包含元素，则返回 true 。

Iteratoriterator()

以正确的顺序返回该列表中的元素的迭代器。

intlastIndexOf(Object o)

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

ListIteratorlistIterator()

返回列表中的列表迭代器（按适当的顺序）。

ListIteratorlistIterator(int index)

从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。

Eremove(int index)

删除该列表中指定位置的元素（可选操作）。

booleanremove(Object o)

从列表中删除指定元素的第一个出现（如果存在）（可选操作）。

booleanremoveAll(Collection c)

从此列表中删除包含在指定集合中的所有元素（可选操作）。

default voidreplaceAll(UnaryOperator operator)

将该列表的每个元素替换为将该运算符应用于该元素的结果。

booleanretainAll(Collection c)

仅保留此列表中包含在指定集合中的元素（可选操作）。

Eset(int index, E element)

用指定的元素（可选操作）替换此列表中指定位置的元素。

intsize()

返回此列表中的元素数。

default voidsort(Comparator c); boolean addAll(Collection c); boolean retainAll(Collection c); default void replaceAll(UnaryOperator operator) { Objects.requireNonNull(operator); final ListIterator li = this.listIterator(); while (li.hasNext()) { li.set(operator.apply(li.next())); } } @SuppressWarnings({"unchecked", "rawtypes"}) default void sort(Comparator c)

如果此集合包含指定 集合中的所有元素，则返回true。

booleanequals(Object o)

将指定的对象与此集合进行比较以获得相等性。

inthashCode()

返回此集合的哈希码值。

booleanisEmpty()

如果此集合不包含元素，则返回 true 。

Iteratoriterator()

返回此集合中的元素的迭代器。

default StreamparallelStream()

返回可能并行的 Stream与此集合作为其来源。

booleanremove(Object o)

从该集合中删除指定元素的单个实例（如果存在）（可选操作）。

booleanremoveAll(Collection c)

删除指定集合中包含的所有此集合的元素（可选操作）。

default booleanremoveIf(Predicate c)

仅保留此集合中包含在指定集合中的元素（可选操作）。

intsize()

返回此集合中的元素数。

default Spliteratorspliterator()

创建一个Spliterator在这个集合中的元素。

default Streamstream()

返回以此集合作为源的顺序 Stream 。

Object[]toArray()

返回一个包含此集合中所有元素的数组。

T[]toArray(T[] a)

返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

package java.util;

import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public interface Collection extends Iterable {
    // Query Operations
    int size();

    boolean isEmpty();

    boolean contains(Object o);

    Iterator iterator();

    Object[] toArray();

     T[] toArray(T[] a);

    // Modification Operations
    boolean add(E e);

    boolean remove(Object o);


    // Bulk Operations
    boolean containsAll(Collection c);

    boolean addAll(Collection c);

    default boolean removeIf(Predicate c);

    void clear();


    // Comparison and hashing
    boolean equals(Object o);
	
    int hashCode();

    @Override
    default Spliterator spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    default Stream stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    default Stream parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

 

Iterable

实现此接口允许对象成为“for-each loop”语句的目标

Modifier and TypeMethod and Descriptiondefault voidforEachRemaining(Consumer