版权申明
原创文章：本博所有原创文章，欢迎转载，转载请注明出处，并联系本人取得授权。
版权邮箱地址：banquan@mrdwy.com
介绍一个自己写的超大整型数字的处理工具类，主要思路就是把整数用字符串存储，然后实现加减乘除等运算方法，运算主要的方式就是拆分成多个整型分别计算，但是要注意处理进位的问题。
package org.tcrow.number;
/**
* @author tcrow.luo
* 10进制大数类型处理类
*/
public class LongLong {
/**
* 表示正负，1表示正数，-1表示负数，0表示0
*/
final int signum;
/**
* 拆解大数字符保存在整形数组中
*/
final int[] mag;
/**
* 无符号数的处理常量
*/
final static long LONG_MASK = 0xffffffffL;
/**
* 用于表示十进制
*/
final static int DEFAULT_RADIX = 10;
LongLong(int[] mag, int signum) {
this.mag = mag;
this.signum = signum;
}
public LongLong(String val) {
int cursor = 0, numDigits;
final int len = val.length();
if (len == 0) {
throw new NumberFormatException("Zero length BigInteger");
}
// 检查大数符号
int sign = 1;
int index1 = val.lastIndexOf('-');
int index2 = val.lastIndexOf('+');
if (index1 >= 0) {
if (index1 != 0 || index2 >= 0) {
throw new NumberFormatException("Illegal embedded sign character");
}
sign = -1;
cursor = 1;
} else if (index2 >= 0) {
if (index2 != 0) {
throw new NumberFormatException("Illegal embedded sign character");
}
cursor = 1;
}
if (cursor == len) {
throw new NumberFormatException("Zero length BigInteger");
}
//去掉头部的0
while (cursor < len && Character.digit(val.charAt(cursor), DEFAULT_RADIX) == 0) {
cursor++;
}
//没有发现有效数字则直接返回一个值为0的对象
if (cursor == len) {
signum = 0;
mag = new int[0];
return;
}
//计算有效长度
numDigits = len - cursor;
signum = sign;
mag = new int[numDigits];
while (cursor < len) {
mag[--numDigits] = Integer.parseInt(val.substring(cursor, ++cursor));
}
}
/**
* 加法运算
*
* @param val
* @return
*/
public LongLong add(LongLong val) {
if (val.signum == 0) {
return this;
}
if (this.signum == 0) {
return val;
}
if (this.signum != val.signum) {
LongLong thiB = new LongLong(this.toString().replaceAll("-", ""));
LongLong valB = new LongLong(val.toString().replaceAll("-", ""));
int compare = compareMagnitude(thiB, valB);
int sign;
if (compare == 0) {
return new LongLong(new int[0], 0);
}
if (compare > 0) {
sign = signum;
} else {
sign = val.signum;
}
return new LongLong(sub(mag, val.mag), sign);
}
return new LongLong(add(mag, val.mag), signum);
}
/**
* 无符号数相加
*
* @param x
* @param y
* @return
*/
private int[] add(int[] x, int[] y) {
boolean cb = false;
StringBuffer result = new StringBuffer();
int len = x.length > y.length ? x.length : y.length;
for (int i = 0; i < len; i++) {
//短数组高位补0
int thiV = i < x.length ? x[i] : 0;
int valV = i < y.length ? y[i] : 0;
result.append((thiV + valV + (cb ? 1 : 0)) % 10);
if (thiV + valV > 9 || (thiV + valV + (cb ? 1 : 0)) == 10) {
cb = true;
} else {
cb = false;
}
}
if (cb) {
result.append(1);
}
return new LongLong(result.reverse().toString()).mag;
}
/**
* 减法运算
*
* @param val
* @return
*/
public LongLong sub(LongLong val) {
if (val.signum == 0) {
return this;
}
if (signum == 0) {
return val.negate();
}
if (this.signum != val.signum) {
if (this.signum < 0) {
return new LongLong(val.add(new LongLong(this.toString().replaceFirst("-", ""))).mag, signum);
}
return this.add(new LongLong(val.toString().replaceFirst("-", "")));
}
int compare = compareMagnitude(this, val);
if (compare == 0) {
return new LongLong("0");
}
return new LongLong(sub(mag, val.mag), ((compare < 0) ? this.negate().signum : signum));
}
/**
* 无符号数相减，会自动用大数减小数，返回大数减小数的结果
*
* @param x
* @param y
* @return
*/
private int[] sub(int[] x, int[] y) {
int compare = compareMagnitude(new LongLong(x, 1), new LongLong(y, 1));
int[] big;
int[] little;
if (compare > 0) {
big = x;
little = y;
} else {
big = y;
little = x;
}
boolean cb = false;
StringBuffer result = new StringBuffer();
int len = big.length > little.length ? big.length : little.length;
for (int i = 0; i < len; i++) {
//防止数组溢出
int thiV = i < big.length ? big[i] : 0;
int valV = i < little.length ? little[i] : 0;
int ret = thiV - valV - (cb ? 1 : 0);
result.append(ret >= 0 ? ret : (ret + 10));
if (thiV < valV || isLast(ret, cb)) {
cb = true;
} else {
cb = false;
}
}
return new LongLong(result.reverse().toString()).mag;
}
private boolean isLast(int ret, boolean cb) {
return ret == -1 && cb == true;
}
/**
* 转换成字符串
*
* @return
*/
@Override
public String toString() {
if (signum == 0) {
return "0";
}
StringBuffer sb = new StringBuffer();
for (int i = 0; i < mag.length; i++) {
sb.append(mag[i]);
}
return signum >= 0 ? sb.reverse().toString() : "-" + sb.reverse().toString();
}
/**
* 比较两个数大小,x == y 返回0 x > y 返回 1 x<y 返回-1
*
* @param x
* @param y
* @return
*/
final int compareMagnitude(LongLong x, LongLong y) {
int[] m1 = x.mag;
int len1 = m1.length;
int[] m2 = y.mag;
int len2 = m2.length;
if (len1 < len2) {
return -1;
}
if (len1 > len2) {
return 1;
}
for (int i = 0; i < len1; i++) {
int a = m1[m1.length - 1 - i];
int b = m2[m2.length - 1 - i];
if (a != b) {
return ((a & LONG_MASK) < (b & LONG_MASK)) ? -1 : 1;
}
}
return 0;
}
/**
* 反转符号
*
* @return
*/
public LongLong negate() {
return new LongLong(this.mag, -this.signum);
}
}
附送单元测试代码
import com.google.common.base.Stopwatch;
import org.junit.Assert;
import org.junit.Test;
import org.tcrow.number.LongLong;
import java.math.BigInteger;
/**
* @author tcrow.luo
* @date 2018/8/17
* @description
*/
public class TestLongLong {
@Test
public void test() throws Exception {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 1000; j++) {
BigInteger bigInteger = new BigInteger("" + i).add(new BigInteger("" + j));
LongLong longLong = new LongLong("" + i).add(new LongLong("" + j));
if (!bigInteger.toString().equals(longLong.toString())) {
throw new Exception("i:" + i + "| j:" + j);
}
bigInteger = new BigInteger("" + i).subtract(new BigInteger("" + j));
longLong = new LongLong("" + i).sub(new LongLong("" + j));
if (!bigInteger.toString().equals(longLong.toString())) {
throw new Exception("i:" + i + "| j:" + j);
}
}
}
for (int i = 0; i < 1000; i++) {
for (int j = 0; j > -10; j--) {
BigInteger bigInteger = new BigInteger("" + i).add(new BigInteger("" + j));
LongLong longLong = new LongLong("" + i).add(new LongLong("" + j));
if (!bigInteger.toString().equals(longLong.toString())) {
throw new Exception("i:" + i + "| j:" + j);
}
bigInteger = new BigInteger("" + i).subtract(new BigInteger("" + j));
longLong = new LongLong("" + i).sub(new LongLong("" + j));
if (!bigInteger.toString().equals(longLong.toString())) {
throw new Exception("i:" + i + "| j:" + j);
}
}
}
}
@Test
public void testBig(){
Stopwatch stopwatch = Stopwatch.createStarted();
Assert.assertEquals(new BigInteger("111111111111111111111111111111111111").add(new BigInteger("99999999999999999999999999999")).toString(),new LongLong("111111111111111111111111111111111111").add(new LongLong("99999999999999999999999999999")).toString());
Assert.assertEquals(new BigInteger("-111111111111111111111111111111111111").add(new BigInteger("99999999999999999999999999999")).toString(),new LongLong("-111111111111111111111111111111111111").add(new LongLong("99999999999999999999999999999")).toString());
Assert.assertEquals(new BigInteger("-111111111111111111111111111111111111").add(new BigInteger("-99999999999999999999999999999")).toString(),new LongLong("-111111111111111111111111111111111111").add(new LongLong("-99999999999999999999999999999")).toString());
Assert.assertEquals(new BigInteger("123153534534213414123").add(new BigInteger("-99999999999999999999999999999")).toString(),new LongLong("123153534534213414123").add(new LongLong("-99999999999999999999999999999")).toString());
Assert.assertEquals(new BigInteger("111111111111111111111111111111111111").subtract(new BigInteger("99999999999999999999999999999")).toString(),new LongLong("111111111111111111111111111111111111").sub(new LongLong("99999999999999999999999999999")).toString());
Assert.assertEquals(new BigInteger("-111111111111111111111111111111111111").subtract(new BigInteger("-99999999999999999999999999999")).toString(),new LongLong("-111111111111111111111111111111111111").sub(new LongLong("-99999999999999999999999999999")).toString());
Assert.assertEquals(new BigInteger("111111111111111111111111111111111111").subtract(new BigInteger("-99999999999999999999999999999")).toString(),new LongLong("111111111111111111111111111111111111").sub(new LongLong("-99999999999999999999999999999")).toString());
Assert.assertEquals(new BigInteger("-111111111111111111111111111111111111").subtract(new BigInteger("99999999999999999999999999999")).toString(),new LongLong("-111111111111111111111111111111111111").sub(new LongLong("99999999999999999999999999999")).toString());
stopwatch.stop();
System.out.println(stopwatch.toString());
}
@Test
public void testSingle(){
LongLong longLong = new LongLong("1");
System.out.println(new LongLong("-1").sub(new LongLong("2")).toString());
}
}
相关代码已经在我的github上面开源了，有兴趣可以关注一下这个项目，主要是做了一些算法的功能实现
https://github.com/tcrow/algorithm
