BlogJava-黑咖啡-随笔分类-java

解析Java对象的equals()和hashCode()的使用

飞熊 — Wed, 11 Aug 2010 00:44:00 GMT

前言

在Java语言中，equals()和hashCode()两个函数的使用是紧密配合的，你要是自己设计其中一个，就要设计另外一个。在多数情况下，这两个函数是不用考虑的，直接使用它们的默认设计就可以了。但是在一些情况下，这两个函数最好是自己设计，才能确保整个程序的正常运行。最常见的是当一个对象被加入收集对象（collection object）时，这两个函数必须自己设计。更细化的定义是：如果你想将一个对象A放入另一个收集对象B里，或者使用这个对象A为查找一个元对象在收集对象B里位置的钥匙，并支持是否容纳，删除收集对象B里的元对象这样的操作，那么，equals()和hashCode()函数必须开发者自己定义。其他情况下，这两个函数是不需要定义的。

equals():

它是用于进行两个对象的比较的，是对象内容的比较，当然也能用于进行对象参阅值的比较。什么是对象参阅值的比较？就是两个参阅变量的值得比较，我们都知道参阅变量的值其实就是一个数字，这个数字可以看成是鉴别不同对象的代号。两个对象参阅值的比较，就是两个数字的比较，两个代号的比较。这种比较是默认的对象比较方式，在Object这个对象中，这种方式就已经设计好了。所以你也不用自己来重写，浪费不必要的时间。

对象内容的比较才是设计equals()的真正目的，Java语言对equals()的要求如下，这些要求是必须遵循的。否则，你就不该浪费时间：

对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
反射性：x.equals(x)必须返回是“true”。
类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

hashCode():
这个函数返回的就是一个用来进行赫希操作的整型代号，请不要把这个代号和前面所说的参阅变量所代表的代号弄混了。后者不仅仅是个代号还具有在内存中才查找对象的位置的功能。hashCode()所返回的值是用来分类对象在一些特定的收集对象中的位置。这些对象是HashMap, Hashtable, HashSet，等等。这个函数和上面的equals()函数必须自己设计，用来协助HashMap, Hashtable, HashSet，等等对自己所收集的大量对象进行搜寻和定位。

这些收集对象究竟如何工作的，想象每个元对象hashCode是一个箱子的编码，按照编码，每个元对象就是根据hashCode()提供的代号归入相应的箱子里。所有的箱子加起来就是一个HashSet，HashMap，或 Hashtable对象，我们需要寻找一个元对象时，先看它的代码，就是hashCode()返回的整型值，这样我们找到它所在的箱子，然后在箱子里，每个元对象都拿出来一个个和我们要找的对象进行对比，如果两个对象的内容相等，我们的搜寻也就结束。这种操作需要两个重要的信息，一是对象的 hashCode()，还有一个是对象内容对比的结果。

hashCode()的返回值和equals()的关系如下：

如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。
如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。

为什么这两个规则是这样的，原因其实很简单，拿HashSet来说吧，HashSet可以拥有一个或更多的箱子，在同一个箱子中可以有一个或更多的独特元对象（HashSet所容纳的必须是独特的元对象）。这个例子说明一个元对象可以和其他不同的元对象拥有相同的hashCode。但是一个元对象只能和拥有同样内容的元对象相等。所以这两个规则必须成立。

设计这两个函数所要注意到的：
如果你设计的对象类型并不使用于收集性对象，那么没有必要自己再设计这两个函数的处理方式。这是正确的面向对象设计方法，任何用户一时用不到的功能，就先不要设计，以免给日后功能扩展带来麻烦。

如果你在设计时想别出心裁，不遵守以上的两套规则，那么劝你还是不要做这样想入非非的事。我还没有遇到过哪一个开发者和我说设计这两个函数要违背前面说的两个规则，我碰到这些违反规则的情况时，都是作为设计错误处理。

当一个对象类型作为收集型对象的元对象时，这个对象应该拥有自己处理equals()，和/或处理hashCode()的设计，而且要遵守前面所说的两种原则。equals()先要查null和是否是同一类型。查同一类型是为了避免出现ClassCastException这样的异常给丢出来。查 null是为了避免出现NullPointerException这样的异常给丢出来。

如果你的对象里面容纳的数据过多，那么这两个函数 equals()和hashCode()将会变得效率低。如果对象中拥有无法serialized的数据，equals()有可能在操作中出现错误。想象一个对象x，它的一个整型数据是transient型（不能被serialize成二进制数据流）。然而equals()和hashCode()都有依靠这个整型数据，那么，这个对象在serialization之前和之后，是否一样？答案是不一样。因为serialization之前的整型数据是有效的数据，在serialization之后，这个整型数据的值并没有存储下来，再重新由二进制数据流转换成对象后，两者（对象在serialization 之前和之后）的状态已经不同了。这也是要注意的。

知道以上这些能够帮助你：
1. 进行更好的设计和开发。
2. 进行更好的测试案例开发。
3. 在面试过程中让面试者对你的学识渊博感到满意。

引用通告地址: http://tmsoft.lsxy.com/trackback.php?tbID=82&extra=9aff4c

飞熊 2010-08-11 08:44 发表评论

COOKIE

飞熊 — Mon, 08 Feb 2010 09:33:00 GMT

