测试大数据(快速排序)100万条数据

该类生成了100万条数据。！！

每条数据数据都是转型完成的10位的长整型

并且该类还用到了了快速排序

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestWrite {

	public static void main(String[] args) throws IOException,
			ClassNotFoundException {
		// TODO 自动生成的方法存根
		File shorts = new File("e:\\short.txt");
		File shorts1 = new File("d:\\short.txt");
		if (!shorts.exists()) {
			shorts.createNewFile();
		}
		FileOutputStream _out = new FileOutputStream(shorts1);
		long[] a = new long[1000000];
		// String _temp = "";
		// for (int i = 0; i < a.length; i++) {
		// for (int j = 0; j < 10; j++) {
		// a[i] = getRandom();
		// _temp += a[i];
		// _out.write(a[i]);
		// }
		// if (i < 5) {
		// System.out.println(_temp);
		// }
		// _temp = "";
		// }
		FileInputStream _in = new FileInputStream(shorts);
		byte[] b = new byte[10];
		int _len = -1;
		int i = 0;
		long _time = System.currentTimeMillis();
		while ((_len = _in.read(b)) != -1) {

			a[i] = Long.parseLong("" + b[0] + b[1] + b[2] + b[3] + b[4] + b[5]
					+ b[6] + b[7] + b[8] + b[9]);
			i++;
		}
		System.out.println("长度：" + a.length);
		quickSort(a, 0, a.length - 1);
		for (int k = 0; k < a.length; k++) {
			String _temp = a[k] + "";
			int _o = 10 - _temp.length();
			for (int m = 0; m < _o; m++) {
				_out.write(0);
			}
			String[] _strs = _temp.split("");
			for (String str : _strs) {
				_out.write(Integer.parseInt(str));
			}
		}
		long _time1 = System.currentTimeMillis();

		System.out.println((_time1 - _time) / 1000);
	}

	/*
	 * 先按照数组为数据原型写出算法，再写出扩展性算法。数组{49,38,65,97,76,13,27}
	 */
	public static void quickSort(long[] n, int left, int right) {
		int pivot;
		if (left < right) {
			// pivot作为枢轴，较之小的元素在左，较之大的元素在右
			pivot = partition(n, left, right);
			// 对左右数组递归调用快速排序，直到顺序完全正确
			quickSort(n, left, pivot - 1);
			quickSort(n, pivot + 1, right);
		}
	}

	public static int partition(long[] n, int left, int right) {
		long pivotkey = n[left];
		// 枢轴选定后永远不变，最终在中间，前小后大
		while (left < right) {
			while (left < right && n[right] >= pivotkey)
				--right;
			// 将比枢轴小的元素移到低端，此时right位相当于空，等待低位比pivotkey大的数补上
			n[left] = n[right];
			while (left < right && n[left] <= pivotkey)
				++left;
			// 将比枢轴大的元素移到高端，此时left位相当于空，等待高位比pivotkey小的数补上
			n[right] = n[left];
		}
		// 当left == right，完成一趟快速排序，此时left位相当于空，等待pivotkey补上
		n[left] = pivotkey;
		return left;
	}

	public static int getRandom() {
		return Math.abs((int) (Math.random() * 10 + 1));
	}

}