/** * Compares this buffer to another. * * <p>Two double buffers are compared by comparing their sequences of remaining elements * lexicographically, without regard to the starting position of each sequence within its * corresponding buffer. * * <p>A double buffer is not comparable to any other type of object. * * @return A negative integer, zero, or a positive integer as this buffer is less than, equal to, * or greater than the given buffer */ public int compareTo(DoubleBuffer that) { int n = this.position() + Math.min(this.remaining(), that.remaining()); for (int i = this.position(), j = that.position(); i < n; i++, j++) { double v1 = this.get(i); double v2 = that.get(j); if (v1 == v2) continue; if ((v1 != v1) && (v2 != v2)) // For float and double continue; if (v1 < v2) return -1; return +1; } return this.remaining() - that.remaining(); }
/** * Relative bulk <i>put</i> method <i>(optional operation)</i>. * * <p>This method transfers the doubles remaining in the given source buffer into this buffer. If * there are more doubles remaining in the source buffer than in this buffer, that is, if * <tt>src.remaining()</tt> <tt>></tt> <tt>remaining()</tt>, then no doubles are * transferred and a {@link BufferOverflowException} is thrown. * * <p>Otherwise, this method copies <i>n</i> = <tt>src.remaining()</tt> doubles from the * given buffer into this buffer, starting at each buffer's current position. The positions of * both buffers are then incremented by <i>n</i>. * * <p>In other words, an invocation of this method of the form <tt>dst.put(src)</tt> has exactly * the same effect as the loop * * <pre> * while (src.hasRemaining()) * dst.put(src.get()); </pre> * * except that it first checks that there is sufficient space in this buffer and it is potentially * much more efficient. * * @param src The source buffer from which doubles are to be read; must not be this buffer * @return This buffer * @throws BufferOverflowException If there is insufficient space in this buffer for the remaining * doubles in the source buffer * @throws IllegalArgumentException If the source buffer is this buffer * @throws ReadOnlyBufferException If this buffer is read-only */ public DoubleBuffer put(DoubleBuffer src) { if (src == this) throw new IllegalArgumentException(); int n = src.remaining(); if (n > remaining()) throw new BufferOverflowException(); for (int i = 0; i < n; i++) put(src.get()); return this; }
/** * Tells whether or not this buffer is equal to another object. * * <p>Two double buffers are equal if, and only if, * * <p> * * <ol> * <li> * <p>They have the same element type, * <li> * <p>They have the same number of remaining elements, and * <li> * <p>The two sequences of remaining elements, considered independently of their starting * positions, are pointwise equal. * </ol> * * <p>A double buffer is not equal to any other type of object. * * @param ob The object to which this buffer is to be compared * @return <tt>true</tt> if, and only if, this buffer is equal to the given object */ public boolean equals(Object ob) { if (!(ob instanceof DoubleBuffer)) return false; DoubleBuffer that = (DoubleBuffer) ob; if (this.remaining() != that.remaining()) return false; int p = this.position(); for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--) { double v1 = this.get(i); double v2 = that.get(j); if (v1 != v2) { if ((v1 != v1) && (v2 != v2)) // For float and double continue; return false; } } return true; }