1.COOKIE
HTTP COOKIE实质是服务端与在客户端之间传送的普通HTTP头,可保存也可不保存在客户的硬盘上.如果保存,每一个文件大小不超过4K的文本文件.多个COOKIE可保存到同一个文件中. 如果从编程角度来看,在JSP中COOKIE就是JAVA提供的一个类.常用的方法如下所表示，因为客户端可能不接受COOKIE，所以建议不用它，改用SESSION等其他方式。

public class cookie
{
public String getDomain() //返回该COOKIE的有效域
public int getMaxAge() //返回该COOKIE的有效期,单位为秒
public String getName() //返回该COOKIE的名称
public String getPath() //返回该COOKIE的有效路径
public boolean getSecure() //返回该COOKIE的安全设置
public String getValue() //返回该COOKIE的值
public void setDomain(java.lang.String pattern) //设置该COOKIE的有效域
public void setMaxAge(int expiry) //设置该COOKIE的有效期,单位为秒
public void setPath(java.lang.String uri) //设置该COOKIE的有效路径
public void setSecure(boolean flag) //设置该COOKIE的安全设置
public void setValue(java.lang.String newValue) //设置该COOKIE的值
}
一个COOKIE包含以下五部分:

NAME/VALUE对,设置该COOKIE的名字及它保存的值
COOKIE通常和服务器相关,如果将域设为JAVA.SUN.COM,那么该COOKIE就和这个域相关,只对该网址起作用,当浏览该网址时,浏览器将把该COOKIE的内容发送给服务端,COOKIE是作为HTTP HEADER的一部分被发送的，如果没有设置域,那么COOKIE就只和创建该COOKIE的服务器相关.
路径用于指定服务器上可以使用该COOKIE的文件所在的路径,它只对该网址下的该路径下的应用起作用."/"表示服务器上所有目录都可以使用该COOKIE.
COOKIE都有一个有效期,有效期默认值为-1,这表示没有保存该COOKIE,当该浏览器退出时,该COOKIE立即失效.
安全选项true/false,如果设置为true,那么在服务端与在客户端之间传送该COOKIE的内容时,采用HTTPS协议.
如何检查一个客户端是否支持COOKIE的方法:
用下面的方法写一个COOKIE到客户端,并确认成功
try
{
Cookie c = new Cookie("mycookie","COOKIE TEST");
response.addCookie(c);
}
catch(Exception e)
{
System.out.println(e);
}

然后在一个新的JSP文件中:用下面的方法取客户端的COOKIE到cookies中, 如果cookies.length ==0,说明该客户端的浏览器不支持COOKIE
try
{
Cookie[] cookies = request.getCookies();
if(cookies.length ==0)
{
System.out.println("not support cookie");
}
}
catch(Exception e)
{
System.out.println(e);
}

2.动态INCLUDE
用jsp:include动作实现它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE
用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>
===================================================================
1. 静态include的结果是把其他jsp引入当前jsp,两者合为一体
动态include的结构是两者独立,直到输出时才合并( 看看jsp生成的java文件就可以知道了)
2.正是因为这样,动态include的jsp文件独立性很强,是一个单独的jsp文件,需要使用的对象,页面设置,都必须有自己创建,当然,还好它和include它的页面的request范围是一致的.
而静态include纯粹是把代码写在外面的一种共享方法,所有的变量都是可以和include它的主文件共享,两者高度紧密结合,不能有变量同名的冲突.而页面设置也可以借用主文件的.

详细出处参考：http://www.jb51.net/article/13159.htm

飞熊 2010-02-08 17:33 发表评论

图片压缩和缩略图[JAVA]

飞熊 — Mon, 25 Jan 2010 03:30:00 GMT

摘要: 最近工作需要对服务器上面的文件进行压缩，并且把原来一些缩略图进行压缩。贴出代码片断供大家交流。搜略图实现规定大小画布上缩小图片，方便列表显示。图片压缩提供了2种方法。1、可以自定义压缩比。2、采用ImageIO进行默认压缩（更安全一些，不会出现内存溢出）。 private void doThumbCo... 阅读全文

飞熊 2010-01-25 11:30 发表评论

java 数字格式化：小数点、百分比

飞熊 — Sun, 17 Jan 2010 09:13:00 GMT

1.Decimalformat df1 = new Decimalformat("####.000");
　　
System.out.println(df1.format(1234.56));

显示：1234.560

2.Numberformat nf = Numberformat.getPercentInstance();
　　
　 System.out.println(nf.format(0.47));

显示：47%

3.DecimalFormat df = new DecimalFormat("###,##0.00");

System.out.println(nf.format(24.7));

显示：24.70

System.out.println(nf.format(23123.47));

显示：123,23.47

飞熊 2010-01-17 17:13 发表评论

对Java配置文件Properties的读取、写入与更新操作

飞熊 — Sun, 17 Jan 2010 09:04:00 GMT

当前项目路径是

String filepath=System.getProperty("user.dir");

对下面的程序很有用...

/**
* 实现对Java配置文件Properties的读取、写入与更新操作
*/
package test;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;

/**
* @author
* @version 2008.11.14
*/
public class SetSystemProperty {
    //属性文件的路径
    static String profilepath="mail.properties";
    /**
    * 采用静态方法
    */
    private static Properties props = new Properties();
    static {
        try {
            props.load(new FileInputStream(profilepath));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.exit(-1);
        } catch (IOException e) {
            System.exit(-1);
        }
    }

