import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
@Override
public String toString() {
    final StringBuilder buf = new StringBuilder( "{" );
    forEachValue( new TDoubleProcedure() {
        private boolean first = true;

        public boolean execute( double value ) {
            if ( first ) {
                first = false;
            } else {
                buf.append( ", " );
            }

            buf.append( value );
            return true;
        }
    } );
    buf.append( "}" );
    return buf.toString();
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
@Override
public String toString() {
    final StringBuilder buf = new StringBuilder( "{" );
    forEachValue( new TDoubleProcedure() {
        private boolean first = true;

        public boolean execute(final double value ) {
            if ( first ) {
                first = false;
            } else {
                buf.append( ", " );
            }

            buf.append( value );
            return false;
        }
    } );
    buf.append( "}" );
    return buf.toString();
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
@Override
public String toString() {
    final StringBuilder buf = new StringBuilder( "{" );
    forEachValue( new TDoubleProcedure() {
        private boolean first = true;

        @Override
        public boolean execute( double value ) {
            if ( first ) {
                first = false;
            } else {
                buf.append( ", " );
            }

            buf.append( value );
            return true;
        }
    } );
    buf.append( "}" );
    return buf.toString();
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/**
 * Executes <tt>procedure</tt> for each value in the map.
 *
 * @param procedure a <code>TDoubleProcedure</code> value
 * @return false if the loop over the values terminated because
 * the procedure returned false for some value.
 */
public boolean forEachValue( TDoubleProcedure procedure ) {
    Object[] keys = _set;
    double[] values = _values;
    for ( int i = values.length; i-- > 0; ) {
        if ( keys[i] != FREE && keys[i] != REMOVED
            && ! procedure.execute( values[i] ) ) {
            return false;
        }
    }
    return true;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public boolean forEach( TDoubleProcedure procedure ) {
    for ( int i = 0; i < _pos; i++ ) {
        if ( !procedure.execute( _data[ i ] ) ) {
            return false;
        }
    }
    return true;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public boolean forEachDescending( TDoubleProcedure procedure ) {
    for ( int i = _pos; i-- > 0; ) {
        if ( !procedure.execute( _data[ i ] ) ) {
            return false;
        }
    }
    return true;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public TDoubleList grep( TDoubleProcedure condition ) {
    TDoubleArrayList list = new TDoubleArrayList();
    for ( int i = 0; i < _pos; i++ ) {
        if ( condition.execute( _data[ i ] ) ) {
            list.add( _data[ i ] );
        }
    }
    return list;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public TDoubleList inverseGrep( TDoubleProcedure condition ) {
    TDoubleArrayList list = new TDoubleArrayList();
    for ( int i = 0; i < _pos; i++ ) {
        if ( !condition.execute( _data[ i ] ) ) {
            list.add( _data[ i ] );
        }
    }
    return list;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public boolean forEach(TDoubleProcedure procedure) {
    for (TDoubleLink l = head; got(l); l = l.getNext()) {
        if (!procedure.execute(l.getValue()))
            return false;
    }
    return true;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public boolean forEachDescending(TDoubleProcedure procedure) {
    for (TDoubleLink l = tail; got(l); l = l.getPrevious()) {
        if (!procedure.execute(l.getValue()))
            return false;
    }
    return true;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public TDoubleList grep(TDoubleProcedure condition) {
    TDoubleList ret = new TDoubleLinkedList();
    for (TDoubleLink l = head; got(l); l = l.getNext()) {
        if (condition.execute(l.getValue()))
            ret.add(l.getValue());
    }
    return ret;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/** {@inheritDoc} */
public TDoubleList inverseGrep(TDoubleProcedure condition) {
    TDoubleList ret = new TDoubleLinkedList();
    for (TDoubleLink l = head; got(l); l = l.getNext()) {
        if (!condition.execute(l.getValue()))
            ret.add(l.getValue());
    }
    return ret;
}
 

import gnu.trove.procedure.TDoubleProcedure; //导入依赖的package包/类
/**
 * Executes <tt>procedure</tt> for each element in the set.
 *
 * @param procedure a <code>TObjectProcedure</code> value
 * @return false if the loop over the set terminated because
 * the procedure returned false for some value.
 */
public boolean forEach( TDoubleProcedure procedure ) {
    byte[] states = _states;
    double[] set = _set;
    for ( int i = set.length; i-- > 0; ) {
        if ( states[i] == FULL && ! procedure.execute( set[i] ) ) {
            return false;
        }
    }
    return true;
}