alicejava代码,alice源代码

java程序在C盘目录上建立一个aa文件夹，文件夹建立的一个名字叫ok.txt的文件。

自己适当的改改~~

创新互联公司公司2013年成立，是专业互联网技术服务公司，拥有项目网站设计、网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元惠州做网站,已为上家服务,为惠州各地企业和个人服务,联系电话:18980820575

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

public class T66 {

public static void main(String[] args) {

try {

BufferedWriter bw = new BufferedWriter(new FileWriter("c:/ok.txt"));

ListString list = new ArrayListString();

for(int i=0;i3;i++){

Scanner input = new Scanner(System.in);

System.out.println("请输入第"+(i+1)+"行");

list.add(input.next());

}

for(int i=0;ilist.size();i++){

bw.write(list.get(i));

bw.write("\r\n");

bw.flush();

}

System.out.println("写入完毕！");

System.out.println("===========读取==========");

BufferedReader br = new BufferedReader(new FileReader("c:/ok.txt"));

String str = "";

System.out.println("姓名 分数1 分数2 分数3");

while((str=br.readLine())!=null){

String [] s = str.split(",");

for(int i=0;is.length;i++){

System.out.print(s[i]+" ");

}

System.out.println();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

关于Java 中的super

toString方法用于表示对象值的字符串.

绝大多数的toString方法遵循这样的格式:类的名字,随后是一对方括号括起来的域值.下面是Employee类中的toString方法的实现(后面附上完整程序):

public String toString()

{

return"Employee[name"+name+",salary="+salary+",hireDay="+hireDay+"]";

}

实际上,还可以设计的更好一些,最好通过调用getClass().getName()得到类名得字符串,而不要将类名硬加到toString方法中.

public String toString()

{

return getClass().getName()+"[name+"+name+",salary="+salary+

",hireDay="+hireDay+"]";

}

toString方法也可以供子类调用.当然在设计子类时也应该定义自己得toString方法,并将子类得描述添加进去.如果超类使用了getClass().getName(),那么子类仅调用super.toString()就可以了,例如,下面是Manager类中的toString方法:

Class Manager extends Employee

{

.......

public String toString()

{

return super.toString()

+"[bonus="+bonus+"]";

}

}

调用toString:只要对象与一个字符串通过操作符"+"连接起来,java编译就会自动地调用toString方法,以便获得这个对象字符串描述.例如:

Point p=new Point(10,20);

String message="The current position is"+p;

//automatically invokes p.toString()

强烈建议为自己编写的每一个类增加toString方法.这样不仅自己受益,而且所有使用这个类的程序员也都会受益菲浅.

下面这个程序实现了Employee和Manager类的toString,equals和hashCode方法.

import java.util.*;

public class EqualsTest

{

public static void main(String[] args)

{

Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);

Employee alice2 = alice1;

Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);

Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);

System.out.println("alice1 == alice2: " + (alice1 == alice2));

System.out.println("alice1 == alice3: " + (alice1 == alice3));

System.out.println("alice1.equals(alice3): " + alice1.equals(alice3));

System.out.println("alice1.equals(bob): " + alice1.equals(bob));

System.out.println("bob.toString(): " + bob);

Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);

Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);

boss.setBonus(5000);

System.out.println("boss.toString(): " + boss);

System.out.println("carl.equals(boss): " + carl.equals(boss));

System.out.println("alice1.hashCode(): " + alice1.hashCode());

System.out.println("alice3.hashCode(): " + alice3.hashCode());

System.out.println("bob.hashCode(): " + bob.hashCode());

System.out.println("carl.hashCode(): " + carl.hashCode());

}

}

class Employee

{

public Employee(String n, double s, int year, int month, int day)

{

name = n;

salary = s;

GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);

hireDay = calendar.getTime();

}

public String getName()

{

return name;

}

public double getSalary()

{

return salary;

}

public Date getHireDay()

{

return hireDay;

}

public void raiseSalary(double byPercent)

{

double raise = salary * byPercent / 100;

salary += raise;

}

public boolean equals(Object otherObject)

