java中2的指数怎么表示什么(java语言输出中+ a +是什么意思)

大家好，今天来为大家解答java中2的指数怎么表示什么这个问题的一些问题点，包括java语言输出中+ a +是什么意思也一样很多人还不知道，因此呢，今天就来为大家分析分析，现在让我们一起来看看吧！如果解决了您的问题，还望您关注下本站哦，谢谢~

RSA PKCS#1在java中怎么实现

楼主看看下面的代码是不是你所需要的，这是我原来用的时候收集的

import javax.crypto.Cipher;

import java.security.*;

import java.security.spec.RSAPublicKeySpec;

import java.security.spec.RSAPrivateKeySpec;

import java.security.spec.InvalidKeySpecException;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.io.*;

import java.math.BigInteger;

/**

* RSA工具类。提供加密，解密，生成密钥对等方法。

*需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。

* RSA加密原理概述

* RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。

*据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积

*===================================================================

*（该算法的安全性未得到理论的证明）

*===================================================================

*密钥的产生：

* 1.选择两个大素数 p,q,计算 n=p*q;

* 2.随机选择加密密钥 e,要求 e和(p-1)*(q-1)互质

* 3.利用 Euclid算法计算解密密钥 d,使其满足 e*d= 1(mod(p-1)*(q-1))(其中 n,d也要互质)

* 4:至此得出公钥为(n,e)私钥为(n,d)

*===================================================================

*加解密方法：

* 1.首先将要加密的信息 m(二进制表示)分成等长的数据块 m1,m2,...,mi块长 s(尽可能大),其中 2^s<n

* 2:对应的密文是： ci= mi^e(mod n)

* 3:解密时作如下计算： mi= ci^d(mod n)

*===================================================================

* RSA速度

*由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论是软件还是硬件实现。

*速度一直是RSA的缺陷。一般来说只用于少量数据加密。

*文件名：RSAUtil.java<br>

*@author赵峰<br>

*版本:1.0.1<br>

*本算法摘自网络，是对RSA算法的实现<br>

*创建时间:2009-7-10下午09:58:16<br>

*文件首先生成两个大素数，然后根据Euclid算法生成解密密钥<br>

*/

public class RSAUtil{

//密钥对

private KeyPair keyPair= null;

/**

*初始化密钥对

*/

public RSAUtil(){

try{

this.keyPair= this.generateKeyPair();

} catch(Exception e){

e.printStackTrace();

}

}

/**

*生成密钥对

*@return KeyPair

*@throws Exception

*/

private KeyPair generateKeyPair() throws Exception{

try{

KeyPairGenerator keyPairGen= KeyPairGenerator.getInstance("RSA",new org.bouncycastle.jce.provider.BouncyCastleProvider());

//这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低

final int KEY_SIZE= 1024;

keyPairGen.initialize(KEY_SIZE, new SecureRandom());

KeyPair keyPair= keyPairGen.genKeyPair();

return keyPair;

} catch(Exception e){

throw new Exception(e.getMessage());

}

}

/**

*生成公钥

*@param modulus

*@param publicExponent

*@return RSAPublicKey

*@throws Exception

*/

private RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception{

KeyFactory keyFac= null;

try{

keyFac= KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch(NoSuchAlgorithmException ex){

throw new Exception(ex.getMessage());

}

RSAPublicKeySpec pubKeySpec= new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));

try{

return(RSAPublicKey) keyFac.generatePublic(pubKeySpec);

} catch(InvalidKeySpecException ex){

throw new Exception(ex.getMessage());

}

}

/**

*生成私钥

*@param modulus

*@param privateExponent

*@return RSAPrivateKey

*@throws Exception

*/

private RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception{

KeyFactory keyFac= null;

try{

keyFac= KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch(NoSuchAlgorithmException ex){

throw new Exception(ex.getMessage());

}

RSAPrivateKeySpec priKeySpec= new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));

try{

return(RSAPrivateKey) keyFac.generatePrivate(priKeySpec);

} catch(InvalidKeySpecException ex){

throw new Exception(ex.getMessage());

}

}

/**

*加密

*@param key加密的密钥

*@param data待加密的明文数据

*@return加密后的数据

*@throws Exception

*/

public byte[] encrypt(Key key, byte[] data) throws Exception{

try{

Cipher cipher= Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE, key);

//获得加密块大小，如:加密前数据为128个byte，而key_size=1024加密块大小为127 byte,加密后为128个byte;

//因此共有2个加密块，第一个127 byte第二个为1个byte

int blockSize= cipher.getBlockSize();

// System.out.println("blockSize:"+blockSize);

int outputSize= cipher.getOutputSize(data.length);//获得加密块加密后块大小

// System.out.println("加密块大小："+outputSize);

int leavedSize= data.length% blockSize;

// System.out.println("leavedSize:"+leavedSize);

int blocksSize= leavedSize!= 0? data.length/ blockSize+ 1: data.length/ blockSize;

byte[] raw= new byte[outputSize* blocksSize];

int i= 0;

while(data.length- i* blockSize> 0){

if(data.length- i* blockSize> blockSize)

cipher.doFinal(data, i* blockSize, blockSize, raw, i* outputSize);

else

cipher.doFinal(data, i* blockSize, data.length- i* blockSize, raw, i* outputSize);

//这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到ByteArrayOutputStream中

//而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了OutputSize所以只好用dofinal方法。

i++;

}

return raw;

} catch(Exception e){

throw new Exception(e.getMessage());

}

}

/**

*解密

*@param key解密的密钥

*@param raw已经加密的数据

*@return解密后的明文

*@throws Exception

*/

@SuppressWarnings("static-access")

public byte[] decrypt(Key key, byte[] raw) throws Exception{

try{

Cipher cipher= Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(cipher.DECRYPT_MODE, key);

int blockSize= cipher.getBlockSize();

ByteArrayOutputStream bout= new ByteArrayOutputStream(64);

int j= 0;

while(raw.length- j* blockSize> 0){

bout.write(cipher.doFinal(raw, j* blockSize, blockSize));

j++;

}

return bout.toByteArray();

} catch(Exception e){

throw new Exception(e.getMessage());

}

}

/**

*返回公钥

*@return

*@throws Exception

*/

public RSAPublicKey getRSAPublicKey() throws Exception{

//获取公钥

RSAPublicKey pubKey=(RSAPublicKey) keyPair.getPublic();

//获取公钥系数(字节数组形式)

byte[] pubModBytes= pubKey.getModulus().toByteArray();

//返回公钥公用指数(字节数组形式)

byte[] pubPubExpBytes= pubKey.getPublicExponent().toByteArray();

//生成公钥

RSAPublicKey recoveryPubKey= this.generateRSAPublicKey(pubModBytes,pubPubExpBytes);

return recoveryPubKey;

}

/**

*获取私钥

*@return

*@throws Exception

*/

public RSAPrivateKey getRSAPrivateKey() throws Exception{

//获取私钥

RSAPrivateKey priKey=(RSAPrivateKey) keyPair.getPrivate();

//返回私钥系数(字节数组形式)

byte[] priModBytes= priKey.getModulus().toByteArray();

//返回私钥专用指数(字节数组形式)

byte[] priPriExpBytes= priKey.getPrivateExponent().toByteArray();

//生成私钥

RSAPrivateKey recoveryPriKey= this.generateRSAPrivateKey(priModBytes,priPriExpBytes);

return recoveryPriKey;

}

/**

*测试

*@param args

*@throws Exception

*/

public static void main(String[] args) throws Exception{

RSAUtil rsa= new RSAUtil();

String str="天龙八部、神雕侠侣、射雕英雄传白马啸西风";

RSAPublicKey pubKey= rsa.getRSAPublicKey();

RSAPrivateKey priKey= rsa.getRSAPrivateKey();

// System.out.println("加密后=="+ new String(rsa.encrypt(pubKey,str.getBytes())));

String mw= new String(rsa.encrypt(pubKey, str.getBytes()));

System.out.println("加密后："+mw);

// System.out.println("解密后：");

System.out.println("解密后=="+ new String(rsa.decrypt(priKey,rsa.encrypt(pubKey,str.getBytes()))));

}

}

java语言输出中+ a +是什么意思

java语言输出中+ a+是什么意思？

这是因为 java语言重构了+这个加法字元，当“+”这个字元的左右有一边是字串的时候，这个字元就被从构成了连线符号即"A="+a的输出是A=a的值。若“+”两边全是资料型别的话就是普通的加法运算即 a+b=（a+b的值)。

printf为输出,scanf为输入,%2c输入或输出字元,宽度为2在printf函式中如果输出的超过2个字元还是会按原来的字元如果不足2个字元会补空格。

格式化输出时，format引数中的格式化标志。

%d整数的引数会被转成有符号的十进位制数字

%u整数的引数会被转成无符号的十进位制数字

%o整数的引数会被转成无符号的八进位制数字

%x整数的引数会被转成无符号的十六进位制数字，并以小写 abcdef表示

%X整数的引数会被转成无符号的十六进位制数字，并以大写 ABCDEF表示

%f double型的引数会被转成十进位制数字，并取到小数点以下六位，四舍五入

%e double型的引数以指数形式列印，有一个数字会在小数点前，六位数字在小数点后，而在指数部分会以小写的 e来表示

%E与%e作用相同，唯一区别是指数部分将以大写的 E来表示

%g double型的引数会自动选择以%f或%e的格式来列印，其标准是根据列印的数值及所设定的有效位数来决定。

%G与%g作用相同，唯一区别在以指数形态列印时会选择%E格式。

%c整型数的引数会被转成 unsigned char型打印出

%s指向字串的引数会被逐字输出，直到出现 NULL字元为止

%p如果是引数是"void*"型指标则使用十六进位制格式显示

输出浮点数，格式为，一共有7位，其中小数4位

在printf可以这样理解*被替换成printf("%*d",number,var);中的number，然后按照printf("%number d"10);来格式化输出资料，看程式码：

#include<stdio.h>

void main()

{

printf("000000123450000000\n");

printf("1=%d,2=%*d,3=%d\n",1,5,3,3);

return;

}

printf（"%*d"，a，b）;其中a作为b的输出宽度控制.其实也就是*的替换功能了，正是由于*的替换功能结合%md的宽度控制，替换之后具体怎么输出的规则就和宽度控制的规则一样了.举个例子: printf("%*d"，2，123);输出为:123，相当于%2d输出的效果，因为123位数超过2，故原样输出，且为预设的右对齐.printf("%*2d"，1，123);输出应为[9个空格][123]，即相当于%12d输出的效果.

java语言是一种简单的，跨平台的，面向物件的，分散式的，解释的，健壮的安全的，结构的中立的，可移植的，效能很优异的多执行绪的，动态的语言。

可能是印几行字，按菱形排列，用行号作为该行的字元。例如：

白白1

白222

33333

白444

白5

为了醒目，我写白表示空格。

还有可能是整个菱形用一个数字来填，例如上面是 5行的菱形，全部用5。

%.45g这里的45看上去有点奇怪。理论上，这个数字对g格式来说，表示“输出时的有效数字个数的最大个数”（This is the maximum number of significant digits to be printed.），

这里居然定成 45个，实际上双精度浮点数有效数字最多 14位。编译器会略去.45的要求。

％g是用于浮点数的省略格式，它自动判断用%e或%f格式输出为好，判断标准是：哪个短用哪个，另外它列印时，省去小数部分后面多余的0。例如 1.23000,输出成 1.23.

java的基本数据类型有哪些

java的基本数据类型有：

1、布尔型（boolean）

取值范围：True或 False

2、字节型（byte）

取值范围：0- 255

3、短整型（short）

取值范围：-32,768~ 32767

4、整型（int）

取值范围：-2,147,483,648~ 2,147,483,647

5、长整型（long）

取值范围：-9223372036854775808~9223372036854775807

6、单精度浮点型（float）

负数范围:

-3.402823E38~-1.401298E-45

正数范围:

1.401298E-45~ 3.402823E38

7、双精度浮点型（double）

负数范围:

-1.797,693,134,862,32E308~

-4.940,656,458,412,47E-324

正数范围:

4.940,656,458,412,47E-324~

1.797,693,134,862,32E308

8、字符型（char）

取值范围：'\u0000'~'\ufff'

扩展资料

任何数据类型的数组都需要 20个字节的内存空间，加上每一数组维数占 4个字节，再加上数据本身所占用的空间。数据所占用的内存空间可以用数据元数目乘上每个元素的大小加以计算。

例如，以 4个 2字节之 Integer数据元所组成的一维数组中的数据，占 8个字节。这 8个字节加上额外的 24个字节，使得这个数组所需总内存空间为 32个字节。

参考资料：百度百科——数据类型

Java 中Double的疑问

你的理解是错误的，double型是64位，但是表示方法和整数是不一样的。你用整数的想法去理解浮点数，肯定会出错啦。给你看下我做过的笔记，你理解下：

存储布局就是一个浮点数在内存中如何表示.我们知道浮点数有float和double,前者是4个字节也就是32位,后者是8个字节也就是64位.布局分别为:

符号指数小数部分偏移附加(bias)

单精度 1[31] 8[30-23] 23[22-00] 127

双精度 1[63] 11[62-52] 52[51-00] 1023

中括号内为位的编号范围,外面为该部分所占有的位的数量.偏移附加不属于位表示的内容,是一个常量,稍后解释.

符号只有一位:0-表示正数 1-表示负数

指数部分:用指数部分的值(8位/11位,unsigned)的值减去偏移附加得到该数实际的指数例如值为200,实际指数为73=200-127.对于双精度的double来说常量bias=1023

尾数:尾数是什么?对于一个科学计数法来讲,形式象这样的 L.M×BE,那么这个L.M就是所谓的尾数(mantisa).它由一个起始位和一个小数部分组成.

OK，本文到此结束，希望对大家有所帮助。