Android大数据读取与折半查找（初步测试几毫秒）

主要实现了，100万条数据的内存读入，以及高效率的折半查找（折半查找大约几毫秒）

该项目分一个Activity和一个TestWrite类。

具体的看以下代码：

package com.example.androidtime;

import gc.android.database.DataBase;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.util.Arrays;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends Activity {
	public static DataBase db;
	private TextView tx;
	public static long[] arrays;
	static int i = 0;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		tx = (TextView) findViewById(R.id.tx);
		// db = new
		// DataBase(Environment.getExternalStorageDirectory().getPath(),
		// "/shorts.db");
		// db.openDataBase();
		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					File shorts = new File(Environment
							.getExternalStorageDirectory().getPath()
							+ "/short.txt");
					arrays = new long[1000000];
					FileInputStream _in;
					_in = new FileInputStream(shorts);
					byte[] b = new byte[4000];
					while (_in.read(b) == 4000) {
						fillArrays(b);
					}
					_in.close();
					mhandler.sendMessage(mhandler.obtainMessage(0, "读取完成"));
				} catch (Exception e1) {
				}

			}
		}).start();

	}

	public void onclick(View v) {
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO 自动生成的方法存根

				// long _start = System.currentTimeMillis();
				// int _result = str.indexOf("2743097074l");
				// long _end = System.currentTimeMillis();
				// mhandler.sendMessage(mhandler.obtainMessage(0,
				// Arrays.toString(new long[] { _end - _start, _result })));
				try {
					mhandler.sendMessage(mhandler.obtainMessage(0,
							Arrays.toString(TestWrite.main())));
				} catch (Exception e) {
					mhandler.sendMessage(mhandler.obtainMessage(0, "err"));
				}
			}
		}).start();
	}

	private Handler mhandler = new Handler() {

		@Override
		public void handleMessage(Message msg) {
			// TODO 自动生成的方法存根
			tx.setText(msg.obj.toString() + "\r\n" + tx.getText().toString());
		}

	};

	public static void fillArrays(byte[] b) {
		int _c = b.length / 10;
		for (int t = 0; t < _c; t++) {
			int _a = 10 * t;
			MainActivity.arrays[i] = Long.parseLong("" + b[0 + _a] + b[1 + _a]
					+ b[2 + _a] + b[3 + _a] + b[4 + _a] + b[5 + _a] + b[6 + _a]
					+ b[7 + _a] + b[8 + _a] + b[9 + _a]);
			i++;
		}
	}
}

<pre name="code" class="java">package com.example.androidtime;

import java.io.IOException;

public class TestWrite {
	/*
	 * 先按照数组为数据原型写出算法，再写出扩展性算法。数组{49,38,65,97,76,13,27}
	 */
	public static void quickSort(int[] 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(int[] n, int left, int right) {
		int 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;
	}

	// 数据读取并转int
	// 导入数组
	public static long[] main() throws IOException, ClassNotFoundException {
		long _time = System.currentTimeMillis();
		// 2743097074l
		int index = splitHalf(MainActivity.arrays, 21826, 0,
				MainActivity.arrays.length - 1);

		long _time1 = System.currentTimeMillis();
		return new long[] { _time1, _time, index, MainActivity.arrays[index],
				MainActivity.arrays[0], MainActivity.arrays[999999] };
	}

	/**
	 * 功 能：折半查找
	 * 
	 * @param arrayData
	 *            数组
	 * @param searchData
	 *            要查找的数据
	 * @param start
	 *            开始下标
	 * @param end
	 *            结束下标
	 * @return 数据在数组中下标的位置，如果数据不在数组中，返回 -1
	 */
	public static int splitHalf(long[] arrayData, long searchData, int start,
			int end) {
		int index = (start + end) / 2;
		long data = arrayData[index];
		if (start > end) {
			return -1;
		}
		if (data == searchData) {
			return index;
		} else {
			if (data < searchData) {
				return splitHalf(arrayData, searchData, index + 1, end);
			} else {
				return splitHalf(arrayData, searchData, start, index - 1);
			}
		}
	}

}

最后别忘了加入读写权！