System.out.println(a==b);结果true

Integer c=new Integer(100);

Integer d=new Integer(100);

System.out.println(c==d);结果false;

以上都是JDK1.5版本以前的

新改动：

Integer aa=100;

Integer bb=100;

System.out.println(aa==bb);结果true;

Integer aa=100;在以前的版本中是不允许的。但在JDK1.5后续版本中可以这样写。

再看这两句：

Integer aa=200;

Integer bb=200;

System.out.println(aa==bb);结果false;

当数值范围是[-128,127]时，是直接从缓存中取，当在范围之外时，生成一个新对象。附上JDK源代码

目标：实现GIF动画格式的验证码。

效果图：

说明：此GIF格式验证码有6个字符组成，共有6帧，单独每帧只有5个字符，每帧的每个字符的透明度不等，显示闪烁效果。也可以做成垂直位置变化的动画效果。 或者类似QQ的那样字体倾斜。

用到第三方类文件：一个老外写的。专门用来解GIF码的，

一共4个，类名：AnimatedGifEncoder,GifDecoder,LZWEncoder,NeuQuant;这几个类网上搜下应该有的。

就不贴了哈，有找不到的加我QQ 87388066，或者留信箱。BLOG没上传附件功能，比较郁闷。

下面贴下我的简单实现：

import jalion.giftools.AnimatedGifEncoder;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Random;

import javax.servlet.http.HttpServletResponse;

public class Test2 {
 //定义验证码字符。去除了O和I等容易混淆的字母（也可写成）
 String s[]={"A","B","C","D","E","F","G","H","G","K","M","N","P","Q","R","S","T","U","V","W","X","Y","Z"
    ,"a","b","c","d","e","f","g","h","i","j","k","m","n","p","q","r","s","t","u","v","w","x","y","z"};
 //定义生成的验证码的宽度和高度
 int width=160;
 int height=30;
 
 public void myTest(OutputStream os)
 {
  //OutputStream os=null;

   //生成字符
   AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER,1);
   AnimatedGifEncoder agf=new AnimatedGifEncoder();

   agf.start(os);
   agf.setQuality(10);
  
   agf.setDelay(100);
   agf.setRepeat(0);
   BufferedImage frame=null;
   Graphics2D teg=null;
  String rands[]=new String[6];
   for(int i=0;i<6;i++)
   {
    rands[i]=s[this.randomInt(0, s.length)];
   }
  //生成字体
   Font   font[]=new Font[6];
   for(int i=0;i<6;i++)
   {
    font[i]=this.getFont();
   }
   //生成背景颜色
   Color bgcolor=getRandColor(160, 200);
   Color linecolor=getRandColor(200, 250);
   Color fontcolor[]=new Color[6];
   Random random=new Random();
   for(int i=0;i<6;i++)
   {
    fontcolor[i]=new Color(20 + random.nextInt(110), 20 + random.nextInt(110), 20 + random.nextInt(110));
   }
   for(int i=0;i<6;i++)
   {
    frame=this.getImage(bgcolor,linecolor,fontcolor,rands,font,i);
   agf.addFrame(frame);
   frame.flush();
   }
   agf.finish();
 }
 private BufferedImage getImage(Color bgcolor,Color linecolor,Color[] fontcolor,String str[],Font[] font,int flag)
 {
  BufferedImage image = new BufferedImage(width, height,BufferedImage.TYPE_INT_RGB);
  //或得图形上下文
  Graphics2D g2d=image.createGraphics();
  //利用指定颜色填充背景
  g2d.setColor(bgcolor);
  g2d.fillRect(0, 0, width, height);
  //画背景线 4*4
  g2d.setColor(linecolor);
  for (int i = 0; i < height/4; i++) {

   g2d.drawLine(0, i*4, width, i*4);
  }
  for (int i = 0; i <width/4; i++) {

   g2d.drawLine(i*4, 0, i*4, height);
  }
  AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f);
     g2d.setComposite(ac);
     g2d.setFont(new Font("隶书", Font.ITALIC+Font.BOLD, 26));
    g2d.setColor(Color.red);
  g2d.drawString("jalion制作", 19, 25);
  
  
  //以下生成验证码 //透明度从0 循环到1 步长为0.2 。一共6个字母
  AlphaComposite ac3 =null;
  for(int i=0;i<str.length;i++)
  {
   g2d.setFont(font[i]);
   ac3 = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getAlpha(flag, i));
    g2d.setComposite(ac3);
   g2d.setColor(fontcolor[i]);
   
   g2d.drawString(str[i], 25 * i + 8, 25);
  }
  g2d.dispose();
  return image;
 }
 
 /**
  *
  * @作者:李桢
  * @日期:2007-6-27
  * @参数：
  * @返回值:
  * @描述:获得随机字体
  */
 private Font getFont()
 {
  //获得随机字体;
//设置font :字体名称:Monotype Corsiva 华文彩云 方正舒体 华文行楷,隶书
  
  Random s=new Random();
  //int i=s.nextInt(10);
  int i=7;
  if(i%2==0)
  {
   return new Font("Monotype Corsiva", Font.BOLD, 28);
  }
  else if(i%3==0)
  {
   return new Font("方正舒体", Font.BOLD, 28);
  }
//  else if(i%5==0)
//  {
//   return new Font("华文行楷", Font.BOLD, 28);
//  }
  else if(i%7==0)
  {
   return new Font("隶书", Font.BOLD, 28);
  }
  else
  {
   return new Font("方正舒体", Font.BOLD, 28);
  }
 }
 
 
 /**
  *
  * @作者:李桢
  * @日期:2007-6-27
  * @参数：
  * @返回值:
  * @描述:获得循环透明度，从0到1 步长为0.2
  */
 private float getAlpha(int i,int j)
 {
  if((i+j)>5)
  {
   
   return ((i+j)*0.2f-1.2f);
  }
  else
  {
   return (i+j)*0.2f;
  }
 }
 /**
  *
  * @作者:李桢
  * @日期:2007-6-27
  * @参数：
  * @返回值:
  * @描述:获得随机色
  */
 private Color getRandColor(int fc, int bc) {// 给定范围获得随机颜色
  Random random = new Random();
  if (fc > 255)
   fc = 255;
  if (bc > 255)
   bc = 255;
  int r = fc + random.nextInt(bc - fc);
  int g = fc + random.nextInt(bc - fc);
  int b = fc + random.nextInt(bc - fc);
  return new Color(r, g, b);
 }
  /**
   * 返回[from,to)之间的一个随机整数
   *
   * @param from 起始值
   * @param to 结束值
   * @return  [from,to)之间的一个随机整数
   */
  private int randomInt(int from,int to){
   Random r = new Random();
   return from+r.nextInt(to-from);
  }
  public static void main(String args[])
  {
   Test2 tt=new Test2();
   //tt.myTest();
  }
}

