ArrayList 中 replaceAll方法的作用（jdk源码分析）

关于ArrayList类中的源码

	    @Override
	    @SuppressWarnings("unchecked")
	    public void replaceAll(UnaryOperator<E> operator) {
	        Objects.requireNonNull(operator);
	        final int expectedModCount = modCount; //modCount表示list结构上被修改的次数
	        final int size = this.size;  //集合长度
	        for (int i=0; modCount == expectedModCount && i < size; i++) {
	            elementData[i] = operator.apply((E) elementData[i]);
	        }
	        if (modCount != expectedModCount) {  //如果集合在遍历过程中，被修改过，就报异常
	            throw new ConcurrentModificationException();
	        }
	        modCount++;
	    }

List中的源码

		/**
		 * 【源码注释很长，就不贴出来了，有兴趣的可以自己去看看。这里就简单解释下】
                 *  源码解释：方法用于将此列表的每个元素替换为将运算符应用于该元素的结果。操作员抛出的错误或运行时异常被转发给调用者
		 *  本人解释：用函数接口的返回结果替代原list中的值.
		 *  如果list的迭代器不支持set操作,当替换第一个元素时,会抛出异常.
		 */
	    default void replaceAll(UnaryOperator<E> operator) {
	        Objects.requireNonNull(operator);
	        final ListIterator<E> li = this.listIterator();
	        while (li.hasNext()) {
	            li.set(operator.apply(li.next()));
	        }
	    }

 

UnaryOperator<E>类

	/**
	 * 表示对单个操作数的操作，该操作数生成与其操作数类型相同的结果。
	 * 这个接口定义了一个静态方法，返回泛型对象的本身；
	 * @param <T>
	 */
	@FunctionalInterface
	public interface UnaryOperator<T> extends Function<T, T> {
 
	    /**
	     * Returns a unary operator that always returns its input argument. 
	     * 总是返回参数类型
	     * @param <T> the type of the input and output of the operator
	     * 输入的类型输出给操作者
	     * @return a unary operator that always returns its input argument
	     */
	    static <T> UnaryOperator<T> identity() {
	        return t -> t;
	    }
	}

UnaryOperator<T>继承于Function<T,T>类

/**
* Function接口定义中有两个泛型，按着接口文档说明第一个泛型是输入类型，第二泛型是结果类型
*/
@FunctionalInterface
public interface Function<T, R> {
   /**
   * apply是一个抽象类，接收一个泛型T对象，并且返回泛型R对象
   */
    R apply(T t);
    /**
     * compose方法接收一个Function参数before，该方法说明是返回一个组合的函数，首先会应用before，然后应用当前对象，换句话说就是先执行before对象的apply，再执行当前对象的apply，将两个执行逻辑串起来。
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
   /**
   * andThen方法接收一个Function参数after，与compose方法相反，它是先执行当前对象的apply方法，再执行after对象的方法。
   */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
 
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

用法

	List<String> list = new ArrayList<>();
	list.add("zhangsan");
	list.add("lisi");
	list.add("wangwu");
	list.add("zhaoer");
	list.add("xiaozhu");
	list.add("xiaoming");
	list.add("xiaoliu");
	list.replaceAll(a->a);
	list.forEach(i->System.out.print(i+"  "));

输出

zhangsan  lisi  wangwu  zhaoer  xiaozhu  xiaoming  xiaoliu  

解释

 list.replaceAll(a->a); 这句的意思是：返回自己本身，就是用自己替换自己

或者用另一个字符串替换指定的字符串，如：把张三替换成张三。

list.replaceAll(a->a.equals("zhangsan")?"张三":a);

或者

list.replaceAll(a->{
    if(a.equals("zhangsan"))
        return "张三";
    else return a;
});