从Python学习中得到的一点启发 - Java逆向索引ArrayList

看了几天Python，感觉记忆力不行了，很多东西记不住了。但是终归是得到了一点知识：重写一个ArrayList，允许从负值的索引得到指定的项。然后写一个得到斐波拉契数组的方法，这种方法要比递归调用的方式好很多，性能上大概提升几百倍。

关于Java的递归调用的性能：

　　Java中的每一个方法调用都会把这个调用的方法加入到调用栈，等到一个方法执行完毕返回的时候（return，如果没有显式写return语句，实际上还是有的 - 方法内还有一个指针，用来执向当前执行的代码位置），才把方法从栈中弹出来，

而在Java中，这个栈的维护会很费性能，而且递归调用还有个5000次的约束。所以，在Java中尽量不要使用递归调用。

　　如果在Android中还可以使用SoarseIntArray来代替ArrayList，那样性能更好些，避免了大量创建BigInteger对象的，性能还能再提升N倍，N>100
SparseIntArray sia = new SparseIntArray();

现在看下这个实现吧：

1 package com.xinye.test;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
* 斐波那契数列的各种实现方式
* F0 = 0
* F1 = 1
* Fn = Fn-2 + Fn-1
*
*
* @author xinye
*
*/
public class Test {
public static void main(String[] args) {
long startTime = System.currentTimeMillis();
XYArrayList<BigInteger> list = getFiboArray(1, 1, 50);
for(BigInteger b : list){
System.out.println(b.toString());
}
System.out.println("计算" + list.size() + "项花费的时间是：" + (System.currentTimeMillis() - startTime) + "毫秒");
}
/**
* 得到斐波那契数组
* @param first 数组第一项
* @param second 数组第一项
* @param index 要得到的最大项，从2开始
* @return
*/
public static XYArrayList<BigInteger> getFiboArray(int first,int second,int index){
XYArrayList<BigInteger> feiboArray = new XYArrayList<BigInteger>();
if(index <= 0){
return feiboArray;
}
BigInteger bi01 = BigInteger.valueOf(first);
feiboArray.add(bi01);
if(index == 1){
return feiboArray;
}
BigInteger bi02 = BigInteger.valueOf(second);
feiboArray.add(bi02);
if(index == 2){
return feiboArray;
}
for(int i = 2;i < index;i++){
feiboArray.add(feiboArray.get(-1).add(feiboArray.get(-2)));
}
return feiboArray;
}
}
/**
* 一个采用了负值索引的ArrayList
* 最后一项索引-1，倒数第二项-2，倒数第三项-3
* 也可以正向取值：0,1,2,3,4,5
*
* @author xinye
*
* @param <E>
*/
class XYArrayList <E> extends ArrayList<E>{

/**
*
*/
private static final long serialVersionUID = -1319739564479533206L;

public E get(int index){

if(index < 0){
index = index + size();
}
return super.get(index);
}
public E set(int index,E element){
if(index < 0){
index = index + size();
}
return super.set(index, element);
}
public void add(int index, E element) {
if(index < 0){
index = index + size();
}
super.add(index, element);
}

public boolean addAll(int index, Collection<? extends E> c) {
if(index < 0){
index = index + size();
}
return super.addAll(index, c);
}
public E remove(int index) {
if(index < 0){
index = index + size();
}
return super.remove(index);
}
/**
* 删除指定范围内的对象
* 无论从正向取值还是负向取值，fromIndex总要比toIndex先出现
*/
public void removeRange(int fromIndex, int toIndex) {
if(fromIndex < 0){
fromIndex = fromIndex + size();
}
if(toIndex < 0){
toIndex = toIndex + size();
}
super.removeRange(fromIndex, toIndex);
}
/**
* 得到从fromIndex到toIndex的List的子集
* 无论从正向取值还是负向取值，fromIndex总要比toIndex先出现
*/
public List<E> subList(int fromIndex, int toIndex) {
if(fromIndex < 0){
fromIndex = fromIndex + size();
}
if(toIndex < 0){
toIndex = toIndex + size();
}
return super.subList(fromIndex, toIndex);
}
}

So Easy.

做个笔记，忘了的时候再来看看！