Question

我有一些产生迭代器的代码，并且当迭代器的任何来源耗尽时，使用NoSuchElementException来发出信号。在分析此代码时，我发现99％的时间都花在方法java.util.NoSuchElementException.<init>上。

我知道C ++中的异常代价很高，但到目前为止我认为它们在Java中并不是那么糟糕。

使用异常进行流量控制是不好的做法。就在不久前我写了这篇文章，所以我不记得为什么我这样做了......

就Java所用的时间而言，在Java中抛出异常是一项昂贵的操作吗？

以下是代码：

public abstract class SequenceIterator<E> implements Iterator<E>
{
    /** Caches the next lazily generated solution, when it has already been asked for by {@link #hasNext}. */
    private E nextSolution = null;

    /** Used to indicate that the sequence has been exhausted. */
    private boolean searchExhausted = false;

    /**
     * Generates the next element in the sequence.
     *
     * @return The next element from the sequence if one is available, or <tt>null</tt> if the sequence is complete.
     */
    public abstract E nextInSequence();

    /**
     * Checks if a sequnce has more elements, caching any generated as a result of the check.
     *
     * @return <tt>true</tt> if there are more elements, <tt>false</tt> if not.
     */
    public boolean hasNext()
    {
        boolean hasNext;

        try
        {
            nextInternal();
            hasNext = true;
        }
        catch (NoSuchElementException e)
        {
            // Exception noted so can be ignored, no such element means no more elements, so 'hasNext' is false.
            e = null;

            hasNext = false;
        }

        return hasNext;
    }

    /**
     * Gets the next element from the sequence if one is available. The difference between this method and
     * {@link #nextInSequence} is that this method consumes any cached solution, so subsequent calls advance onto
     * subsequent solutions.
     *
     * @return The next solution from the search space if one is available.
     *
     * @throws NoSuchElementException If no solutions are available.
     */
    public E next()
    {
        // Consume the next element in the sequence, if one is available.
        E result = nextInternal();
        nextSolution = null;

        return result;
    }

    /**
     * Removes from the underlying collection the last element returned by the iterator (optional operation). This
     * method can be called only once per call to <tt>next</tt>. The behavior of an iterator is unspecified if the
     * underlying collection is modified while the iteration is in progress in any way other than by calling this
     * method.
     *
     * @throws UnsupportedOperationException The <tt>remove</tt> operation is not generally supported by lazy sequences.
     */
    public void remove()
    {
        throw new UnsupportedOperationException("Lazy sequences, in general, do not support removal.");
    }

    /**
     * Gets the next element from the sequence, the cached one if one has already been generated, or creating and
     * caching a new one if not. If the cached element from a previous call has not been consumed, then subsequent calls
     * to this method will not advance the iterator.
     *
     * @return The next solution from the search space if one is available.
     *
     * @throws NoSuchElementException If no solutions are available.
     */
    private E nextInternal()
    {
        // Check if the search space is already known to be empty.
        if (searchExhausted)
        {
            throw new NoSuchElementException("Sequence exhausted.");
        }

        // Check if the next soluation has already been cached, because of a call to hasNext.
        if (nextSolution != null)
        {
            return nextSolution;
        }

        // Otherwise, generate the next solution, if possible.
        nextSolution = nextInSequence();

        // Check if the solution was null, which indicates that the search space is exhausted.
        if (nextSolution == null)
        {
            // Raise a no such element exception to signal the iterator cannot continue.
            throw new NoSuchElementException("Seqeuence exhausted.");
        }
        else
        {
            return nextSolution;
        }
    }
}

Answer 1

使用异常进行流量控制的不良做法，但有其他原因，我在某种程度上被迫这样做 - Iterator接口不提供返回特殊值的方法表示“不再有价值”。

https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html#hasNext--

在Java中抛出Exception是一项昂贵的操作需要的时间？

AFAIK，尤其是为异常创建堆栈跟踪的代价很高。我不是100％确定是否在构造函数中发生这种情况或抛出异常，但以下答案表明它在构造函数中发生：https://stackoverflow.com/a/8024032/506855

在任何情况下，正如您自己提到的，如果可以避免，则不应对控制流使用异常。我认为应该可以重构您提供的代码以避免这种情况。

Answer 2

评论已经提到异常不能代替控制流。但是您不需要使用例外，因为您可以在Iterator类中引入状态，其中包含使用公共帮助方法实现hasNext()和next()的所有必要信息

例如：

public abstract class SequenceIterator<E> implements Iterator<E> {
    private boolean searchExhausted = false;
    private E next;
    private boolean hasNext;
    private boolean nextInitialized;

    public abstract E nextInSequence();

    @Override public boolean hasNext() {
        if (!nextInitialized)
            initNext();
        return hasNext;
    }

    @Override public E next() {
        if (!nextInitialized)
            initNext();
        if (!hasNext())
            throw new NoSuchElementException();
        nextInitialized = false;
        return next;
    }

    private void initNext() {
        hasNext = false;
        nextInitialized = true;

        if (!searchExhausted) {
            next = nextInSequence();
            hasNext = next != null;
        }
    }
}

在Java中抛出一个昂贵的Exception？

2 个答案: