1.我想把java文件先加密然后打包，源码请高手指教怎么加密，解析有那种好的源码加密算法吗？
2.关于java中DecimalFormat的问题。
3.BigInteger与BigDecimal
4.三种大数相乘算法

我想把java文件先加密然后打包，解析请高手指教怎么加密，源码有那种好的解析免费商城小程序源码加密算法吗？

       RSA算法非常简单，概述如下：

       找两素数p和q

       取n=p*q

       取t=(p-1)*(q-1)

       取任何一个数e,源码要求满足e<t并且e与t互素（就是最大公因数为1）

       取d*e%t==1

       这样最终得到三个数： n d e

       设消息为数M (M <n)

       设c=(M**d)%n就得到了加密后的消息c

       设m=(c**e)%n则 m == M，从而完成对c的解析解密。

       注：**表示次方,源码上面两式中的d和e可以互换。

       在对称加密中：

       n d两个数构成公钥，解析可以告诉别人；

       n e两个数构成私钥，源码e自己保留，解析电影排行源码不让任何人知道。源码

       给别人发送的解析信息使用e加密，只要别人能用d解开就证明信息是源码由你发送的，构成了签名机制。

       别人给你发送信息时使用d加密，这样只有拥有e的你能够对其解密。

       rsa的安全性在于对于一个大数n，没有有效的方法能够将其分解

       从而在已知n d的情况下无法获得e；同样在已知n e的情况下无法

       求得d。

       <二>实践

       接下来我们来一个实践，看看实际的操作：

       找两个素数：

       p=

       q=

       这样

       n=p*q=

       t=(p-1)*(q-1)=

       取e=，满足e<t并且e和t互素

       用perl简单穷举可以获得满主 e*d%t ==1的linuxfota升级源码数d：

       C:\Temp>perl -e "foreach $i (1..){ print($i),last if $i*%==1 }"

       

       即d＝

       最终我们获得关键的

       n=

       d=

       e=

       取消息M=我们看看

       加密：

       c=M**d%n = **%

       用perl的大数计算来算一下：

       C:\Temp>perl -Mbigint -e "print **%"

       

       即用d对M加密后获得加密信息c＝

       解密：

       我们可以用e来对加密后的c进行解密，还原M：

       m=c**e%n=**% ：

       C:\Temp>perl -Mbigint -e "print **%"

       

       即用e对c解密后获得m= , 该值和原始信息M相等。

       <三>字符串加密

       把上面的过程集成一下我们就能实现一个对字符串加密解密的示例了。

       每次取字符串中的一个字符的ascii值作为M进行计算，其输出为加密后进制

       的数的字符串形式，按3字节表示，如F

       代码如下：

       #!/usr/bin/perl -w

       #RSA 计算过程学习程序编写的测试程序

       #watercloud -8-

       #

       use strict;

       use Math::BigInt;

       my %RSA_CORE = (n=>,e=>,d=>); #p=,q=

       my $N=new Math::BigInt($RSA_CORE{ n});

       my $E=new Math::BigInt($RSA_CORE{ e});

       my $D=new Math::BigInt($RSA_CORE{ d});

       print "N=$N D=$D E=$E\n";

       sub RSA_ENCRYPT

       {

       my $r_mess = shift @_;

       my ($c,$i,$M,$C,$cmess);

       for($i=0;$i < length($$r_mess);$i++)

       {

       $c=ord(substr($$r_mess,$i,1));

       $M=Math::BigInt->new($c);

       $C=$M->copy(); $C->bmodpow($D,$N);

       $c=sprintf "%X",$C;

       $cmess.=$c;

       }

       return \$cmess;

       }

       sub RSA_DECRYPT

       {

       my $r_mess = shift @_;

       my ($c,$i,$M,$C,$dmess);

       for($i=0;$i < length($$r_mess);$i+=3)

       {

       $c=substr($$r_mess,$i,3);

       $c=hex($c);

       $M=Math::BigInt->new($c);

       $C=$M->copy(); $C->bmodpow($E,$N);

       $c=chr($C);

       $dmess.=$c;

       }

       return \$dmess;

       }

       my $mess="RSA 娃哈哈哈～～～";

       $mess=$ARGV[0] if @ARGV >= 1;

       print "原始串：",$mess,"\n";

       my $r_cmess = RSA_ENCRYPT(\$mess);

       print "加密串：",$$r_cmess,"\n";

       my $r_dmess = RSA_DECRYPT($r_cmess);

       print "解密串：",$$r_dmess,"\n";

       #EOF

       测试一下：

       C:\Temp>perl rsa-test.pl

       N= D= E=

       原始串：RSA 娃哈哈哈～～～

       加密串：5CB6CD6BCAAAA0AAA0AAA6CACACA4

       解密串：RSA 娃哈哈哈～～～

       C:\Temp>perl rsa-test.pl 安全焦点（xfocus）

       N= D= E=

       原始串：安全焦点（xfocus）

       加密串：ECF0AE0AADD7BADCFDCDB

       解密串：安全焦点（xfocus）

       <四>提高

       前面已经提到，rsa的安全来源于n足够大，我们测试中使用的n是非常小的，根本不能保障安全性，

       我们可以通过RSAKit、RSATool之类的取源码php工具获得足够大的N 及D E。

       通过工具，我们获得位的N及D E来测试一下：

       n=0xCDFCDEBEBBBBCEECC2BCE7B5FCDFBEC3AFD

       BDCDED9BDFCB3C4CAFADDFC7A6BFDADEDBC4FF9CCFD4CBB

       DECBCAB5DB9EE5AD2D7BE7ABFBEDDD2EDCCAED7E2

       BC

       d=0x

       e=0xEAACDE1E8E3D7DCF9CEFEFE8CEBBBBCBA9DADDCC

       4C5DBEECA8CEC3BAFEB9EABDBABEAFF2

       C4DD8B1CCA9D8B4B7A3C9EEFFF3AAFCDDA1DCABEABDAD2B

       

       设原始信息

       M=0x

       完成这么大数字的计算依赖于大数运算库，用perl来运算非常简单：

       A) 用d对M进行加密如下：

       c=M**d%n :

       C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x

       , 0x, 0xCDFCDEBEBBBBCEECC2BCE7B5F

       CDFBEC3AFDBDCDED9BDFCB3C4CAFADDFC7A6BFDADEDBC4F0

       F9CCFD4CBBDECBCAB5DB9EE5AD2D7BE7ABFBEDD6

       D2EDCCAED7E2BC);print $x->as_hex"

       0xbbececd7cabacfccbbd8abdea8dbdbd

       bf3a2f7c5f5aa1defafa8eed1d4cc4bebc0a1dcecaa6b

       fa3bec0cbfd8adadbc5e8bedaddd2acdeab

       fc3f6d

       即用d对M加密后信息为：

       c=0xbbececd7cabacfccbbd8abdea8dbdbd

       bf3a2f7c5f5aa1defafa8eed1d4cc4bebc0a1dcecaa6b

       fa3bec0cbfd8adadbc5e8bedaddd2acdeab

       fc3f6d

       B) 用e对c进行解密如下：

       m=c**e%n ：

       C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0xbbececd7cab

       acfccbbd8abdea8dbdbdbf3a2f7c5f5aa1def3

       afa8eed1d4cc4bebc0a1dcecaa6bfa3bec0cb

       fd8adadbc5e8bedaddd2acdeabfc3f6d, 0xEA

       ACDE1E8E3D7DCF9CEFEFE8CEBBBBCBA9DADDCCC5D

       BEECA8CEC3BAFEB9EABDBABEAFF

       2C4DD8B1CCA9D8B4B7A3C9EEFFF3AAFCDDA1DCABEABDA

       D2B, 0xCDFCDEBEBBBBCEECC2BCE7B5FCDF

       BEC3AFDBDCDED9BDFCB3C4CAFADDFC7A6BFDADEDBC4FF9CCF

       D4CBBDECBCAB5DB9EE5AD2D7BE7ABFBEDD

       D2EDCCAED7E2BC);print $x->as_hex"

       0x

       (我的P4 1.6G的机器上计算了约5秒钟）

       得到用e解密后的m=0x == M

       C) RSA通常的实现

       RSA简洁幽雅，但计算速度比较慢，通常加密中并不是直接使用RSA 来对所有的信息进行加密，

       最常见的情况是随机产生一个对称加密的密钥，然后使用对称加密算法对信息加密，之后用

       RSA对刚才的加密密钥进行加密。

       最后需要说明的是，当前小于位的N已经被证明是不安全的

       自己使用中不要使用小于位的RSA，最好使用位的搭建源码app。

       ----------------------------------------------------------

       一个简单的RSA算法实现JAVA源代码：

       filename:RSA.java

       /

*

       * Created on Mar 3,

       

*

       * TODO To change the template for this generated file go to

       * Window - Preferences - Java - Code Style - Code Templates

       */

       import java.math.BigInteger;

       import java.io.InputStream;

       import java.io.OutputStream;

       import java.io.FileInputStream;

       import java.io.FileOutputStream;

       import java.io.FileNotFoundException;

       import java.io.IOException;

       import java.io.FileWriter;

       import java.io.FileReader;

       import java.io.BufferedReader;

       import java.util.StringTokenizer;

       /

**

       * @author Steve

       

*

       * TODO To change the template for this generated type comment go to

       * Window - Preferences - Java - Code Style - Code Templates

       */

       public class RSA {

       /

**

       * BigInteger.ZERO

       */

       private static final BigInteger ZERO = BigInteger.ZERO;

       /

**

       * BigInteger.ONE

       */

       private static final BigInteger ONE = BigInteger.ONE;

       /

**

       * Pseudo BigInteger.TWO

       */

       private static final BigInteger TWO = new BigInteger("2");

       private BigInteger myKey;

       private BigInteger myMod;

       private int blockSize;

       public RSA (BigInteger key, BigInteger n, int b) {

       myKey = key;

       myMod = n;

       blockSize = b;

       }

       public void encodeFile (String filename) {

       byte[] bytes = new byte[blockSize / 8 + 1];

       byte[] temp;

       int tempLen;

       InputStream is = null;

       FileWriter writer = null;

       try {

       is = new FileInputStream(filename);

       writer = new FileWriter(filename + ".enc");

       }

       catch (FileNotFoundException e1){

       System.out.println("File not found: " + filename);

       }

       catch (IOException e1){

       System.out.println("File not found: " + filename + ".enc");

       }

       /

**

       * Write encoded message to 'filename'.enc

       */

       try {

       while ((tempLen = is.read(bytes, 1, blockSize / 8)) > 0) {

       for (int i = tempLen + 1; i < bytes.length; ++i) {

       bytes[i] = 0;

       }

       writer.write(encodeDecode(new BigInteger(bytes)) + " ");

       }

       }

       catch (IOException e1) {

       System.out.println("error writing to file");

       }

       /

**

       * Close input stream and file writer

       */

       try {

       is.close();

       writer.close();

       }

       catch (IOException e1) {

       System.out.println("Error closing file.");

       }

       }

       public void decodeFile (String filename) {

       FileReader reader = null;

       OutputStream os = null;

       try {

       reader = new FileReader(filename);

       os = new FileOutputStream(filename.replaceAll(".enc", ".dec"));

       }

       catch (FileNotFoundException e1) {

       if (reader == null)

       System.out.println("File not found: " + filename);

       else

       System.out.println("File not found: " + filename.replaceAll(".enc", "dec"));

       }

       BufferedReader br = new BufferedReader(reader);

       int offset;

       byte[] temp, toFile;

       StringTokenizer st = null;

       try {

       while (br.ready()) {

       st = new StringTokenizer(br.readLine());

       while (st.hasMoreTokens()){

       toFile = encodeDecode(new BigInteger(st.nextToken())).toByteArray();

       System.out.println(toFile.length + " x " + (blockSize / 8));

       if (toFile[0] == 0 && toFile.length != (blockSize / 8)) {

       temp = new byte[blockSize / 8];

       offset = temp.length - toFile.length;

       for (int i = toFile.length - 1; (i <= 0) && ((i + offset) <= 0); --i) {

       temp[i + offset] = toFile[i];

       }

       toFile = temp;

       }

       /*if (toFile.length != ((blockSize / 8) + 1)){

       temp = new byte[(blockSize / 8) + 1];

       System.out.println(toFile.length + " x " + temp.length);

       for (int i = 1; i < temp.length; i++) {

       temp[i] = toFile[i - 1];

       }

       toFile = temp;

       }

       else

       System.out.println(toFile.length + " " + ((blockSize / 8) + 1));*/

       os.write(toFile);

       }

       }

       }

       catch (IOException e1) {

       System.out.println("Something went wrong");

       }

       /

**

       * close data streams

       */

       try {

       os.close();

       reader.close();

       }

       catch (IOException e1) {

       System.out.println("Error closing file.");

       }

       }

       /

**

       * Performs <tt>base</tt>^^<tt>pow</tt> within the modular

       * domain of <tt>mod</tt>.

       

*

       * @param base the base to be raised

       * @param pow the power to which the base will be raisded

       * @param mod the modular domain over which to perform this operation

       * @return <tt>base</tt>^^<tt>pow</tt> within the modular

       * domain of <tt>mod</tt>.

       */

       public BigInteger encodeDecode(BigInteger base) {

       BigInteger a = ONE;

       BigInteger s = base;

       BigInteger n = myKey;

       while (!n.equals(ZERO)) {

       if(!n.mod(TWO).equals(ZERO))

       a = a.multiply(s).mod(myMod);

       s = s.pow(2).mod(myMod);

       n = n.divide(TWO);

       }

       return a;

       }

       }

       在这里提供两个版本的RSA算法JAVA实现的代码下载：

       1. 来自于 /code.aspx?ID= 的RSA算法实现源代码包:

       /rsa/

       

参考资料：

/product/showarticle.asp?id=

关于java中DecimalFormat的问题。

       把newSalary转为double型，然后再format就好了，看源码就会知道，String类型是不被允许的

public final StringBuffer format(Object number,

                                            StringBuffer toAppendTo,

                                            FieldPosition pos) {

               if (number instanceof Long || number instanceof Integer ||

                          number instanceof Short || number instanceof Byte ||

                          number instanceof AtomicInteger ||

                          number instanceof AtomicLong ||

                          (number instanceof BigInteger &&

                           ((BigInteger)number).bitLength () < )) {

                   return format(((Number)number).longValue(), toAppendTo, pos);

               } else if (number instanceof BigDecimal) {

                   return format((BigDecimal)number, toAppendTo, pos);

               } else if (number instanceof BigInteger) {

                   return format((BigInteger)number, toAppendTo, pos);

               } else if (number instanceof Number) {

                   return format(((Number)number).doubleValue(), toAppendTo, pos);

               } else {

                   throw new IllegalArgumentException("Cannot format given Object as a Number");

               }

           }

BigInteger与BigDecimal

       BigInteger - 廖雪峰的网站

        在Java中，由CPU原生提供的整型最大范围是位 long 型整数。使用 long 型整数可以直接通过CPU指令进行计算，速度非常快。

        如果我们使用的整数范围超过了 long 型怎么办？这个时候，就只能用软件来模拟一个大整数。 java.math.BigInteger 就是用来表示任意大小的整数。 BigInteger 内部用一个 int[] 数组来模拟一个非常大的整数：

        对 BigInteger 做运算的时候，只能使用实例方法，例如，加法运算：

        和 long 型整数运算比， BigInteger 不会有范围限制，但缺点是速度比较慢。

        也可以把 BigInteger 转换成 long 型：

        使用 longValueExact() 方法时，如果超出了 long 型的范围，会抛出 ArithmeticException 。

        BigInteger 和 Integer 、 Long 一样，也是不可变类，并且也继承自 Number 类。因为 Number 定义了转换为基本类型的几个方法：

        因此，通过上述方法，可以把 BigInteger 转换成基本类型。如果 BigInteger 表示的范围超过了基本类型的范围，转换时将丢失高位信息，即结果不一定是准确的。如果需要准确地转换成基本类型，可以使用 intValueExact() 、 longValueExact() 等方法，在转换时如果超出范围，将直接抛出 ArithmeticException 异常。

        如果 BigInteger 的值甚至超过了 float 的最大范围，那么返回的 float 是什么呢？

        和 BigInteger 类似， BigDecimal 可以表示一个任意大小且精度完全准确的浮点数。

        通过 BigDecimal 的 stripTrailingZeros() 方法，可以将一个 BigDecimal 格式化为一个相等的，但去掉了末尾0的 BigDecimal ：

        如果一个 BigDecimal 的 scale() 返回负数，例如， -2 ，表示这个数是个整数，并且末尾有2个0。

        可以对一个 BigDecimal 设置它的 scale ，如果精度比原始值低，那么按照指定的方法进行四舍五入或者直接截断：

        对 BigDecimal 做加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断：

        还可以对 BigDecimal 做除法的同时求余数：

        调用 divideAndRemainder() 方法时，返回的数组包含两个 BigDecimal ，分别是商和余数，其中商总是整数，余数不会大于除数。我们可以利用这个方法判断两个 BigDecimal 是否是整数倍数：

        在比较两个 BigDecimal 的值是否相等时，要特别注意，使用 equals() 方法不但要求两个 BigDecimal 的值相等，还要求它们的 scale() 相等：

        必须使用 compareTo() 方法来比较，它根据两个值的大小分别返回负数、正数和0，分别表示小于、大于和等于。

        总是使用 compareTo() 比较两个 BigDecimal 的值，不要使用 equals() ！

        如果查看 BigDecimal 的源码，可以发现，实际上一个 BigDecimal 是通过一个 BigInteger 和一个 scale 来表示的，即 BigInteger 表示一个完整的整数，而 scale 表示小数位数：

        BigDecimal 也是从 Number 继承的，也是不可变对象。

三种大数相乘算法

       在深入研究Java的BigInteger乘法操作的源码时，我们发现JDK的实现里包含了三种不同的算法，根据两个乘数的大小来选择不同的方法进行计算。这三种算法分别是：小学生算法、Karatsuba算法和Toom Cook-3算法。接下来，我们将逐一探讨这三种算法的原理和特点。

       首先，让我们从最基础的小学生算法谈起。这一算法的名称形象地描绘了其操作过程，类似于我们在小学数学课上学过的列竖式方法。它通过逐位相乘并将结果累加来计算乘积。尽管这一方法相对简单易懂，但它的时间复杂度为平方级。因此，尽管在算法理论和实现上都显得较低级，但在乘数较小时，小学生算法仍然具有一定的优势，尤其是在JDK中，当两个乘数的二进制位数都大于某个特定阈值时，就会采用此算法进行计算。

       进一步，我们来分析Karatsuba算法。这一算法的核心思想是通过分而治之的方式来降低计算复杂度。它将两个乘数分成两半，然后利用递归调用和一些巧妙的数学运算来减少所需的乘法次数。尽管Karatsuba算法在理论上的复杂度可以低于小学生算法，但在实现中，由于引入了递归调用和额外的操作，其效率提升并不明显，尤其是在输入规模较小时。因此，Karatsuba算法的使用在实际应用中受到限制。

       最后，让我们探讨Toom Cook-3算法。这一算法同样基于分而治之的策略，但与Karatsuba算法不同，它将乘数分为三份来进行计算。通过一系列的数学变换和操作，Toom Cook-3算法能够在一定程度上减少所需乘法次数，从而提高计算效率。虽然在理论分析中，Toom Cook-3算法的复杂度比前两种方法更为优化，但由于涉及复杂的数学变换和额外的操作，实际上其在实现上的复杂度和效率并未明显超过Karatsuba算法，尤其是在处理小规模数据时。

       综上所述，JDK中的BigInteger乘法操作采用了这些算法的组合，以适应不同规模的数据需求。在实际应用中，JDK倾向于选择能够提供最佳平衡计算速度和效率的算法。这种策略使得JDK在处理大数乘法时能够高效地满足各种计算需求。

       在深入研究这些算法的源码时，我们不仅能够学习到如何高效地进行大数运算，还能理解不同算法在特定场景下的优势与局限性。通过对这些算法的分析与实现，我们可以更好地掌握大数运算的理论基础和实践应用，进而提升自己的编程技能和问题解决能力。