{

// a quick test to see if the objects are identical

if (this == otherObject) return true;

// must return false if the explicit parameter is null

if (otherObject == null) return false;

// if the classes don't match, they can't be equal

if (getClass() != otherObject.getClass())

return false;

// now we know otherObject is a non-null Employee

Employee other = (Employee) otherObject;

// test whether the fields have identical values

return name.equals(other.name)

salary == other.salary

hireDay.equals(other.hireDay);

}

public int hashCode()

{

return 7 * name.hashCode()

+ 11 * new Double(salary).hashCode()

+ 13 * hireDay.hashCode();

}

public String toString()

{

return getClass().getName()

+ "[name=" + name

+ ",salary=" + salary

+ ",hireDay=" + hireDay

+ "]";

}

private String name;

private double salary;

private Date hireDay;

}

class Manager extends Employee

{

public Manager(String n, double s, int year, int month, int day)

{

super(n, s, year, month, day);

bonus = 0;

}

public double getSalary()

{

double baseSalary = super.getSalary();

return baseSalary + bonus;

}

public void setBonus(double b)

{

bonus = b;

}

public boolean equals(Object otherObject)

{

if (!super.equals(otherObject)) return false;

Manager other = (Manager) otherObject;

// super.equals checked that this and other belong to the same class

return bonus == other.bonus;

}

public int hashCode()

{

return super.hashCode()

+ 17 * new Double(bonus).hashCode();

}

public String toString()

{

return super.toString()

+ "[bonus=" + bonus

+ "]";

}

private double bonus;

}

toString()是重写了父类Object的方法，目的是把该对象以字符串的形式表达出来，

一般的实体类都要重写toString() 、equals()、hashCode()等方法方法,如User ,Student等实体类

如果一个类用来处理一些业务的就没必要重写toStirng()

在commons-lang包中都封装了这些方法，

1）public boolean equals(Object obj){

return EqualsBuilder.reflectionEquals(this.obj);

}

2）public int hashCode(){

return HashCodeBuilder.reflectionHashCode(this);

}

3）public String toStirng(){

teturn ToStringBuilder.reflectionToString(this);

}

java中的toString()函数用法

在java中，所有对象都有toString()这个方法，因为它是Object里面已经有了的方法，而所有类都是继承Object，所以“所有对象都有这个方法”

它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法

toString就是让你重写用以在调用的时候输出你像要输出的信息的,谁调用它就把谁换成字符串形式 ,toString()方法返回对象的字符串表示；

也就是当打印输出一个对象时，系统自动调用其toString方法，打印的是toString方法的返回值。

总而言之，它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法

例子1：

public class A{

public String toString(){return "this is A";}

}

如果某个方法里面有如下句子：

A obj=new A();

System.out.println(obj);

会得到输出:this is A

例子2：

public class A{

public String getString(){return "this is A";}//toString改个名字试试看

}

A obj=new A();

System.out.println(obj); //隐式调用toString()函数

//因为没用自定义toString()函数的返回值，所以会得到输出:xxxx@xxxxxxx的类名加地址形式 ；

System.out.println(obj.getString()); //显式调用getString()函数,会得到输出:this is A

所以，toString的好处是在碰到“println”之类的输出方法时会自动调用，不用显式打出来

java问题

-------------参考下------------------

JAVA加密算法的实现用例

对象

参数 algorithm 如:"DSA"

public final void initSign(PrivateKey privateKey)

throws InvalidKeyException

用指定的私钥初始化

参数:privateKey 所进行签名时用的私钥

public final void update(byte data)

throws SignatureException

public final void update(byte[] data)

throws SignatureException

public final void update(byte[] data, int off, int len)

throws SignatureException

添加要签名的信息

public final byte[] sign()

throws SignatureException

返回签名的数组,前提是initSign和update

public final void initVerify(PublicKey publicKey)

throws InvalidKeyException

用指定的公钥初始化

参数:publicKey 验证时用的公钥

public final boolean verify(byte[] signature)

throws SignatureException

