java与python性能对比，差一个数量级

以下用金融里面的常见参数“移动平均值”为例，分别用python和java编写计算，结果对比发现，相差一个数量级。

这个只是针对j语言本身基本特性做的一个基线测试，仅供参考。

python版

from __future__ import division
import time
import random

# 生成测试用的数据
data = []
data_length = 100000    # 总数据量
ma_length = 500         # 移动均线的窗口
test_times = 10         # 测试次数

for i in range(data_length):
    data.append(random.randint(1, 100))




# 计算500期的移动均线，并将结果保存到一个列表里返回
def ma_basic(data, ma_length):

    # 用于保存均线输出结果的列表
    ma = []

    # 计算均线用的数据窗口
    data_window = data[:ma_length]

    # 测试用数据（去除了之前初始化用的部分）
    test_data = data[ma_length:]

    # 模拟实盘不断收到新数据推送的情景，遍历历史数据计算均线
    for new_tick in test_data:
        # 移除最老的数据点并增加最新的数据点
        data_window.pop(0)
        data_window.append(new_tick)

        # 遍历求均线
        sum_tick = 0
        for tick in data_window:
            sum_tick += tick
        ma.append(sum_tick/ma_length)

    # 返回数据
    return ma

# 运行测试
start = time.time()

for i in range(test_times):
    result = ma_basic(data, ma_length)

time_per_test = (time.time()-start)/test_times
time_per_point = time_per_test/(data_length - ma_length)

print (u'单次耗时：%s秒' %time_per_test)

java版

package com.yiniu;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class MaTest {
	
	static List<Integer> data = new LinkedList<>();
	static int data_length = 100000;    //总数据量
	static int ma_length = 500;         //移动均线的窗口
	static int test_times = 10;         //测试次数
	
	static void initDatas()
	{
		Random r=new Random();
		int a;
		for (int i=0;i<data_length;i++)
		{
			a=1+r.nextInt(100);
			data.add(a);
		}
	}
	
	static List<Integer> maBase(List<Integer> datas,int win)
	{
		List<Integer> result = new ArrayList<>();
		List<Integer> data_window = data.subList(0, ma_length);
		
		List<Integer> test_data = new ArrayList<>( Arrays.asList(new Integer[data_length-ma_length]) );
		Collections.copy(test_data, data.subList(ma_length,data.size()));  
		
		int sum_tick=0;
		for (Integer new_tick:test_data)
		{
			data_window.remove(0);
	        data_window.add(new_tick);
	        
	        for(int tick:data_window)
	        {
	        	sum_tick += tick;
	        }
	        result.add(sum_tick/ma_length);
	        
	        sum_tick = 0; 
		}
		
		return result;
	}
	
	
	public static void main(String args[])
	{
		initDatas();
		
		long st = System.currentTimeMillis();
		for (int i=0;i<test_times;i++)	maBase(data,ma_length);
		long en = System.currentTimeMillis();
		
		System.out.println( (en-st)/test_times );
	}

}

python运行结果：单次耗时：2.179024648666382秒
java运行结果：205毫秒