    /**
    * 读取属性文件中相应键的值
    * @param key
    *            主键
    * @return String
    */
    public static String getKeyValue(String key) {
        return props.getProperty(key);
    }

    /**
    * 根据主键key读取主键的值value
    * @param filePath 属性文件路径
    * @param key 键名
    */
    public static String readValue(String filePath, String key) {
        Properties props = new Properties();
        try {
            InputStream in = new BufferedInputStream(new FileInputStream(
                    filePath));
            props.load(in);
            String value = props.getProperty(key);
            System.out.println(key +"键的值是："+ value);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
    * 更新（或插入）一对properties信息(主键及其键值)
    * 如果该主键已经存在，更新该主键的值；
    * 如果该主键不存在，则插件一对键值。
    * @param keyname 键名
    * @param keyvalue 键值
    */
    public static void writeProperties(String keyname,String keyvalue) {
        try {
            // 调用 Hashtable 的方法 put，使用 getProperty 方法提供并行性。
            // 强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。
            OutputStream fos = new FileOutputStream(profilepath);
            props.setProperty(keyname, keyvalue);
            // 以适合使用 load 方法加载到 Properties 表中的格式，
            // 将此 Properties 表中的属性列表（键和元素对）写入输出流
            props.store(fos, "Update '" + keyname + "' value");
        } catch (IOException e) {
            System.err.println("属性文件更新错误");
        }
    }

    /**
    * 更新properties文件的键值对
    * 如果该主键已经存在，更新该主键的值；
    * 如果该主键不存在，则插件一对键值。
    * @param keyname 键名
    * @param keyvalue 键值
    */
    public void updateProperties(String keyname,String keyvalue) {
        try {
            props.load(new FileInputStream(profilepath));
            // 调用 Hashtable 的方法 put，使用 getProperty 方法提供并行性。
            // 强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。
            OutputStream fos = new FileOutputStream(profilepath);
            props.setProperty(keyname, keyvalue);
            // 以适合使用 load 方法加载到 Properties 表中的格式，
            // 将此 Properties 表中的属性列表（键和元素对）写入输出流
            props.store(fos, "Update '" + keyname + "' value");
        } catch (IOException e) {
            System.err.println("属性文件更新错误");
        }
    }
    //测试代码
    public static void main(String[] args) {
        readValue("mail.properties", "MAIL_SERVER_PASSWORD");
        writeProperties("MAIL_SERVER_INCOMING", "327@qq.com");
        System.out.println("操作完成");
    }
}

飞熊 2010-01-17 17:04 发表评论

Java反射经典实例

飞熊 — Thu, 14 Jan 2010 13:32:00 GMT

Java反射经典实例 Java Reflection Cookbook

Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射。反射机制是如今很多流行框架的实现基础，其中包括Spring、Hibernate等。原理性的问题不是本文的重点，接下来让我们在实例中学习这套精彩的机制。

1. 得到某个对象的属性

1 public Object getProperty(Object owner, String fieldName) throws Exception {
2     Class ownerClass = owner.getClass();
3
4     Field field = ownerClass.getField(fieldName);
5
6     Object property = field.get(owner);
7
8     return property;
9 }

Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

2. 得到某个类的静态属性

1 public Object getStaticProperty(String className, String fieldName)
2             throws Exception {
3     Class ownerClass = Class.forName(className);
4
5     Field field = ownerClass.getField(fieldName);
6
7     Object property = field.get(ownerClass);
8
9     return property;
10 }

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法

1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3     Class ownerClass = owner.getClass();
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(owner, args);
14 }

Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

5～9行：配置参数的Class数组，作为寻找Method的条件。

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法

1 public Object invokeStaticMethod(String className, String methodName,
2             Object[] args) throws Exception {
3     Class ownerClass = Class.forName(className);
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(null, args);
14 }

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

5. 新建实例

1
2 public Object newInstance(String className, Object[] args) throws Exception {
3     Class newoneClass = Class.forName(className);
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Constructor cons = newoneClass.getConstructor(argsClass);
12
13     return cons.newInstance(args);
14
15 }

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。

第5～第9行：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例

1 public boolean isInstance(Object obj, Class cls) {
2 return cls.isInstance(obj);
3 }

7. 得到数组中的某个元素

1 public Object getByArray(Object array, int index) {
2 return Array.get(array,index);
3 }

附完整源码：

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
* Java Reflection Cookbook
*
* @author Michael Lee
* @since 2006-8-23
* @version 0.1a
*/

public class Reflection {
    /**
     * 得到某个对象的公共属性
     *
     * @param owner, fieldName
     * @return 该属性对象
     * @throws Exception
     *
     */
    public Object getProperty(Object owner, String fieldName) throws Exception {
        Class ownerClass = owner.getClass();

        Field field = ownerClass.getField(fieldName);

        Object property = field.get(owner);

        return property;
    }

    /**
     * 得到某类的静态公共属性
     *
     * @param className   类名
     * @param fieldName   属性名
     * @return 该属性对象
     * @throws Exception
     */
    public Object getStaticProperty(String className, String fieldName)
            throws Exception {
        Class ownerClass = Class.forName(className);

        Field field = ownerClass.getField(fieldName);

        Object property = field.get(ownerClass);

        return property;
    }

    /**
     * 执行某对象方法
     *
     * @param owner
     *            对象
     * @param methodName
     *            方法名
     * @param args
     *            参数
     * @return 方法返回值
     * @throws Exception
     */
    public Object invokeMethod(Object owner, String methodName, Object[] args)
            throws Exception {

        Class ownerClass = owner.getClass();

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Method method = ownerClass.getMethod(methodName, argsClass);

        return method.invoke(owner, args);
    }

      /**
     * 执行某类的静态方法
     *
     * @param className
     *            类名
     * @param methodName
     *            方法名
     * @param args
     *            参数数组
     * @return 执行方法返回的结果
     * @throws Exception
     */
    public Object invokeStaticMethod(String className, String methodName,
            Object[] args) throws Exception {
        Class ownerClass = Class.forName(className);

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Method method = ownerClass.getMethod(methodName, argsClass);

        return method.invoke(null, args);
    }

    /**
     * 新建实例
     *
     * @param className
     *            类名
     * @param args
     *            构造函数的参数
     * @return 新建的实例
     * @throws Exception
     */
    public Object newInstance(String className, Object[] args) throws Exception {
        Class newoneClass = Class.forName(className);

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Constructor cons = newoneClass.getConstructor(argsClass);

        return cons.newInstance(args);

    }


    /**
     * 是不是某个类的实例
     * @param obj 实例
     * @param cls 类
     * @return 如果 obj 是此类的实例，则返回 true
     */
    public boolean isInstance(Object obj, Class cls) {
        return cls.isInstance(obj);
    }

    /**
     * 得到数组中的某个元素
     * @param array 数组
     * @param index 索引
     * @return 返回指定数组对象中索引组件的值
     */
    public Object getByArray(Object array, int index) {
        return Array.get(array,index);
    }
}

飞熊 2010-01-14 21:32 发表评论

java中的过滤器Filter的使用配置

飞熊 — Fri, 08 Jan 2010 09:07:00 GMT