验证签名是否有效,前提是已经initVerify初始化

参数: signature 签名数组

*/

import java.security.*;

import java.security.spec.*;

public class testdsa {

public static void main(String[] args) throws java.security.NoSuchAlgorithmException,java.lang.Exception {

testdsa my=new testdsa();

my.run();

}

public void run()

{

//数字签名生成密钥

//第一步生成密钥对,如果已经生成过,本过程就可以跳过,对用户来讲myprikey.dat要保存在本地

//而mypubkey.dat给发布给其它用户

if ((new java.io.File("myprikey.dat")).exists()==false) {

if (generatekey()==false) {

System.out.println("生成密钥对败");

return;

};

}

//第二步,此用户

//从文件中读入私钥,对一个字符串进行签名后保存在一个文件(myinfo.dat)中

//并且再把myinfo.dat发送出去

//为了方便数字签名也放进了myifno.dat文件中,当然也可分别发送

try {

java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));

PrivateKey myprikey=(PrivateKey)in.readObject();

in.close();

// java.security.spec.X509EncodedKeySpec pubX509=new java.security.spec.X509EncodedKeySpec(bX509);

//java.security.spec.X509EncodedKeySpec pubkeyEncode=java.security.spec.X509EncodedKeySpec

String myinfo="这是我的信息"; //要签名的信息

//用私钥对信息生成数字签名

java.security.Signature signet=java.security.Signature.getInstance("DSA");

signet.initSign(myprikey);

signet.update(myinfo.getBytes());

byte[] signed=signet.sign(); //对信息的数字签名

System.out.println ("signed(签名内容)="+byte2hex(signed));

//把信息和数字签名保存在一个文件中

java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));

out.writeObject(myinfo);

out.writeObject(signed);

out.close();

System.out.println("签名并生成文件成功");

}

catch (java.lang.Exception e) {

e.printStackTrace();

System.out.println("签名并生成文件失败");

};

//第三步

//其他人通过公共方式得到此户的公钥和文件

//其他人用此户的公钥,对文件进行检查,如果成功说明是此用户发布的信息.

//

try {

java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));

PublicKey pubkey=(PublicKey)in.readObject();

in.close();

System.out.println(pubkey.getFormat());

in=new java.io.ObjectInputStream(new java.io.FileInputStream("myinfo.dat"));

String info=(String)in.readObject();

byte[] signed=(byte[])in.readObject();

in.close();

java.security.Signature signetcheck=java.security.Signature.getInstance("DSA");

signetcheck.initVerify(pubkey);

signetcheck.update (info.getBytes());

if (signetcheck.verify(signed)) {

System.out.println("info="+info);

System.out.println("签名正常");

}

else System.out.println("非签名正常");

}

catch ( java.lang.Exception e) {e.printStackTrace();};

}

//生成一对文件myprikey.dat和mypubkey.dat---私钥和公钥,

//公钥要用户发送(文件,网络等方法)给其它用户,私钥保存在本地

public boolean generatekey()

{

try {

java.security.KeyPairGenerator keygen=java.security.KeyPairGenerator.getInstance("DSA");

// SecureRandom secrand=new SecureRandom();

// secrand.setSeed("tttt".getBytes()); //初始化随机产生器

// keygen.initialize(576,secrand); //初始化密钥生成器

keygen.initialize(512);

KeyPair keys=keygen.genKeyPair();

// KeyPair keys=keygen.generateKeyPair(); //生成密钥组

PublicKey pubkey=keys.getPublic();

PrivateKey prikey=keys.getPrivate();

java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));

out.writeObject(prikey);

out.close();

System.out.println("写入对象 prikeys ok");

out=new java.io.ObjectOutputStream (new java.io.FileOutputStream("mypubkey.dat"));

out.writeObject(pubkey);

out.close();

System.out.println("写入对象 pubkeys ok");

System.out.println("生成密钥对成功");

return true;

}

catch (java.lang.Exception e) {

e.printStackTrace();

System.out.println("生成密钥对失败");

return false;

};

}

public String byte2hex(byte[] b)

