在Java中，经常会进行两个数之间的比较，当被比较的两个数均为整数时，按如下代码进行比较即可：
 
int a=2;
int b=5;
System.out.println(a==b);
 
运行的结果为false。 
 当两个数为浮点数时，若直接进行比较，可能会产生错误，如下所示：
 
double a=1.0;
double b=0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1;
System.out.println(a==b);
 
运行后，会发现输出的结果为false。这是因为Java在进行浮点数的运算时，并不是精确运算，因此会产生一定的误差，这个时候，应该如下进行比较：
 
double a=1.0;
double b=0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1;
System.out.println(Math.abs(a-b)<1e-6);
 
其中，1e-6表示一个很小的数，可以换成其他的合适的数进行替换。这个时候，输出的结果就为true了。

JAVA 两个大字符串数字相加
 
 
 
在平常的业务中也许会有很大的数字无法使用int或者long来存储了，那么只能存储成string类型，当需要两个这样的数字相加的时候，怎么办呢？
 
 
方法中不再验证传入的数字的正确性，默认是正确的。
 
整体步骤：
 
将两个字符串长度补全，补成一致长度，长度短的左边补0；
定义一个新的整形数组，长度为字符串的长度+1，因为结果的长度可能超出原字符串的长度（整形数组值默认为0）；
倒叙循环相加，将结果%10的余位放在低位，结果的/10的结果放在高位；最终合并结果返回。
 
public String bigNumberPlus(String a, String b) {
    int lenA = a.length();
    int lenB = b.length();
    if(lenA > lenB) {
        b = StringUtils.leftPad(b, lenA, "0");
    } else {
        a = StringUtils.leftPad(a, lenB, "0");
    }

    int[] arrC = new int[a.length() + 1];

    for(int i = a.length()-1; i>=0; i--) {
        int ai = Integer.parseInt(a.charAt(i) + "" );
        int bi = Integer.parseInt(b.charAt(i) + "" );
        int ci = arrC[i+1];
        int t = ai + bi + ci;
        arrC[i+1] = t%10;
        arrC[i] = t/10;
    }

    StringBuffer res = new StringBuffer();
    for(int i = 0; i<arrC.length; i++) {
        if(i==0 && arrC[i]==0) continue;
        res.append(arrC[i]);
    }
    return res.toString();
}
 
 
 
方法整体只循环一次，效率还可以，大家还有什么好方法，可以留言讨论！
 
 
如果是小数的话，有两种思路：
 
补全长度的时候，需要两边都补全，小数点左边的在左边补全0，小数点右边在右边补全0，然后标记小数点所在的位置，剔除小数点，计算完成后，再在固定位置加入小数点即可。
分开计算：先计算小数点右边的小数部分，计算时需要右边补全；然后计算小数点左边部分，计算时需要左边补全，当右边计算结果大于1的时候，需要左边按照3个字符串计算。

 
有一个字符串的时间，比如"2012-12-31 16:18:36" 与另一个时间做比较，如果前者比后者早，则返回true，否则返回false。
 
 
为此，我设计了一个方法。
 
 
 
 
 
import java.util.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
class Test
{
	public boolean compare(String time1,String time2) throws ParseException
	{
		//如果想比较日期则写成"yyyy-MM-dd"就可以了
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		//将字符串形式的时间转化为Date类型的时间
		Date a=sdf.parse(time1);
		Date b=sdf.parse(time2);
		//Date类的一个方法，如果a早于b返回true，否则返回false
		if(a.before(b))
			return true;
		else
			return false;
		/*
		 * 如果你不喜欢用上面这个太流氓的方法，也可以根据将Date转换成毫秒
		if(a.getTime()-b.getTime()<0)
			return true;
		else
			return false;
		*/
	}
	public static void main(String[] args) throws Exception
	{
		boolean result=new Test().compare("2012-11-30 16:11:16", "2012-11-30 16:18:18");
		System.out.println(result);
	}
}
 
 
结果输出true
 
 
很简单实用，希望大家喜欢~
 
 
 
 
转载于:https://www.cnblogs.com/james1207/p/3295156.html

