Java tutorial
/* * Copyright (c) 1998 - 2005 Versant Corporation * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * Versant Corporation - initial API and implementation */ /** * Fast StringBuffer replacement that allows direct access to the underlying * char[]. This is based com.sosnoski.util.array.CharArray from * Sosnoski Software Solutions, Inc. */ public final class CharBuf { private char[] buf; private int size; public CharBuf() { this(64); } public CharBuf(int capacity) { buf = new char[capacity]; } public CharBuf(String s) { this(s.length()); append(s); } public CharBuf(CharBuf s) { this(s.size); size = s.size; System.arraycopy(s.buf, 0, buf, 0, size); } public int size() { return size; } public void clear() { size = 0; } private void ensureCapacity(int len) { if (size + len > buf.length) { int n = buf.length * 3 / 2 + 1; if (size + len > n) { n = size + len; } char[] a = new char[n]; System.arraycopy(buf, 0, a, 0, size); buf = a; } } /** * Append ch and return its index. */ public int append(char ch) { ensureCapacity(size + 1); int start = size; buf[size++] = ch; return start; } /** * Append i and return its index. */ public int append(int i) { return append(Integer.toString(i)); } /** * Append s and return its index. */ public int append(String s) { return append(s.toCharArray()); } /** * Append a and return its index. */ public int append(char[] a) { int n = a.length; ensureCapacity(size + n); int start = size; System.arraycopy(a, 0, buf, size, n); size += n; return start; } /** * Replace characters from i onwards with supplied characters. This does * not do any error checking or make any attempt to expand the buffer * for performance reasons. */ public void replace(int i, char[] text) { System.arraycopy(text, 0, buf, i, text.length); } /** * Replace characters from first to last - 1 with c. This does * not do any error checking for performance reasons. */ public void replace(int first, int last, char c) { for (int i = first; i < last; i++) { buf[i] = c; } } public String toString() { return new String(buf, 0, size); } /** * Constructs and returns a simple array containing the same data as held * in a portion of this growable array. */ public char[] toArray(int offset, int length) { char[] a = new char[length]; System.arraycopy(buf, offset, a, 0, length); return a; } public void setSize(int sz) { size = sz; } /** * Construct a <code>String</code> from a portion of the character sequence * present. */ public String toString(int offset, int length) { return new String(buf, offset, length); } /** * Insert the characters from a <code>char[]</code> into the array. */ public void insert(int offset, char[] text) { adjust(offset, offset, text.length); System.arraycopy(text, 0, buf, offset, text.length); } /** * Insert the characters from a <code>String</code> into the array. */ public void insert(int offset, String text) { adjust(offset, offset, text.length()); text.getChars(0, text.length(), buf, offset); } /** * Replace a character range in the array with the characters from a * <code>String</code>. */ public void replace(int from, int to, String text) { adjust(from, to, text.length()); text.getChars(0, text.length(), buf, from); } /** * Replace a character range in the array with the characters from a * <code>char[]</code>. */ public void replace(int from, int to, char[] text) { adjust(from, to, text.length); System.arraycopy(text, 0, buf, from, text.length); } /** * Adjust the characters in the array to make room for an insertion or * replacement. Depending on the relative sizes of the range being * replaced and the range being inserted, this may move characters past * the start of the replacement range up or down in the array. * * @param from index number of first character to be replaced * @param to index number past last character to be replaced * @param length length of character range being inserted */ protected void adjust(int from, int to, int length) { if (from >= 0 && to < size && from <= to) { int change = from + length - to; if (change > 0) { ensureCapacity(size + change); } if (to < size) { System.arraycopy(buf, to, buf, to + change, size - to); size += change; } } else { throw new ArrayIndexOutOfBoundsException("Invalid remove range"); } } /** * Set the value at an index position in the array. */ public void set(int index, char value) { buf[index] = value; } /** * Remove a range of value from the array. The index positions for values * above the range removed are decreased by the number of values removed. * * @param from index number of first value to be removed * @param to index number past last value to be removed */ public void remove(int from, int to) { if (from >= 0 && to <= size && from <= to) { if (to < size) { int change = from - to; System.arraycopy(buf, to, buf, from, size - to); size += change; } } else { throw new ArrayIndexOutOfBoundsException("Invalid remove range"); } } }