{

String hs="";

String stmp="";

for (int n=0;nb.length;n++)

{

stmp=(java.lang.Integer.toHexString(b[n] 0XFF));

if (stmp.length()==1) hs=hs+"0"+stmp;

else hs=hs+stmp;

if (nb.length-1) hs=hs+":";

}

return hs.toUpperCase();

}

}

2.4. DESede/DES对称算法

首先生成密钥,并保存(这里并没的保存的代码,可参考DSA中的方法)

KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

SecretKey deskey = keygen.generateKey();

用密钥加密明文(myinfo),生成密文(cipherByte)

Cipher c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

byte[] cipherByte=c1.doFinal(myinfo.getBytes());

传送密文和密钥,本文没有相应代码可参考DSA

.............

用密钥解密密文

c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

byte[] clearByte= c1.doFinal(cipherByte);

相对来说对称密钥的使用是很简单的,对于JCE来讲支技DES,DESede,Blowfish三种加密术

对于密钥的保存各传送可使用对象流或者用二进制编码,相关参考代码如下

SecretKey deskey = keygen.generateKey();

byte[] desEncode=deskey.getEncoded();

javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);

SecretKey mydeskey=destmp;

相关API

KeyGenerator 在DSA中已经说明,在添加JCE后在instance进可以如下参数

DES,DESede,Blowfish,HmacMD5,HmacSHA1

javax.crypto.Cipher 加/解密器

public static final Cipher getInstance(java.lang.String transformation)

throws java.security.NoSuchAlgorithmException ,

NoSuchPaddingException

返回一个指定方法的Cipher对象

参数:transformation 方法名(可用 DES,DESede,Blowfish)

public final void init(int opmode, java.security.Key key)

throws java.security.InvalidKeyException

用指定的密钥和模式初始化Cipher对象

参数:opmode 方式(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)

key 密钥

public final byte[] doFinal(byte[] input)

throws java.lang.IllegalStateException,

IllegalBlockSizeException,

BadPaddingException

对input内的串,进行编码处理,返回处理后二进制串,是返回解密文还是加解文由init时的opmode决定

注意:本方法的执行前如果有update,是对updat和本次input全部处理,否则是本inout的内容

/*

安全程序 DESede/DES测试

*/

import java.security.*;

import javax.crypto.*;

public class testdes {

public static void main(String[] args){

testdes my=new testdes();

my.run();

}

public void run() {

//添加新安全算法,如果用JCE就要把它添加进去

Security.addProvider(new com.sun.crypto.provider.SunJCE());

String Algorithm="DES"; //定义 加密算法,可用 DES,DESede,Blowfish

String myinfo="要加密的信息";

try {

//生成密钥

KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

SecretKey deskey = keygen.generateKey();

//加密

System.out.println("加密前的二进串:"+byte2hex( myinfo.getBytes()));

System.out.println("加密前的信息:"+myinfo);

Cipher c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

byte[] cipherByte=c1.doFinal(myinfo.getBytes());

System.out.println("加密后的二进串:"+byte2hex(cipherByte));

//解密

c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

byte[] clearByte=c1.doFinal(cipherByte);

System.out.println ("解密后的二进串:"+byte2hex(clearByte));

System.out.println("解密后的信息:"+(new String(clearByte)));

}

catch (java.security.NoSuchAlgorithmException e1) {e1.printStackTrace();}

catch (javax.crypto.NoSuchPaddingException e2) {e2.printStackTrace();}

catch (java.lang.Exception e3) {e3.printStackTrace();}

}

public String byte2hex(byte[] b) //二行制转字符串

{

String hs="";

String stmp="";

for (int n=0;nb.length;n++)

{

stmp=(java.lang.Integer.toHexString(b[n] 0XFF));

if (stmp.length()==1) hs=hs+"0"+stmp;

else hs=hs+stmp;

if (nb.length-1 ) hs=hs+":";

}

return hs.toUpperCase();

}

}

2.5. Diffie-Hellman密钥一致协议

