counting.java

java 的源代码

package com.reddragon2046.base.utilities.data.algorithms;

import com.reddragon2046.base.utilities.data.*;
import com.reddragon2046.base.utilities.data.functions.MinusNumber;
import com.reddragon2046.base.utilities.data.functions.PlusNumber;
import com.reddragon2046.base.utilities.data.util.InsertIterator;
import com.reddragon2046.base.utilities.data.util.IteratorFactory;
import java.util.*;

public final class Counting
{

    private Counting()
    {
    }

    private static int count(InputIterator first, InputIterator last, Object object)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        InputIterator firstx = (InputIterator)first.clone();
        int n = 0;
        while(!firstx.equals(last))
        {
            Object element = firstx.next();
            if(element.equals(object))
                n++;
        }
        return n;
    }

    public static int count(Collection c, Object object)
    {
        return count(IteratorFactory.start(c), IteratorFactory.finish(c), object);
    }

    private static int countIf(InputIterator first, InputIterator last, UnaryPredicate predicate)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        InputIterator firstx = (InputIterator)first.clone();
        int n = 0;
        while(!firstx.equals(last))
            if(predicate.execute(firstx.next()))
                n++;
        return n;
    }

    public static int countIf(Collection collection, UnaryPredicate predicate)
    {
        return countIf(IteratorFactory.start(collection), IteratorFactory.finish(collection), predicate);
    }

    private static Number accumulate(InputIterator first, InputIterator last, Number init)
    {
        return accumulate(first, last, init, ((BinaryFunction) (new PlusNumber(init.getClass()))));
    }

    public static Number accumulate(Collection collection, Number init)
    {
        return accumulate(IteratorFactory.start(collection), IteratorFactory.finish(collection), init, ((BinaryFunction) (new PlusNumber(init.getClass()))));
    }

    private static Number accumulate(InputIterator first, InputIterator last, Number init, BinaryFunction function)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        for(InputIterator firstx = (InputIterator)first.clone(); !firstx.equals(last);)
            init = (Number)function.execute(init, firstx.next());

        return init;
    }

    public static Number accumulate(Collection collection, Number init, BinaryFunction function)
    {
        return accumulate(IteratorFactory.start(collection), IteratorFactory.finish(collection), init, function);
    }

    private static OutputIterator adjacentDifference(InputIterator first, InputIterator last, OutputIterator result)
    {
        return adjacentDifference(first, last, result, ((BinaryFunction) (new MinusNumber())));
    }

    public static OutputIterator adjacentDifference(Collection input, OutputIterator result)
    {
        return adjacentDifference(IteratorFactory.start(input), IteratorFactory.finish(input), result, ((BinaryFunction) (new MinusNumber())));
    }

    public static void adjacentDifference(Collection source, Collection destination)
    {
        adjacentDifference(IteratorFactory.start(source), IteratorFactory.finish(source), ((OutputIterator) (new InsertIterator(destination))), ((BinaryFunction) (new MinusNumber())));
    }

    public static List adjacentDifference(Collection source)
    {
        Vector destination = new Vector();
        adjacentDifference(source, ((Collection) (destination)));
        return destination;
    }

    private static OutputIterator adjacentDifference(InputIterator first, InputIterator last, OutputIterator result, BinaryFunction function)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        OutputIterator resultx = (OutputIterator)result.clone();
        if(first.equals(last))
            return resultx;
        InputIterator firstx = (InputIterator)first.clone();
        resultx.put(firstx.get());
        resultx.advance();
        Object tmp;
        for(Object value = firstx.next(); !firstx.equals(last); value = tmp)
        {
            tmp = firstx.next();
            resultx.put(function.execute(tmp, value));
            resultx.advance();
        }

        return resultx;
    }

    public static OutputIterator adjacentDifference(Collection input, OutputIterator result, BinaryFunction function)
    {
        return adjacentDifference(IteratorFactory.start(input), IteratorFactory.finish(input), result, function);
    }

    public static void adjacentDifference(Collection source, Collection destination, BinaryFunction function)
    {
        adjacentDifference(IteratorFactory.start(source), IteratorFactory.finish(source), ((OutputIterator) (new InsertIterator(destination))), function);
    }
}