servlet：

public class yanzhengma extends HttpServlet {
 // Initialize global variables
 public void init() throws ServletException {
 }

 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  response.setContentType("image/gif");
  response.setHeader("Pragma", "No-cache");
  response.setHeader("Cache-Control", "no-cache");
  response.setDateHeader("Expires", 0);

  new Test2().myTest(response.getOutputStream());

 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  doGet(request, response);
 }

 // 这是POST，和GET差不多，不过HTTP有POST和GET两种请求方式罢了
 // Clean up resources
 public void destroy() {

 }

}

web.xml

    <!-- 验证码ｓｅｒｖｌｅｔ　开始 -->
  <servlet>
     <servlet-name>yanzhengma</servlet-name>
     <servlet-class>jalion.image.yanzhengma</servlet-class>
 </servlet>

 
 <servlet-mapping>
   <servlet-name>yanzhengma</servlet-name>
   <url-pattern>/servlet/yanzhengma</url-pattern>
 </servlet-mapping>

 <!-- 验证码ｓｅｒｖｌｅｔ　结束 --> 
 

页面中调用

 <img src="servlet/yanzhengma"/>

好了到此为止了，困了。。。，

再生成验证码字符串的地方把验证码加到cookie或者session里。

好像outputstream没有关闭。。标记下，改天再说 需要改动老外那个类。困了 睡觉了。

import static org.junit.Assert.*; //JDK5的新特性,静态引用,调用方法时,只写方法名就行.例如下文的assertEquals();

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.Ignore;
import org.junit.internal.runners.TestClassRunner;
import org.junit.runner.RunWith;

/*
 * @RunWith(Parameterized.class) 类标识
 *  @Parameters 方法标识.参数
*/
@RunWith(TestClassRunner.class)
public class CalculatorTest {

 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
  System.out.println("类初始化时执行一次,必须是public static");
 }

 @AfterClass
 public static void tearDownAfterClass() throws Exception {
  System.out.println("运行结束时执行一次,必须是public static ");
 }

 @Before
 public void setUp() throws Exception {
  System.out.println("每次执行一个测试方法之前时,执行一次");
 }

 @After
 public void tearDown() throws Exception {
  System.out.println("每次执行完一个测试方法之后,执行一次");
 }

 @Test
 public void testAdd() {
  System.out.println("这是一个测试方法,用@Test标识, @Test(timeout = 1000) 表示执行1000毫秒,对于循环用");
  assertEquals(5,5);//查看预期结果和测试结果是否相同 是Assert的方法
 }

 @Ignore("暂时忽略")
 @Test
 public void testSubstract() {
  System.out.println("这个是暂时忽略的");
  assertEquals(5,5);
 }

 @Test(expected = ArithmeticException.class)
 public void testDivide() {
  System.out.println("异常测试,是否抛出指定异常");
  assertEquals(5,6/0);
 }

}