公 开密钥密码体制的奠基人Diffie和Hellman所提出的 "指数密钥一致协议" (Exponential Key Agreement Protocol),该协议不要求别的安全性先决条件,允许两名用户在公开媒体上交换信息以生成 "一致"的,可以共享的密钥。在JCE的中实现用户alice生成DH类型的密钥对,如果长度用1024生成的时间请,推荐第一次生成后保存 DHParameterSpec,以便下次使用直接初始化.使其速度加快

System.out.println("ALICE: 产生 DH 对 ...");

KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");

aliceKpairGen.initialize(512);

KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

alice生成公钥发送组bob

byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

bob从alice发送来的公钥中读出DH密钥对的初始参数生成bob的DH密钥对

注意这一步一定要做,要保证每个用户用相同的初始参数生成的

DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");

bobKpairGen.initialize(dhParamSpec);

KeyPair bobKpair = bobKpairGen.generateKeyPair();

bob根据alice的公钥生成本地的DES密钥

KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");

bobKeyAgree.init(bobKpair.getPrivate());

bobKeyAgree.doPhase (alicePubKey, true);

SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

bob已经生成了他的DES密钥,他现把他的公钥发给alice,

byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

alice根据bob的公钥生成本地的DES密钥

,,,,,,解码

KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");

aliceKeyAgree.init(aliceKpair.getPrivate());

aliceKeyAgree.doPhase (bobPubKey, true);

SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

bob和alice能过这个过程就生成了相同的DES密钥,在这种基础就可进行安全能信

常用API

java.security.KeyPairGenerator 密钥生成器类

public static KeyPairGenerator getInstance(String algorithm)

throws NoSuchAlgorithmException

以指定的算法返回一个KeyPairGenerator 对象

参数: algorithm 算法名.如:原来是DSA,现在添加了 DiffieHellman(DH)

public void initialize(int keysize)

以指定的长度初始化KeyPairGenerator对象,如果没有初始化系统以1024长度默认设置

参数:keysize 算法位长.其范围必须在 512 到 1024 之间，且必须为 64 的倍数

注意:如果用1024生长的时间很长,最好生成一次后就保存,下次就不用生成了

public void initialize(AlgorithmParameterSpec params)

throws InvalidAlgorithmParameterException

以指定参数初始化

javax.crypto.interfaces.DHPublicKey

public DHParameterSpec getParams()

返回

java.security.KeyFactory

public static KeyFactory getInstance(String algorithm)

throws NoSuchAlgorithmException

以指定的算法返回一个KeyFactory

参数: algorithm 算法名:DSH,DH

public final PublicKey generatePublic(KeySpec keySpec)

throws InvalidKeySpecException

根据指定的key说明,返回一个PublicKey对象

java.security.spec.X509EncodedKeySpec

public X509EncodedKeySpec(byte[] encodedKey)

根据指定的二进制编码的字串生成一个key的说明

参数:encodedKey 二进制编码的字串(一般能过PublicKey.getEncoded()生成)

javax.crypto.KeyAgreement 密码一至类

public static final KeyAgreement getInstance(java.lang.String algorithm)

throws java.security.NoSuchAlgorithmException

返回一个指定算法的KeyAgreement对象

参数:algorithm 算法名,现在只能是DiffieHellman(DH)

public final void init(java.security.Key key)

throws java.security.InvalidKeyException

用指定的私钥初始化

参数:key 一个私钥

public final java.security.Key doPhase(java.security.Key key,

boolean lastPhase)

throws java.security.InvalidKeyException,

java.lang.IllegalStateException

用指定的公钥进行定位,lastPhase确定这是否是最后一个公钥,对于两个用户的

情况下就可以多次定次,最后确定

参数:key 公钥

lastPhase 是否最后公钥

public final SecretKey generateSecret(java.lang.String algorithm)

throws java.lang.IllegalStateException,

java.security.NoSuchAlgorithmException,

java.security.InvalidKeyException

根据指定的算法生成密钥

参数:algorithm 加密算法(可用 DES,DESede,Blowfish)

*/