注意点:   
 
 
大数相加的时候没有判断数字的正负， 
 
 
如果都是正数，那么就可以按照正数相加来计算， 
 
 
如果是一正一负可以转换成大整数相减，
 两个负数可以先保存符号，然后相加。
 

 
 
加法和减法的输入都不包括符号
 
 
加法
 
 

	public String bigNumberAdd(String f, String s) {
		System.out.print("加法:" + f + "+" + s + "=");
		// 翻转两个字符串，并转换成数组
		char[] a = new StringBuffer(f).reverse().toString().toCharArray();
		char[] b = new StringBuffer(s).reverse().toString().toCharArray();
		int lenA = a.length;
		int lenB = b.length;
		// 计算两个长字符串中的较长字符串的长度
		int len = lenA > lenB ? lenA : lenB;
		int[] result = new int[len + 1];
		for (int i = 0; i < len + 1; i++) {
			// 如果当前的i超过了其中的一个，就用0代替，和另一个字符数组中的数字相加
			int aint = i < lenA ? (a[i] - '0') : 0;
			int bint = i < lenB ? (b[i] - '0') : 0;
			result[i] = aint + bint;
		}
		// 处理结果集合，如果大于10的就向前一位进位，本身进行除10取余
		for (int i = 0; i < result.length; i++) {
			if (result[i] >= 10) {
				result[i + 1] += result[i] / 10;
				result[i] %= 10;
			}
		}
		StringBuffer sb = new StringBuffer();
		// 该字段用于标识是否有前置0，如果有就不要存储
		boolean flag = true;
		// 注意从后往前
		for (int i = len; i >= 0; i--) {
			if (result[i] == 0 && flag) {
				continue;
			} else {
				flag = false;
			}
			sb.append(result[i]);
		}
		// 结果
		System.out.println(sb.toString());
		return sb.toString();
	}
 
减法
 

	public static String bigNumberSub(String f, String s) {
		System.out.print("减法:" + f + "-" + s + "=");
		// 将字符串翻转并转换成字符数组
		char[] a = new StringBuffer(f).reverse().toString().toCharArray();
		char[] b = new StringBuffer(s).reverse().toString().toCharArray();
		int lenA = a.length;
		int lenB = b.length;
		// 找到最大长度
		int len = lenA > lenB ? lenA : lenB;
		int[] result = new int[len];
		// 表示结果的正负
		char sign = '+';
		// 判断最终结果的正负
		if (lenA < lenB) {
			sign = '-';
		} else if (lenA == lenB) {
			int i = lenA - 1;
			// 找到第一个不相等的
			// 注意下标0处理
			while (i > 0 && a[i] == b[i]) {
				i--;
			}
			if (a[i] < b[i]) {
				sign = '-';
			}
		}
		// 计算结果集，如果最终结果为正，那么就a-b否则的话就b-a
		for (int i = 0; i < len; i++) {
			int aint = i < lenA ? (a[i] - '0') : 0;
			int bint = i < lenB ? (b[i] - '0') : 0;
			if (sign == '+') {
				result[i] = aint - bint;
			} else {
				result[i] = bint - aint;
			}
		}
		// 如果结果集合中的某一位小于零，那么就向前一位借一，
		// 然后将本位加上10。其实就相当于借位做减法
		for (int i = 0; i < result.length - 1; i++) {
			if (result[i] < 0) {
				result[i + 1] -= 1;
				result[i] += 10;
			}
		}

		StringBuffer sb = new StringBuffer();
		// 如果最终结果为负值，就将负号放在最前面，正号则不需要
		if (sign == '-') {
			sb.append('-');
		}
		// 判断是否有前置0
		boolean flag = true;
		for (int i = len - 1; i >= 0; i--) {
			if (result[i] == 0 && flag) {
				continue;
			} else {
				flag = false;
			}
			sb.append(result[i]);
		}
		// 结果为一位且是0，被上面的for处理了
		// 如果最终结果集合中没有值，就说明是两值相等，最终返回0
		if (sb.toString().equals("")) {
			sb.append("0");
		}
		// 返回值
		System.out.println(sb.toString());
		return sb.toString();
	}