Java工具： 一个类型安全的 WeakArray

有的地方要用一个简单的数组缓存运算结果，空间换时间，但是要求万一内存不够，要这些结果能被释放(WeakReference)，所以有了这个工具类。

/*
* Copyright 2012 raistlic (raistlic@gmail.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.lang.ref.WeakReference;
import java.util.Iterator;

/**
* This class simply encapsulates an array to be used as a cache, which holds
* weak references.
*
* It is intended to store "not so important" contents, which can be GCed
* when required.
*
* The iterator of this class can be used to iterate it, or remove elements
* from it, removing elements using the iterator will not effect the subsequent
* elements' positions.
*
* @author raistlic
* @date   27/09/2012
*/
public class WeakArray<E> implements Iterable<E> {

@SuppressWarnings({"unchecked", "rawtypes"})
private WeakReference<E>[] data;
public WeakArray(int size) {

if( size < 0 )
throw new IllegalArgumentException("Invalid array size: " + size);

data = (WeakReference<E>[])new WeakReference[size];
}

public int length() {

return data.length;
}

public void set(int index, E element) {

// potentially throws ArrayIndexOutOfBoundsException
if( get(index) != element )
data[index] = new WeakReference<E>(element);
}

public E get(int index) {

// potentially throws ArrayIndexOutOfBoundsException
WeakReference<E> ref = data[index];
return ref == null ? null : ref.get();
}

public void remove(int index) {

// potentially throws ArrayIndexOutOfBoundsException
data[index] = null;
}

@Override
public Iterator<E> iterator() {

return new IndexIterator();
}

private class IndexIterator implements Iterator<E> {

private int index = 0;

@Override
public boolean hasNext() {

return index < length();
}

@Override
public E next() {

// potentially throws ArrayIndexOutOfBoundsException
E result = get(index);
index++;
return result;
}

@Override
public void remove() {

// potentially throws ArrayIndexOutOfBoundsException
WeakArray.this.remove(index);
index++;
}
}
}

上一篇文章里用来计算阶乘的工具类 Calculator，可以使用 WeakArray 来cache运算结果，修改如下：

/*
* Copyright 2012 raistlic (raistlic@gmail.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.math.BigInteger;

/**
* This class is intended to provide convenient facilities for
* frequently used maths calculations that {@code java.lang.Math}
* does not cover.
*
* @date   08/08/2012
* @author raistlic
*/
public final class Calculator {

private Calculator() {}

private static final WeakArray<BigInteger> FACT_POOL =
new WeakArray<BigInteger>(1024);
public static BigInteger factorial(int number) {

if( number < 0 )
throw new IllegalArgumentException();

BigInteger result = null;

if( number < FACT_POOL.length() )
result = FACT_POOL.get(number);

if( result == null ) {

int lastCachedIndex = lastCachedFactIndex(number);
if( lastCachedIndex > 0 )
result = FACT_POOL.get(lastCachedIndex);
if( result == null )
result = BigInteger.ONE;

for(int i = Math.max(2, lastCachedIndex+1); i <= number; i++) {

result = result.multiply(BigInteger.valueOf(i));
if( i < FACT_POOL.length() )
FACT_POOL.set(i, result);
}
}
return result;
}

private static int lastCachedFactIndex(int number) {

for(int i=Math.min(number, FACT_POOL.length()-1); i>=0; i--) {

if( FACT_POOL.get(i) != null )
return i;
}

return -1;
}
}