第二个类

package jalion.uit;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)//runner 运行器
@Suite.SuiteClasses({  //标注为打包测试类 参数为想要测试的类
        CalculatorTest.class,
        //CalculatorTest2.class
        })
public class AllTests {
}

定义:序列化是指把一个对象写到一个输出流中;对象的反序列化是指从一个输入流中读取一个对象.只要实现了java.io.Serializable(标识接口)接口的对象才能被序列化和反序列化;

序列化的步骤:

1).创建一个对象输出流,它可以包装一个其他类型的输出流,比如文件输出流.

ObjectOutputStream out=new ObjectOutputStream(new fileOutputStream("c:/a.obj"));

2).通过对象输出流的writeObject()方法写对象

out.writeObject("hello");

out.close;

以上代码将一个String 对象保存到文件中.

对象的反序列化步骤:

1).创建一个对象输入流,他可以包装一个其他类型的输入流,例如文件输入流.

 ObjectInputStream in=new ObjectInputStream(new FileInputStream("c:/a.obj"));

2).通过对象输入流的readObject()方法读取对象.

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

 in.close();

当写入多个对象时,为了能正确读出数据,必须保证向输出流写对象的顺序与从输入流读对象的顺序相同.

一个简单的序列化 反序列化的例子:

=======================================================================================

Customer类(实现了Serializable标识接口)

import java.io.Serializable;
import java.util.Date;

