在java中，两个超长整形数相加，已经超过了long 的存储范围，怎么计算它的值呢？_百度知道
在java中，两个超长整形数相加，已经超过了long 的存储范围，怎么计算它的值呢？
有BigDecimal的用法，也有我写的一个相加的方法，参考下。方法很多的还可以把分成若干个int段分段计算后再加到一起。import java.math.BigDpublic class Class1 {
public static void main(String[] args) {
Class1 c=new Class1();
BigDecimal bi1=new BigDecimal(&6945&);
BigDecimal bi2=new BigDecimal(&323&);
BigDecimal bi3=bi1.add(bi2);
System.out.println(c.add(&6945&,&323&));
System.out.println(bi3);
public String add(String a,String b){
if(a.length()&b.length()){
return adds(a.trim(),b.trim());
return adds(b.trim(),a.trim());
adds(String a,String b){
int tmp=0;
char[] nc=new char[a.length()];
for(int i=a.length()-1,j=i-(a.length()-b.length());i&=0;i--){
if(a.charAt(i)&47&&a.charAt(i)&58){
t=tmp+(int)a.charAt(i)-48;
throw new FormatException(a+&第&+(i+1)+&个字符不是数字&);
if(b.charAt(j)&47&&b.charAt(j)&58){
t=t+(int)b.charAt(j)-48;
throw new FormatException(b+&第&+(j+1)+&个字符不是数字&);
tmp=t/10;
nc[i]=(char)(t%10+48);
if(tmp&0){
return tmp+new String(nc);
return new String(nc);
}}class FormatException extends RuntimeException {
public FormatException(String string) {
super(string);
其他类似问题
为您推荐：
6&quotBigInteger sum = new BigInteger(&).add(new BigInteger(&));6945&quot
计算的人只要知道最后的答案就行 所以你不一定要输出一个long型比如你只要按位数4574617作为一个数组
然后与123.。。467这个数组逐个相加然后进位 最后得到一个int型数组 再把数组逐个输出就行了
用数组的方式怎么解决？可以写个算法不？
用科学技算咯
下载知道APP
随时随地咨询
出门在外也不愁以下试题来自：
填空题在Java语言中，需要定义含有两个子数组的二维整型数组x，第一个子数组元素为7，8，第二个子数组元素为l，2，3，4，5，采用直接赋值创建此二维数组的语句为______。 参考答案int[][]x={{7，8}，{1，2，3，4，5}}；
为您推荐的考试题库
你可能感兴趣的试题
1.填空题 参考答案System．exit(0)；2A．ResultSet类 B．Driver Manager类C．Statement类 D．Connection类3A．将对象自己作为参数，调用别的方法B．当方法的局部变量隐藏成员变量时，利用this引用成员变量C．使用super调用超类的构造方法D．构造函数内调用另一构造函数4A．next B．breakC．switch D．continue5A．java.io包中 B．java. input包中C．Java．output包中 D．java．lang. io包中
热门相关试卷
最新相关试卷关于数组方面的JAVA一、 输入五个数字，输出这五个数字中的最大数、最小数、总和、平均值。二、 有15个数存放在一个数组中，输入一个数，要求查找出该数是数组中第几个元素的值。如果该数不在数组中，则输出“无此数”。15个数用赋初值的方法在程序中给出。三、 某个公司想用电话来传送数据，但又担心被人窃听。数据是由四个0～9的十进制数组成，然后按如下规则加密：每位数字都加上7，然后用和除以10的余数取代该数字；再把第1位与第3位交换，第2位与第4位交换。将加密后的结果输出；再单独编写一个程序，读取一个加密后的四位数字的整数，把它解密成原来的数。四、 输入五个数字，放置在一个一维数组中，倒置该数组并输出。五、 打印杨晖三角形（输出若干行，自己决定） 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1
窝窝_SSSoqo
import java.util.Spublic class Du { public static void main(String[] args) {
question1();
question2();
question3();
question4();
question5(); } private static void question5() {
int number = 5;
int[][] ary = new int[number][];
for(int i = 0; i < ary. i++){
ary[i] = new int[i+1];
ary[i][0] = 1;
ary[i][i] = 1;
for(int j = 1; j < ary[i].length - 1; j++){
ary[i][j] = ary[i-1][j] + ary[i-1][j-1];
for(int i = 0; i < ary. i++){
for(int j = 0; j < ary[i]. j++){
System.out.print(ary[i][j] + "
System.out.println();
} } private static void question4() {
System.out.println("\n Please input 5 number, separate with space:");
String[] number = new Scanner(System.in).nextLine().split("\\s+");
System.out.print("Reversed numbers are: ");
for(int i = number.length - 1; i >= 0; i--){
System.out.print(number[i] + "\t");
} } private static void question3() {
System.out.print("\nPlease input a number between 0000 and 9999:");
String number = new Scanner(System.in).next();
System.out.println("The number to encode is: " + number);
String encode = encode(number);
System.out.println("Encoded number is: " + encode);
String decode = decode(encode);
System.out.println("Decoded number is: " + decode); } private static String decode(String encode) {
StringBuilder sb = new StringBuilder(encode);
char first = sb.charAt(0);
char second = sb.charAt(1);
sb.setCharAt(0, sb.charAt(2));
sb.setCharAt(2, first);
sb.setCharAt(1, sb.charAt(3));
sb.setCharAt(3, second);
encode = sb.toString();
sb = new StringBuilder();
for(int i = 0, value = 0;i < encode.length(); i++){
value = Integer.parseInt(String.valueOf(encode.charAt(i)));
if(value >= 7){
sb.append(value-7);
sb.append((10 + value)-7);
return sb.toString(); } private static String encode(String number) {
String str = String.valueOf(number);
StringBuffer sb = new StringBuffer();
for(int i = 0; i < str.length(); i++){
sb.append(((str.charAt(i) - 48) + 7) % 10);
char first = sb.charAt(0);
sb.setCharAt(0, sb.charAt(2));
sb.setCharAt(2, first);
char second = sb.charAt(1);
sb.setCharAt(1, sb.charAt(3));
sb.setCharAt(3, second);
return sb.toString(); } private static void question2() {
int[] nums = {1, 2, 3, 4, 5, 6,7,8,9,10,11,12,13,14,15};
System.out.print("\nPlease input a number to search in the array:");
int input = new Scanner(System.in).nextInt();
for(int i = 0; i < nums. i++){
if(nums[i] == input){
System.out.println("Element at position " + (i+1) + "=" + input);
System.out.println("Not found " + input + " in the ary "); } private static void question1() {
System.out.print("Please input 5 numbers, separate with space:");
String[] input = new Scanner(System.in).nextLine().split("\\s+");
double sum = 0;
double max = Double.parseDouble(input[0]);
double min =
double item = 0;
for(int i= 0; i < input. i++){
item = Double.parseDouble(input[i]);
if(item > max){
System.out.println("Max is: " + max);
System.out.println("Min is: " + min);
System.out.println("Sum is: " + sum);
System.out.println("Average is: " + sum / input.length); }}--------------------------testingPlease input 5 numbers, separate with space:11 22 9Max is: 9999.0Min is: 66.0Sum is: 13453.0Average is: 2690.6Please input a number to search in the array:12Element at position 12=12Please input a number between 0000 and The number to encode is: 2345Encoded number is: 1290Decoded number is: 2345 Please input 5 number, separate with space:11 22 55 99 623Reversed numbers are: 623 99 55 22 11 1
为您推荐：
扫描下载二维码高效的找出两个List中的不同元素 - NotOnlyJava - 博客园
/developerworks/cn/java/j-lo-serial/
posts - 45, comments - 37, trackbacks - 0, articles - 0
如题：有List&String& list1和List&String& list2,两个集合各有上万个元素，怎样取出两个集合中不同的元素?
方法1：遍历两个集合：
package com.czp.
import java.util.ArrayL
import java.util.L
public class TestList {
public static void main(String[] args) {
List&String& list1 = new ArrayList&String&();
List&String& list2 = new ArrayList&String&();
for (int i = 0; i & 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
getDiffrent(list1,list2);
//输出：total times
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent(List&String& list1, List&String& list2) {
long st = System.nanoTime();
List&String& diff = new ArrayList&String&();
for(String str:list1)
if(!list2.contains(str))
diff.add(str);
System.out.println("total times "+(System.nanoTime()-st));
千万不要采用这种方法，总共要循环的次数是两个List的size相乘的积，从输出看耗时也是比较长的，那么我们有没有其他的方法呢？当然有.
方法2：采用List提供的retainAll（）方法：
package com.czp.
import java.util.ArrayL
import java.util.L
public class TestList {
public static void main(String[] args) {
List&String& list1 = new ArrayList&String&();
List&String& list2 = new ArrayList&String&();
for (int i = 0; i & 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
getDiffrent(list1,list2);
//输出：total times
getDiffrent2(list1,list2);
//输出：getDiffrent2 total times
* 获取连个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent2(List&String& list1, List&String& list2) {
long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
return list1;
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent(List&String& list1, List&String& list2) {
long st = System.nanoTime();
List&String& diff = new ArrayList&String&();
for(String str:list1)
if(!list2.contains(str))
diff.add(str);
System.out.println("getDiffrent total times "+(System.nanoTime()-st));
很遗憾，这种方式虽然只要几行代码就搞定，但是这个却更耗时，查看retainAll（）的源码:
public boolean retainAll(Collection&?& c) {
boolean modified = false;
Iterator&E& e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
无需解释这个耗时是必然的，那么我们还有没有更好的办法呢？仔细分析以上两个方法中我都做了mXn次循环，其实完全没有必要循环这么多次，我们的需求是找出两个List中的不同元素,那么我可以这样考虑：用一个map存放lsit的所有元素，其中的key为lsit1的各个元素，value为该元素出现的次数,接着把list2的所有元素也放到map里，如果已经存在则value加1，最后我们只要取出map里value为1的元素即可，这样我们只需循环m+n次，大大减少了循环的次数。
package com.czp.
import java.util.ArrayL
import java.util.HashM
import java.util.L
import java.util.M
public class TestList {
public static void main(String[] args) {
List&String& list1 = new ArrayList&String&();
List&String& list2 = new ArrayList&String&();
for (int i = 0; i & 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
getDiffrent(list1,list2);
//输出：total times
getDiffrent2(list1,list2);
//输出：getDiffrent2 total times
getDiffrent3(list1,list2);
//输出：getDiffrent3 total times
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent3(List&String& list1, List&String& list2) {
long st = System.nanoTime();
Map&String,Integer& map = new HashMap&String,Integer&(list1.size()+list2.size());
List&String& diff = new ArrayList&String&();
for (String string : list1) {
map.put(string, 1);
for (String string : list2) {
Integer cc = map.get(string);
if(cc!=null)
map.put(string, ++cc);
map.put(string, 1);
for(Map.Entry&String, Integer& entry:map.entrySet())
if(entry.getValue()==1)
diff.add(entry.getKey());
System.out.println("getDiffrent3 total times "+(System.nanoTime()-st));
return list1;
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent2(List&String& list1, List&String& list2) {
long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
return list1;
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent(List&String& list1, List&String& list2) {
long st = System.nanoTime();
List&String& diff = new ArrayList&String&();
for(String str:list1)
if(!list2.contains(str))
diff.add(str);
System.out.println("getDiffrent total times "+(System.nanoTime()-st));
显然，这种方法大大减少耗时，是方法1的1/4，是方法2的1/40，这个性能的提升时相当可观的，但是，这不是最佳的解决方法，观察方法3我们只是随机取了一个list作为首次添加的标准，这样一旦我们的list2比list1的size大，则我们第二次put时的if判断也会耗时，做如下改进：
package com.czp.
import java.util.ArrayL
import java.util.HashM
import java.util.L
import java.util.M
public class TestList {
public static void main(String[] args) {
List&String& list1 = new ArrayList&String&();
List&String& list2 = new ArrayList&String&();
for (int i = 0; i & 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
getDiffrent(list1,list2);
getDiffrent2(list1,list2);
getDiffrent3(list1,list2);
getDiffrent4(list1,list2);
getDiffrent total times
getDiffrent2 total times
getDiffrent3 total times
getDiffrent4 total times
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent4(List&String& list1, List&String& list2) {
long st = System.nanoTime();
Map&String,Integer& map = new HashMap&String,Integer&(list1.size()+list2.size());
List&String& diff = new ArrayList&String&();
List&String& maxList = list1;
List&String& minList = list2;
if(list2.size()&list1.size())
maxList = list2;
minList = list1;
for (String string : maxList) {
map.put(string, 1);
for (String string : minList) {
Integer cc = map.get(string);
if(cc!=null)
map.put(string, ++cc);
map.put(string, 1);
for(Map.Entry&String, Integer& entry:map.entrySet())
if(entry.getValue()==1)
diff.add(entry.getKey());
System.out.println("getDiffrent4 total times "+(System.nanoTime()-st));
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent3(List&String& list1, List&String& list2) {
long st = System.nanoTime();
Map&String,Integer& map = new HashMap&String,Integer&(list1.size()+list2.size());
List&String& diff = new ArrayList&String&();
for (String string : list1) {
map.put(string, 1);
for (String string : list2) {
Integer cc = map.get(string);
if(cc!=null)
map.put(string, ++cc);
map.put(string, 1);
for(Map.Entry&String, Integer& entry:map.entrySet())
if(entry.getValue()==1)
diff.add(entry.getKey());
System.out.println("getDiffrent3 total times "+(System.nanoTime()-st));
* 获取连个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent2(List&String& list1, List&String& list2) {
long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
return list1;
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent(List&String& list1, List&String& list2) {
long st = System.nanoTime();
List&String& diff = new ArrayList&String&();
for(String str:list1)
if(!list2.contains(str))
diff.add(str);
System.out.println("getDiffrent total times "+(System.nanoTime()-st));
这里对连个list的大小进行了判断，小的在最后添加，这样会减少循环里的判断，性能又有了一定的提升，正如一位朋友所说，编程是无止境的，只要你认真去思考了，总会找到更好的方法！
非常感谢binglian的指正，针对List有重复元素的问题，做以下修正，首先明确一点，两个List不管有多少个重复，只要重复的元素在两个List都能找到，则不应该包含在返回值里面，所以在做第二次循环时，这样判断：如果当前元素在map中找不到，则肯定需要添加到返回值中，如果能找到则value++，遍历完之后diff里面已经包含了只在list2里而没在list2里的元素，剩下的工作就是找到list1里有list2里没有的元素，遍历map取value为1的即可：
package com.czp.
import java.util.ArrayL
import java.util.HashM
import java.util.L
import java.util.M
public class TestList {
public static void main(String[] args) {
List&String& list1 = new ArrayList&String&();
List&String& list2 = new ArrayList&String&();
for (int i = 0; i & 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
getDiffrent(list1,list2);
getDiffrent3(list1,list2);
getDiffrent5(list1,list2);
getDiffrent4(list1,list2);
getDiffrent2(list1,list2);
getDiffrent3 total times
getDiffrent5 total times
getDiffrent4 total times
getDiffrent2 total times
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent5(List&String& list1, List&String& list2) {
long st = System.nanoTime();
List&String& diff = new ArrayList&String&();
List&String& maxList = list1;
List&String& minList = list2;
if(list2.size()&list1.size())
maxList = list2;
minList = list1;
Map&String,Integer& map = new HashMap&String,Integer&(maxList.size());
for (String string : maxList) {
map.put(string, 1);
for (String string : minList) {
if(map.get(string)!=null)
map.put(string, 2);
diff.add(string);
for(Map.Entry&String, Integer& entry:map.entrySet())
if(entry.getValue()==1)
diff.add(entry.getKey());
System.out.println("getDiffrent5 total times "+(System.nanoTime()-st));
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent4(List&String& list1, List&String& list2) {
long st = System.nanoTime();
Map&String,Integer& map = new HashMap&String,Integer&(list1.size()+list2.size());
List&String& diff = new ArrayList&String&();
List&String& maxList = list1;
List&String& minList = list2;
if(list2.size()&list1.size())
maxList = list2;
minList = list1;
for (String string : maxList) {
map.put(string, 1);
for (String string : minList) {
Integer cc = map.get(string);
if(cc!=null)
map.put(string, ++cc);
map.put(string, 1);
for(Map.Entry&String, Integer& entry:map.entrySet())
if(entry.getValue()==1)
diff.add(entry.getKey());
System.out.println("getDiffrent4 total times "+(System.nanoTime()-st));
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent3(List&String& list1, List&String& list2) {
long st = System.nanoTime();
Map&String,Integer& map = new HashMap&String,Integer&(list1.size()+list2.size());
List&String& diff = new ArrayList&String&();
for (String string : list1) {
map.put(string, 1);
for (String string : list2) {
Integer cc = map.get(string);
if(cc!=null)
map.put(string, ++cc);
map.put(string, 1);
for(Map.Entry&String, Integer& entry:map.entrySet())
if(entry.getValue()==1)
diff.add(entry.getKey());
System.out.println("getDiffrent3 total times "+(System.nanoTime()-st));
* 获取连个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent2(List&String& list1, List&String& list2) {
long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
return list1;
* 获取两个List的不同元素
* @param list1
* @param list2
private static List&String& getDiffrent(List&String& list1, List&String& list2) {
long st = System.nanoTime();
List&String& diff = new ArrayList&String&();
for(String str:list1)
if(!list2.contains(str))
diff.add(str);
System.out.println("getDiffrent total times "+(System.nanoTime()-st));
以下是完整的代码:
1 package com.czp.
3 import java.util.C
4 import java.util.HashM
5 import java.util.HashS
6 import java.util.LinkedL
7 import java.util.M
* 该类提供对集合类的高效操作
* @author Czp
15 public class CollectionUtil {
* 不允许实例化
private CollectionUtil() {
获取两个集合的不同元素
* @param collmax
* @param collmin
@SuppressWarnings({ "rawtypes", "unchecked" })
public static Collection getDiffent(Collection collmax,Collection collmin)
//使用LinkeList防止差异过大时,元素拷贝
Collection csReturn = new LinkedList();
Collection max =
Collection min =
//先比较大小,这样会减少后续map的if判断次数
if(collmax.size()&collmin.size())
//直接指定大小,防止再散列
Map&Object,Integer& map = new HashMap&Object,Integer&(max.size());
for (Object object : max) {
map.put(object, 1);
for (Object object : min) {
if(map.get(object)==null)
csReturn.add(object);
map.put(object, 2);
for (Map.Entry&Object, Integer& entry : map.entrySet()) {
if(entry.getValue()==1)
csReturn.add(entry.getKey());
return csR
获取两个集合的不同元素,去除重复
* @param collmax
* @param collmin
@SuppressWarnings({ "rawtypes", "unchecked" })
public static Collection getDiffentNoDuplicate (Collection collmax,Collection collmin)
return new HashSet(getDiffent(collmax, collmin));