Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Copyright (c) 2008, Nathan Sweet
   * All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
   * conditions are met:
   * 
   * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
   * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
   * disclaimer in the documentation and/or other materials provided with the distribution.
  * - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
  * from this software without specific prior written permission.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 
 package com.esotericsoftware.kryo.util;
 
A resizable, ordered or unordered int array. Avoids the boxing that occurs with ArrayList<Integer>. If unordered, this class avoids a memory copy when removing elements (the last element is moved to the removed element's position).

Author(s):
Nathan Sweet
 
 public class IntArray {
 	public int[] items;
 	public int size;
 	public boolean ordered;

Creates an ordered array with a capacity of 16.
 
 	public IntArray () {
 		this(true, 16);
 	}

Creates an ordered array with the specified capacity.
 
 	public IntArray (int capacity) {
 		this(truecapacity);
 	}

Parameters:
ordered If false, methods that remove elements may change the order of other elements in the array, which avoids a memory copy.
capacity Any elements added beyond this will cause the backing array to be grown.
 
 	public IntArray (boolean orderedint capacity) {
 		this. = ordered;
 		 = new int[capacity];
 	}

Creates a new array containing the elements in the specific array. The new array will be ordered if the specific array is ordered. The capacity is set to the number of elements, so any subsequent elements added will cause the backing array to be grown.
 
 	public IntArray (IntArray array) {
 		this. = array.ordered;
 		 = array.size;
 		 = new int[];
 		System.arraycopy(array.items, 0, , 0, );
 	}

Creates a new ordered array containing the elements in the specified array. The capacity is set to the number of elements, so any subsequent elements added will cause the backing array to be grown.
 
 	public IntArray (int[] array) {
 		this(truearray);
 	}

Creates a new array containing the elements in the specified array. The capacity is set to the number of elements, so any subsequent elements added will cause the backing array to be grown.

Parameters:
ordered If false, methods that remove elements may change the order of other elements in the array, which avoids a memory copy.
 
 	public IntArray (boolean orderedint[] array) {
 		this(orderedarray.length);
 		 = array.length;
 		System.arraycopy(array, 0, , 0, );
 	}
 
 	public void add (int value) {
 		int[] items = this.;
 		if ( == items.lengthitems = resize(Math.max(8, (int)( * 1.75f)));
 		items[++] = value;
 	}
 
 	public void addAll (IntArray array) {
 		addAll(array, 0, array.size);
 	}
 
 	public void addAll (IntArray arrayint offsetint length) {
 		if (offset + length > array.size)
 			throw new IllegalArgumentException("offset + length must be <= size: " + offset + " + " + length + " <= " + array.size);
 		addAll(array.itemsoffsetlength);
 	}
 
 	public void addAll (int[] array) {
 		addAll(array, 0, array.length);
 	}
 
 	public void addAll (int[] arrayint offsetint length) {
 		int[] items = this.;
 		int sizeNeeded =  + length - offset;
 		if (sizeNeeded >= items.lengthitems = resize(Math.max(8, (int)(sizeNeeded * 1.75f)));
		System.arraycopy(arrayoffsetitemslength);
		 += length;
	}
	public int get (int index) {
		if (index >= throw new IndexOutOfBoundsException(String.valueOf(index));
		return [index];
	}
	public void set (int indexint value) {
		if (index >= throw new IndexOutOfBoundsException(String.valueOf(index));
		[index] = value;
	}
	public void insert (int indexint value) {
		int[] items = this.;
		if ( == items.lengthitems = resize(Math.max(8, (int)( * 1.75f)));
		if ()
			System.arraycopy(itemsindexitemsindex + 1,  - index);
		else
			items[] = items[index];
		items[index] = value;
	}
	public void swap (int firstint second) {
		if (first >= throw new IndexOutOfBoundsException(String.valueOf(first));
		if (second >= throw new IndexOutOfBoundsException(String.valueOf(second));
		int[] items = this.;
		int firstValue = items[first];
		items[first] = items[second];
		items[second] = firstValue;
	}
	public boolean contains (int value) {
		int i =  - 1;
		int[] items = this.;
		while (i >= 0)
			if (items[i--] == valuereturn true;
		return false;
	}
	public int indexOf (int value) {
		int[] items = this.;
		for (int i = 0, n = i < ni++)
			if (items[i] == valuereturn i;
		return -1;
	}
	public boolean removeValue (int value) {
		int[] items = this.;
		for (int i = 0, n = i < ni++) {
			if (items[i] == value) {
				return true;
			}
		}
		return false;
	}

Removes and returns the item at the specified index.
	public int removeIndex (int index) {
		if (index >= throw new IndexOutOfBoundsException(String.valueOf(index));
		int[] items = this.;
		int value = items[index];
		if ()
			System.arraycopy(itemsindex + 1, itemsindex - index);
		else
			items[index] = items[];
		return value;
	}

Removes and returns the last item.
	public int pop () {
		return [--];
	}

Returns the last item.
	public int peek () {
		return [ - 1];
	}
	public void clear () {
		 = 0;
	}

Reduces the size of the backing array to the size of the actual items. This is useful to release memory when many items have been removed, or if it is known that more items will not be added.
	public void shrink () {
	}

Increases the size of the backing array to acommodate the specified number of additional items. Useful before adding many items to avoid multiple backing array resizes.

Returns:
items
	public int[] ensureCapacity (int additionalCapacity) {
		int sizeNeeded =  + additionalCapacity;
		if (sizeNeeded >= .resize(Math.max(8, sizeNeeded));
		return ;
	}
	protected int[] resize (int newSize) {
		int[] newItems = new int[newSize];
		int[] items = this.;
		System.arraycopy(items, 0, newItems, 0, Math.min(items.lengthnewItems.length));
		this. = newItems;
		return newItems;
	}
	public void sort () {
		Arrays.sort(, 0, );
	}
	public void reverse () {
		for (int i = 0, lastIndex =  - 1, n =  / 2; i < ni++) {
			int ii = lastIndex - i;
			int temp = [i];
			[i] = [ii];
			[ii] = temp;
		}
	}

Reduces the size of the array to the specified size. If the array is already smaller than the specified size, no action is taken.
	public void truncate (int newSize) {
		if ( > newSize = newSize;
	}
	public int[] toArray () {
		int[] array = new int[];
		System.arraycopy(, 0, array, 0, );
		return array;
	}
	public String toString () {
		if ( == 0) return "[]";
		int[] items = this.;
		StringBuilder buffer = new StringBuilder(32);
		buffer.append('[');
		buffer.append(items[0]);
		for (int i = 1; i < i++) {
			buffer.append(", ");
			buffer.append(items[i]);
		}
		buffer.append(']');
		return buffer.toString();
	}
	public String toString (String separator) {
		if ( == 0) return "";
		int[] items = this.;
		StringBuilder buffer = new StringBuilder(32);
		buffer.append(items[0]);
		for (int i = 1; i < i++) {
			buffer.append(separator);
			buffer.append(items[i]);
		}
		return buffer.toString();
	}
New to GrepCode? Check out our FAQ X