import java.io.*;

import java.math.BigInteger;

import java.security.*;

import java.security.spec.*;

import java.security.interfaces.*;

import javax.crypto.*;

import javax.crypto.spec.*;

import javax.crypto.interfaces.*;

import com.sun.crypto.provider.SunJCE;

public class testDHKey {

public static void main(String argv[]) {

try {

testDHKey my= new testDHKey();

my.run();

} catch (Exception e) {

System.err.println(e);

}

}

private void run() throws Exception {

Security.addProvider (new com.sun.crypto.provider.SunJCE());

System.out.println("ALICE: 产生 DH 对 ...");

KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");

aliceKpairGen.initialize (512);

KeyPair aliceKpair = aliceKpairGen.generateKeyPair(); //生成时间长

// 张三(Alice)生成公共密钥 alicePubKeyEnc 并发送给李四(Bob) ,

//比如用文件方式,socket.....

byte[] alicePubKeyEnc = aliceKpair.getPublic ().getEncoded();

//bob接收到alice的编码后的公钥,将其解码

KeyFactory bobKeyFac = KeyFactory.getInstance("DH");

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec (alicePubKeyEnc);

PublicKey alicePubKey = bobKeyFac.generatePublic(x509KeySpec);

System.out.println("alice公钥bob解码成功");

// bob必须用相同的参数初始化的他的DH KEY对,所以要从Alice发给他的公开密钥,

//中读出参数,再用这个参数初始化他的 DH key对

//从alicePubKye中取alice初始化时用的参数

DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();

KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");

bobKpairGen.initialize(dhParamSpec);

KeyPair bobKpair = bobKpairGen.generateKeyPair();

System.out.println("BOB: 生成 DH key 对成功");

KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");

bobKeyAgree.init(bobKpair.getPrivate());

System.out.println("BOB: 初始化本地key成功");

//李四(bob) 生成本地的密钥 bobDesKey

bobKeyAgree.doPhase(alicePubKey, true);

SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

System.out.println("BOB: 用alice的公钥定位本地key,生成本地DES密钥成功");

// Bob生成公共密钥 bobPubKeyEnc 并发送给Alice,

//比如用文件方式,socket.....,使其生成本地密钥

byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

System.out.println("BOB向ALICE发送公钥");

// alice接收到 bobPubKeyEnc后生成bobPubKey

// 再进行定位,使aliceKeyAgree定位在bobPubKey

KeyFactory aliceKeyFac = KeyFactory.getInstance("DH");

x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc);

PublicKey bobPubKey = aliceKeyFac.generatePublic(x509KeySpec);

System.out.println("ALICE接收BOB公钥并解码成功");

;

KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");

aliceKeyAgree.init(aliceKpair.getPrivate());

System.out.println("ALICE: 初始化本地key成功");

aliceKeyAgree.doPhase(bobPubKey, true);

// 张三(alice) 生成本地的密钥 aliceDesKey

SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

System.out.println("ALICE: 用bob的公钥定位本地key,并生成本地DES密钥");

if (aliceDesKey.equals(bobDesKey)) System.out.println ("张三和李四的密钥相同");

//现在张三和李四的本地的deskey是相同的所以,完全可以进行发送加密,接收后解密,达到

//安全通道的的目的

/*

* bob用bobDesKey密钥加密信息

*/

Cipher bobCipher = Cipher.getInstance("DES");

bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);

String bobinfo= "这是李四的机密信息";

System.out.println("李四加密前原文:"+bobinfo);

byte[] cleartext =bobinfo.getBytes();

byte[] ciphertext = bobCipher.doFinal(cleartext);

/*

* alice用aliceDesKey密钥解密

*/

Cipher aliceCipher = Cipher.getInstance("DES");

aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey);

byte[] recovered = aliceCipher.doFinal(ciphertext);

System.out.println("alice解密bob的信息:"+(new String(recovered)));

if (!java.util.Arrays.equals(cleartext, recovered))

throw new Exception("解密后与原文信息不同");

System.out.println("解密后相同");

}

}