public class Customer implements Serializable {
 private String name;
 private Date birthday;
 private transient String password; 注释①
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public Customer(String name,String password)
 {
  this.name=name;
  this.birthday=new Date();
  this.password=password;
 }
 public Date getBirthday() {
  return birthday;
 }
 public void setBirthday(Date birthday) {
  this.birthday = birthday;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 
 }

}
ObjectSaver类:执行序列化,将类写到文件中

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class ObjectSaver 
{
 public ObjectSaver()
 {
  try {
   ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("c:/a.obj"));
   String obj1="序列化对象";
   Date obj2=new Date();
   Customer obj3=new Customer("jalion","123456");
   //序列化对象
   out.writeObject(obj1);
   out.writeObject(obj2);
   out.writeObject(obj3);
   out.close();
   System.out.println("需要序列化的对象:"+obj1);
   System.out.println("需要序列化的对象:"+obj2);
   System.out.println("需要序列化的对象:"+obj3.getName()+"生日"+obj3.getBirthday()+"密码:"+obj3.getPassword());

   
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
 public static void main(String args[])
 {
  new ObjectSaver();
 }
}
ObjectRead:反序列化类 从文件中读取对象

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Date;

public class ObjectRead {
 public static void main(String args[])
 {
//  反序列化对象
  ObjectInputStream in;
  try {
   in = new ObjectInputStream(new FileInputStream("c:/a.obj"));
   String obj11=(String)in.readObject();
   Date obj22=(Date)in.readObject();
   Customer obj33=(Customer)in.readObject();
   System.out.println("反序列化的对象:"+obj11);
   System.out.println("反序列化的对象:"+obj22);
   System.out.println("反序列化的对象:"+obj33.getName()+"生日"+obj33.getBirthday()+"密码:"+obj33.getPassword());
   in.close();
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
 
 }

}

说明:由于String和Date类都实现了Serializable接口,所以可以序列化,要进行序列化的类包括其属性中引用的类必须全部实现Serializable接口才能序列化,否则将会抛出java.io.NotSerializableException异常.

========================================================================================

注释①在类Customer中,有个属性password,由于将类序列化保存在文件中,可以通过网络传输,当password比较重要时,很容易通过读取文件或者拦截网络数据来得到password,所以应当禁止对这种属性序列化.解决办法就是将这个属性用transient修饰,例如例子中的注释处.当属性有transient修饰时,不进行序列化.

ObjectRead运行结果如下:

当有transient修饰时:

反序列化的对象:序列化对象
反序列化的对象:Tue May 08 10:56:40 CST 2007
反序列化的对象:jalion生日Tue May 08 10:56:40 CST 2007密码:null

当没有transient修饰时:

反序列化的对象:序列化对象
反序列化的对象:Tue May 08 10:56:40 CST 2007
反序列化的对象:jalion生日Tue May 08 10:56:40 CST 2007密码:123456

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

除了用以上方案,来保证传输过程中的安全,还可以用通过进一步控制序列化和反序列化的方式,来达到将password加密或其他方式来实现序列化.

可以在Costumer类中提供一个readObject()和writeObject()方法,当ObjectOutputStream对一个对象序列化时,如果该对象具有writeObject()方法,那么就会执行这一方法,否则就按默认的方式序列化,在writeObject()方法中,可以调用defaultWriteObject()方法,使得对象输出流执行默认的序列化操作.反序列化同理.在修改后的Costumer类中,提供了readObject()和writeObject()方法,使得transient类型的password属性能够进行特殊的序列化

①private void writeObject(ObjectOutputStream stream){}

②private void readObject (ObjectInputStream stream) {}

以上两个方法并不是在Serializable接口中实现的.如果要进一步控制序列化的方式,就可以实现这两个方法,方法名必须与方法①②完全一致.

=========================================================================

修改后的Customer类

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;

public class Customer implements Serializable {
 private String name;
 private Date birthday;
 private transient String password;

 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public Customer(String name,String password)
 {
  this.name=name;
  this.birthday=new Date();
  this.password=password;
  
 }
 public Date getBirthday() {
  return birthday;
 }
 public void setBirthday(Date birthday) {
  this.birthday = birthday;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 
 }
 private void writeObject(ObjectOutputStream stream)
 {
  try {
   stream.defaultWriteObject();//先按默认的方式序列化
   stream.writeObject(jiami(password));
  } catch (Exception e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  }
  
 }
 private void readObject(ObjectInputStream stream)
 {
  try {
   
   stream.defaultReadObject();//先按默认的方式反序列化
   password=jiemi((String)stream.readObject());
  } catch (Exception e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  }
  
 }
 private String jiami(String password) //加密解密示意
 {
  return "gthgthg"+password;
 }
 private String jiemi(String password) //解密示意
 {
  String s=password.substring(7,password.length());
  return s;
 }

}

结论：请等待

  DecimalFormat df = new DecimalFormat("#.##");

  String  result=df.format(123456.789);

  结果：result="123456.79"

2 ，格式化为百分数

NumberFormat nf = NumberFormat.getPercentInstance();

String result=nf.format(0.89);

  结果:result="89%"

 //得到宽度（小数形式，小数点后四位）
 DecimalFormat geshi1 = new DecimalFormat("#.####");
        NumberFormat nf = NumberFormat.getPercentInstance();
 nf.setMaximumFractionDigits(2);
 nf.setMinimumFractionDigits(2);
 kuan=nf.format(Integer.parseInt(piaoshu)/Float.parseFloat(sumvotecount));

//以上代码得到当前的时间的对象

datea.set(Calendar.DAY_OF_MONTH, datea.get(Calendar.DAY_OF_MONTH)+300);

//修改日期，在当前日期基础上加上300天，只需得到你想要的日期就OK了，一切都由Calendar搞定

import javax.imageio.ImageIO;

public class Alpha {

 /**
  * @param args
  */
 public Alpha()
 {
  //创建一个600*400的图象
  BufferedImage image=new BufferedImage(600,400,BufferedImage.TYPE_INT_RGB);
  //创建java2D对象
  Graphics2D g2d=image.createGraphics();
  
  //g2d.setBackground(Color.PINK);
//  填充背景
  g2d.setColor(Color.yellow);
  g2d.fillRect(0, 0, 600, 400);
  
 
  
 
   // 创建AlphaComposite对象，并设定透明度
    AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f);
    g2d.setComposite(ac);
    g2d.setFont(new Font("隶书", Font.PLAIN, 42));
   g2d.setColor(Color.black);
   g2d.drawString("方正粗宋简体透明度为0.5", 20, 40);
   
  //画一个背景色为..的长方形
   
    AlphaComposite ac2 = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f);
     g2d.setComposite(ac2);
   g2d.setColor(Color.CYAN);
   g2d.fill3DRect(10, 200, 180, 80,false);
   
  g2d.dispose();
  try {
   FileOutputStream fs=new FileOutputStream("c://alpha.jpg");
   ImageIO.write(image, "jpg", fs);
  } catch (Exception e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  }
 }
 public static void main(String[] args) {
  // TODO 自动生成方法存根
  new Alpha();
 }

}