    import java.io.IOException;
　　import java.io.PrintWriter;
　　import javax.servlet.Filter;
　　import javax.servlet.FilterChain;
　　import javax.servlet.FilterConfig;
　　import javax.servlet.RequestDispatcher;
　　import javax.servlet.ServletException;
　　import javax.servlet.ServletRequest;
　　import javax.servlet.ServletResponse;
　　import javax.servlet.http.HttpServlet;
　　import javax.servlet.http.HttpServletRequest;
　　import javax.servlet.http.HttpServletResponse;
　　import javax.servlet.http.HttpSession;
　　/**
　　* 过滤器使用：用户没用登录，不可以在浏览器输入地址访问页面
　　* @author Administrator
　　*
　　*/
　　public class OnlineFilter extends HttpServlet implements Filter {
　　public void doFilter(ServletRequest request, ServletResponse response,
  　　FilterChain chain) throws IOException, ServletException {
  　　RequestDispatcher dispatcher = request.getRequestDispatcher("Login.jsp");
  　　HttpServletRequest req =(HttpServletRequest)request;
  　　HttpServletResponse res =(HttpServletResponse)response;
  　　HttpSession session =req.getSession(true);
  　　//从session 里面获取用户名的信息
  　　String user =(String)session.getAttribute("user");
  　　//判断如果没有取到用户信息，就跳转到登陆页面，提示用户进行登陆
      if(user == null || "".equals(user)){
   　　//跳转到登陆的页面，进行用户登录
   　　dispatcher.forward(request,response);
   　　System.out.println("用户没有登录，请登陆！");
  　　}else{
  　　 System.out.println("用户已经登陆成功，允许继续操作！");
  　　}
  　　chain.doFilter(request, response);
　　}
　　public void init(FilterConfig arg0) throws ServletException {
　　}
　　/**
　　* Destruction of the servlet.

　　*/
　　public void destroy() {
　　super.destroy(); // Just puts "destroy" string in log
　　}
　　public void init() throws ServletException {
　　}
　　}
　　Web.xml配置
　　
　　
　　

sessionFilter

biz.sdna.cbrc.util.OnlineFilter

sessionFilter

/jsp/*

飞熊 2010-01-08 17:07 发表评论

Java读写Excel

飞熊 — Sat, 19 Dec 2009 15:46:00 GMT

本文主要向你演示如何使用JavaExcel API来读写Excel文件。关于JavaExcel API，这是一个开源的lib库。其相关的feature如下：

支持Excel 95, 97, 2000, XP, 2003 的制表页。
可以读写相关的Excel公式（仅支持Excel 97 及以后版本）
可以生成 Excel 2000 格式的xls文件。
支持字体，数字和日期格式。
支持单元格的阴影，边框和颜色。
可以修改已存在的制表页。
国际化多语言集。(公式目前支持，英文，法文，西班牙文和德文）
支持图表拷贝。
支持图片的插入和复制。
日志生成可以使用Jakarta Commons Logging, log4j, JDK 1.4 Logger, 等。
更多……
你可以在这里下载：http://jexcelapi.sourceforge.net/，然后，把jxl.jar加到你的Java的classpath中。

下面是两段例程，一段是如何创建Excel，一段是如何读取Excel。

创建Excel

packagewriter;

importjava.io.File;

importjava.io.IOException;

importjava.util.Locale;

importjxl.CellView;

importjxl.Workbook;

importjxl.WorkbookSettings;

importjxl.format.UnderlineStyle;

importjxl.write.Formula;

importjxl.write.Label;

importjxl.write.Number;

importjxl.write.WritableCellFormat;

importjxl.write.WritableFont;

importjxl.write.WritableSheet;

importjxl.write.WritableWorkbook;

importjxl.write.WriteException;

importjxl.write.biff.RowsExceededException;

publicclassWriteExcel {

privateWritableCellFormat timesBoldUnderline;

privateWritableCellFormat times;

privateString inputFile;

publicvoidsetOutputFile(String inputFile) {

this.inputFile = inputFile;

}

publicvoidwrite() throwsIOException, WriteException {

File file = newFile(inputFile);

WorkbookSettings wbSettings = newWorkbookSettings();

wbSettings.setLocale(newLocale("en", "EN"));

WritableWorkbook workbook = Workbook.createWorkbook(file, wbSettings);

workbook.createSheet("Report", 0);

WritableSheet excelSheet = workbook.getSheet(0);

createLabel(excelSheet);

createContent(excelSheet);

workbook.write();

workbook.close();

}

privatevoidcreateLabel(WritableSheet sheet)

throwsWriteException {

// Lets create a times font

WritableFont times10pt = newWritableFont(WritableFont.TIMES, 10);

// Define the cell format

times = newWritableCellFormat(times10pt);

// Lets automatically wrap the cells

times.setWrap(true);

// Create create a bold font with unterlines

WritableFont times10ptBoldUnderline = newWritableFont(

WritableFont.TIMES, 10, WritableFont.BOLD, false,

UnderlineStyle.SINGLE);

timesBoldUnderline = newWritableCellFormat(times10ptBoldUnderline);

// Lets automatically wrap the cells

timesBoldUnderline.setWrap(true);

CellView cv = newCellView();

cv.setFormat(times);

cv.setFormat(timesBoldUnderline);

cv.setAutosize(true);

// Write a few headers

addCaption(sheet, 0, 0, "Header 1");

addCaption(sheet, 1, 0, "This is another header");

}

privatevoidcreateContent(WritableSheet sheet) throwsWriteException,

RowsExceededException {

// Write a few number

for(inti = 1; i < 10; i++) {

// First column

addNumber(sheet, 0, i, i + 10);

// Second column

addNumber(sheet, 1, i, i * i);

}

// Lets calculate the sum of it

StringBuffer buf = newStringBuffer();

buf.append("SUM(A2:A10)");

Formula f = newFormula(0, 10, buf.toString());

sheet.addCell(f);

buf = newStringBuffer();

buf.append("SUM(B2:B10)");

f = newFormula(1, 10, buf.toString());

sheet.addCell(f);

// Now a bit of text

for(inti = 12; i < 20; i++) {

// First column

addLabel(sheet, 0, i, "Boring text "+ i);

// Second column

addLabel(sheet, 1, i, "Another text");

}

privatevoidaddCaption(WritableSheet sheet, intcolumn, introw, String s)

throwsRowsExceededException, WriteException {

Label label;

label = newLabel(column, row, s, timesBoldUnderline);

sheet.addCell(label);

}

privatevoidaddNumber(WritableSheet sheet, intcolumn, introw,

Integer integer) throwsWriteException, RowsExceededException {

Number number;

number = newNumber(column, row, integer, times);

sheet.addCell(number);

}

privatevoidaddLabel(WritableSheet sheet, intcolumn, introw, String s)

throwsWriteException, RowsExceededException {

Label label;

label = newLabel(column, row, s, times);

sheet.addCell(label);

}

publicstaticvoidmain(String[] args) throwsWriteException, IOException {

WriteExcel test = newWriteExcel();

test.setOutputFile("c:/temp/lars.xls");

test.write();

System.out

.println("Please check the result file under c:/temp/lars.xls ");

}

读取Excel

packagereader;

importjava.io.File;

importjava.io.IOException;

importjxl.Cell;

importjxl.CellType;

importjxl.Sheet;

importjxl.Workbook;

importjxl.read.biff.BiffException;

publicclassReadExcel {

privateString inputFile;

publicvoidsetInputFile(String inputFile) {

this.inputFile = inputFile;

}

publicvoidread() throwsIOException {

File inputWorkbook = newFile(inputFile);

Workbook w;

try{

w = Workbook.getWorkbook(inputWorkbook);

// Get the first sheet

Sheet sheet = w.getSheet(0);

// Loop over first 10 column and lines

for(intj = 0; j < sheet.getColumns(); j++) {

for(inti = 0; i < sheet.getRows(); i++) {

Cell cell = sheet.getCell(j, i);

CellType type = cell.getType();

if(cell.getType() == CellType.LABEL) {

System.out.println("I got a label "

+ cell.getContents());

}

if(cell.getType() == CellType.NUMBER) {

System.out.println("I got a number "

+ cell.getContents());

}

} catch(BiffException e) {

e.printStackTrace();

}

publicstaticvoidmain(String[] args) throwsIOException {

ReadExcel test = newReadExcel();

test.setInputFile("c:/temp/lars.xls");

test.read();

}

飞熊 2009-12-19 23:46 发表评论

Java中的堆内存与栈内存分配浅析

飞熊 — Fri, 11 Dec 2009 09:26:00 GMT

Java 把内存划分成两种：一种是栈内存，另一种是堆内存。在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或者对象之后，还可以在栈中定义一个特殊的变量，让栈中的这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或者对象，引用变量就相当于是为数组或者对象起的一个名称。引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。

这也是 Java 比较占内存的原因,实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针！

飞熊 2009-12-11 17:26 发表评论

java 图片切割,缩放,转换类型

飞熊 — Mon, 07 Dec 2009 07:03:00 GMT

import java.io.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.Graphics;
import java.awt.color.ColorSpace;
import javax.imageio.ImageIO;

public class ImageCut {
/**
* 缩放图像
*
* @param srcImageFile
*            源图像文件地址
* @param result
*            缩放后的图像地址
* @param scale
*            缩放比例
* @param flag
*            缩放选择:true 放大; false 缩小;
*/
public static void scale(String srcImageFile, String result, int scale,
   boolean flag) {
  try {
   BufferedImage src = ImageIO.read(new File(srcImageFile)); // 读入文件
   int width = src.getWidth(); // 得到源图宽
   int height = src.getHeight(); // 得到源图长
   if (flag) {
    // 放大
    width = width * scale;
    height = height * scale;
   } else {
    // 缩小
    width = width / scale;
    height = height / scale;
   }
   Image image = src.getScaledInstance(width, height,
     Image.SCALE_DEFAULT);
   BufferedImage tag = new BufferedImage(width, height,
     BufferedImage.TYPE_INT_RGB);
   Graphics g = tag.getGraphics();
   g.drawImage(image, 0, 0, null); // 绘制缩小后的图
   g.dispose();
   ImageIO.write(tag, "JPEG", new File(result));// 输出到文件流
  } catch (IOException e) {
   e.printStackTrace();
  }
}

/**
* 图像切割
*
* @param srcImageFile
*            源图像地址
* @param descDir
*            切片目标文件夹
* @param destWidth
*            目标切片宽度
* @param destHeight
*            目标切片高度
*/
public static void cut(String srcImageFile, String descDir, int destWidth,
   int destHeight) {
  try {
   Image img;
   ImageFilter cropFilter;
   // 读取源图像
   BufferedImage bi = ImageIO.read(new File(srcImageFile));
   int srcWidth = bi.getHeight(); // 源图宽度
   int srcHeight = bi.getWidth(); // 源图高度
   if (srcWidth > destWidth && srcHeight > destHeight) {
    Image image = bi.getScaledInstance(srcWidth, srcHeight,
      Image.SCALE_DEFAULT);
    destWidth = 200; // 切片宽度
    destHeight = 150; // 切片高度
    int cols = 0; // 切片横向数量
    int rows = 0; // 切片纵向数量
    // 计算切片的横向和纵向数量
    if (srcWidth % destWidth == 0) {
     cols = srcWidth / destWidth;
    } else {
     cols = (int) Math.floor(srcWidth / destWidth) + 1;
    }
    if (srcHeight % destHeight == 0) {
     rows = srcHeight / destHeight;
    } else {
     rows = (int) Math.floor(srcHeight / destHeight) + 1;
    }
    // 循环建立切片
    // 改进的想法:是否可用多线程加快切割速度
    for (int i = 0; i < rows; i++) {
     for (int j = 0; j < cols; j++) {
      // 四个参数分别为图像起点坐标和宽高
      // 即: CropImageFilter(int x,int y,int width,int height)
      cropFilter = new CropImageFilter(j * 200, i * 150,
        destWidth, destHeight);
      img = Toolkit.getDefaultToolkit().createImage(
        new FilteredImageSource(image.getSource(),
          cropFilter));
      BufferedImage tag = new BufferedImage(destWidth,
        destHeight, BufferedImage.TYPE_INT_RGB);
      Graphics g = tag.getGraphics();
      g.drawImage(img, 0, 0, null); // 绘制缩小后的图
      g.dispose();
      // 输出为文件
      ImageIO.write(tag, "JPEG", new File(descDir
        + "pre_map_" + i + "_" + j + ".jpg"));
     }
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
}

/**
* 图像类型转换 GIF->JPG GIF->PNG PNG->JPG PNG->GIF(X)
*/
public static void convert(String source, String result) {
  try {
   File f = new File(source);
   f.canRead();
   f.canWrite();
   BufferedImage src = ImageIO.read(f);
   ImageIO.write(src, "JPG", new File(result));
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
}

/**
* 彩色转为黑白
*
* @param source
* @param result
*/
public static void gray(String source, String result) {
  try {
   BufferedImage src = ImageIO.read(new File(source));
   ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);
   ColorConvertOp op = new ColorConvertOp(cs, null);
   src = op.filter(src, null);
   ImageIO.write(src, "JPEG", new File(result));
  } catch (IOException e) {
   e.printStackTrace();
  }
}

/**
* @param args
*/
public static void main(String[] args) {
cut("D:/logo.gif", "D:/", 20, 15);
convert("D:/logo.gif", "D:/temp.png");
}
}

飞熊 2009-12-07 15:03 发表评论

JSP连接远程FTP服务器，生成缩略图

飞熊 — Mon, 07 Dec 2009 06:24:00 GMT

需求是这样的：
图片文件放在远程FTP服务器上，图片是用作宣传的，很大。用户只能访问web服务器，用户需要在web上先预览图片的缩略图，然后点击链接下载该图片。

目前有两种解决方案
第一种方案，通过web服务器的jsp去连接ftp客户端，读取到远程FTP服务器上的图片，生成缩略图，返回到页面，然后用户选择想下载的图片，再一次通过jsp连接ftp下载到客户端。
示例代码如下：

<%--
    Document   : img
    Created on : 2007-10-30, 0:02:28
    Author     : autumn
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ page import="java.awt.image.BufferedImage" %>
<%@ page import="java.awt.*" %>
<%@ page import="com.sun.image.codec.jpeg.*" %>
<%@ page import="sun.net.ftp.FtpClient" %>
<%@ page import="sun.net.TelnetInputStream" %>
<%@ page import="java.io.ByteArrayOutputStream" %>
<%

String path = request.getParameter("path");

try {
  response.flushBuffer();
  out.clear();
  out = pageContext.pushBody();

  out.clear();
  response.setContentType("image/jpg");
  response.addHeader("pragma","NO-cache");
  response.addHeader("Cache-Control","no-cache");
  response.addDateHeader("Expries",0);

  /*连接ftp服务器*/
  FtpClient fc = new FtpClient();
  fc.openServer("127.0.0.1");                 //连接ftp服务器，参数为ftp服务器地址
  fc.login("test", "test");                   //登录ftp服务器，参数为ftp用户名密码
  fc.binary();                                //转成二进制模式
  TelnetInputStream bis = fc.get(path);      //获取文件，返回输入流

  BufferedImage image = javax.imageio.ImageIO.read(bis);
  bis.close();                                //关闭输入流
  fc.closeServer();                           //关闭服务器连接
  /*生成缩略图*/
  float tag_w=80;
  float tag_h=60;
  int old_w=image.getWidth(null);        //得到源图宽度
  int old_h=image.getHeight(null);       //得到源图高度
  int new_w=0;                            //缩略图的宽度
  int new_h=0;                            //缩略图的高度

  float tempdouble;
  if(old_w>old_h){
    tempdouble=old_w/tag_w;
  }else{
    tempdouble=old_h/tag_h;
  }
  new_w=Math.round(old_w/tempdouble);  //计算缩略图高度
  new_h=Math.round(old_h/tempdouble);  //计算缩略图宽度

  BufferedImage tag = new BufferedImage(new_w,new_h,BufferedImage.TYPE_INT_RGB);
  tag.getGraphics().drawImage(image,0,0,new_w,new_h,null);       //绘制缩小后的图

  ServletOutputStream outStream = response.getOutputStream();
  JPEGImageEncoder encoder =JPEGCodec.createJPEGEncoder(outStream);
  encoder.encode(tag);
  outStream.close();
  response.reset();
} catch (Exception ex) {
//异常处理
}
%>

<%--
    Document   : main
    Created on : 2007-10-30, 0:02:11
    Author     : autumn
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Pagetitle>
    head>
    <body>
        <h3>FTP img tseth3>
        <img src="img.jsp?path=/2.jpg"/>
    body>
html>

上例只实现从远程获得图片生成缩略图返回，没有实现远程下载图片，不过原理一样。
这个方案有一个缺点，就是生成缩略图前，得从ftp服务器读取大图，速度比较慢。

第二种解决方案是在远程ftp服务器架设一个web server，两个服务器共享文件目录，把生成缩略图的工作放在远程，而传回来的只是缩略图，所以速度会快不少。

飞熊 2009-12-07 14:24 发表评论

StringTokenizer和Splite的区别

飞熊 — Thu, 05 Nov 2009 15:43:00 GMT

1.StringTokenizer的例子
import java.util.StringTokenizer;

public class TestStringTokenizer {

    public static void main(String[] args) {
        StringTokenizer tokenizer = new StringTokenizer(
                "I am a deve,loper; in shenzhen", " |,|;");
        System.out.println(tokenizer.countTokens());

        while (tokenizer.hasMoreTokens()) {
            // logger.debug(tokenizer.nextToken(" ")); //nextToken(String
            // delim); 下一个分隔符分割的值

            System.out.println(tokenizer.nextToken());
        }
    }
}
结果：
7
I
am
a
deve
loper
in
shenzhen

2.Split的例子
public static void main(String[] args) {
        TestSplit ts = new TestSplit();
        System.out.println(ts.bubbleSort("1,32,23 14 5,7"));
    }

    public static String bubbleSort(String str1) {
        String st[] = str1.split(",| ");
        for (int i = 0; i < st.length; i++) {
            for (int j = 0; j < st.length - 1 - i; j++) {
                if (Integer.parseInt(st[j]) > Integer.parseInt(st[j + 1])) {
                    String temp = st[j];
                    st[j] = st[j + 1];
                    st[j + 1] = temp;
                }
            }
        }
        String str2 = "";
        for (int i = 0; i < st.length; i++) {
            if (str2.equals("")) {
                str2 = st[i];
            } else {
                str2 = str2 + "," + st[i];
            }
        }
        return str2;
    }

结果：1,5,7,14,23,32

飞熊 2009-11-05 23:43 发表评论

JAVA反射机制

飞熊 — Wed, 04 Nov 2009 14:02:00 GMT

public Object getProperty(Object owner, String fieldName) throws Exception {
     Class ownerClass = owner.getClass();

    Field field = ownerClass.getField(fieldName);

     Object property = field.get(owner);

     return property;
}

  public Object getStaticProperty(String className, String fieldName)
              throws Exception {
      Class ownerClass = Class.forName(className);

      Field field = ownerClass.getField(fieldName);

      Object property = field.get(ownerClass);

      return property;
}

  public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {

      Class ownerClass = owner.getClass();

      Class[] argsClass = new Class[args.length];

      for (int i = 0, j = args.length; i < j; i++) {
          argsClass[i] = args[i].getClass();
      }

     Method method = ownerClass.getMethod(methodName, argsClass);

     return method.invoke(owner, args);
}

public Object invokeStaticMethod(String className, String methodName,
              Object[] args) throws Exception {
      Class ownerClass = Class.forName(className);

      Class[] argsClass = new Class[args.length];

      for (int i = 0, j = args.length; i < j; i++) {
          argsClass[i] = args[i].getClass();
      }

     Method method = ownerClass.getMethod(methodName, argsClass);

     return method.invoke(null, args);
}

飞熊 2009-11-04 22:02 发表评论

Java实现文件拷贝的4种方法

飞熊 — Fri, 23 Oct 2009 16:41:00 GMT

第一种方法:古老的方式

public static long forJava(File f1,File f2) throws Exception{
long time=new Date().getTime();
int length=2097152;
FileInputStream in=new FileInputStream(f1);
FileOutputStream out=new FileOutputStream(f2);
byte[] buffer=new byte[length];
while(true){
   int ins=in.read(buffer);
   if(ins==-1){
    in.close();
    out.flush();
    out.close();
    return new Date().getTime()-time;
   }else
    out.write(buffer,0,ins);
}
}
方法的2参数分别是原始文件,和拷贝的目的文件.这里不做过多介绍.

实现方法很简单,分别对2个文件构建输入输出流,并且使用一个字节数组作为我们内存的缓存器, 然后使用流从f1 中读出数据到缓存里,在将缓存数据写到f2里面去.这里的缓存是2MB的字节数组

第2种方法:使用NIO中的管道到管道传输

    public static long forTransfer(File f1,File f2) throws Exception{
        long time=new Date().getTime();
        int length=2097152;
        FileInputStream in=new FileInputStream(f1);
        FileOutputStream out=new FileOutputStream(f2);
        FileChannel inC=in.getChannel();
        FileChannel outC=out.getChannel();
        int i=0;
        while(true){
            if(inC.position()==inC.size()){
                inC.close();
                outC.close();
                return new Date().getTime()-time;
            }
            if((inC.size()-inC.position())<20971520)
                length=(int)(inC.size()-inC.position());
            else
                length=20971520;
            inC.transferTo(inC.position(),length,outC);
            inC.position(inC.position()+length);
            i++;
        }
    }
实现方法:在第一种实现方法基础上对输入输出流获得其管道,然后分批次的从f1的管道中像f2的管道中输入数据每次输入的数据最大为2MB

方法3:内存文件景象写(读文件没有使用文件景象,有兴趣的可以回去试试,,我就不试了,估计会更快)

    public static long forImage(File f1,File f2) throws Exception{
        long time=new Date().getTime();
        int length=2097152;
        FileInputStream in=new FileInputStream(f1);
        RandomAccessFile out=new RandomAccessFile(f2,"rw");
        FileChannel inC=in.getChannel();
        MappedByteBuffer outC=null;
        MappedByteBuffer inbuffer=null;
        byte[] b=new byte[length];
        while(true){
            if(inC.position()==inC.size()){
                inC.close();
                outC.force();
                out.close();
                return new Date().getTime()-time;
            }
            if((inC.size()-inC.position())                 length=(int)(inC.size()-inC.position());
            }else{
                length=20971520;
            }
            b=new byte[length];
            inbuffer=inC.map(MapMode.READ_ONLY,inC.position(),length);
            inbuffer.load();
            inbuffer.get(b);
            outC=out.getChannel().map(MapMode.READ_WRITE,inC.position(),length);
            inC.position(b.length+inC.position());
            outC.put(b);
            outC.force();
        }
    }
实现方法:跟伤2个例子不一样,这里写文件流没有使用管道而是使用内存文件映射(假设文件f2在内存中).在循环中从f1的管道中读取数据到字节数组里,然后在像内存映射的f2文件中写数据.

第4种方法:管道对管道

    public static long forChannel(File f1,File f2) throws Exception{
        long time=new Date().getTime();
        int length=2097152;
        FileInputStream in=new FileInputStream(f1);
        FileOutputStream out=new FileOutputStream(f2);
        FileChannel inC=in.getChannel();
        FileChannel outC=out.getChannel();
        ByteBuffer b=null;
        while(true){
            if(inC.position()==inC.size()){
                inC.close();
                outC.close();
                return new Date().getTime()-time;
            }
            if((inC.size()-inC.position())                 length=(int)(inC.size()-inC.position());
            }else
                length=2097152;
            b=ByteBuffer.allocateDirect(length);
            inC.read(b);
            b.flip();
            outC.write(b);
            outC.force(false);
        }
    }
这里实现方式与第3种实现方式很类似,不过没有使用内存影射。

飞熊 2009-10-24 00:41 发表评论