Java开发常用Util工具类-StringUtil、CastUtil、CollectionUtil、ArrayUtil、PropsUtil详解编程语言

package com.***.util; 
 
/** 
 * StringUtil 
 * @description: 字符串工具类 
 **/ 
public class StringUtil { 
 
    /** 
     * 判断是否为空字符串最优代码 
     * @param str 
     * @return 如果为空，则返回true 
     */ 
    public static boolean isEmpty(String str){ 
        return str == null || str.trim().length() == 0; 
    } 
 
    /** 
     * 判断字符串是否非空 
     * @param str 如果不为空，则返回true 
     * @return 
     */ 
    public static boolean isNotEmpty(String str){ 
        return !isEmpty(str); 
    } 
}

package com.***.util; 
 
/** 
 * CastUtil 
 * @description: 数据转型工具类 
 **/ 
public class CastUtil { 
    /**  
    * @Description: 转为String类型 
    * @Param: [obj]  
    * @return: java.lang.String 如果参数为null则转为空字符串 
    */  
    public static String castString(Object obj){ 
        return CastUtil.castString(obj,""); 
    } 
 
    /**  
    * @Description: 转为String类型（提供默认值） 
    * @Param: [obj, defaultValue] 将obj转为string，如果obj为null则返回default 
    * @return: String 
    */  
    public static String castString(Object obj,String defaultValue){ 
        return obj!=null?String.valueOf(obj):defaultValue; 
    } 
 
    /**  
    * @Description: 转为double类型，如果为null或者空字符串或者格式不对则返回0 
    * @Param: [obj]  
    * @return: String 
    */  
    public static double castDouble(Object obj){ 
        return CastUtil.castDouble(obj,0); 
    } 
 
    /**  
    * @Description: 转为double类型 ，如果obj为null或者空字符串或者格式不对则返回defaultValue 
    * @Param: [obj, defaultValue]  
    * @return: String obj为null或者空字符串或者格式不对返回defaultValue 
    */  
    public static double castDouble(Object obj,double defaultValue){ 
        double value = defaultValue;  //声明结果，把默认值赋给结果 
        if (obj!=null){   //判断是否为null 
            String strValue = castString(obj);  //转换为String 
            if (StringUtil.isNotEmpty(strValue)){   //判断字符串是否为空（是否为空只能判断字符串，不能判断Object） 
                try{ 
                    value = Double.parseDouble(strValue);  //不为空则把值赋给value 
                }catch (NumberFormatException e){ 
                    value = defaultValue;  //格式不对把默认值赋给value 
                } 
 
            } 
        } 
        return value; 
    } 
 
    /** 
     * 转为long型，如果obj为null或者空字符串或者格式不对则返回0 
     * @param obj 
     * @return 
     */ 
    public static long castLong(Object obj){ 
        return CastUtil.castLong(obj,0); 
    } 
 
    /** 
     * 转为long型（提供默认数值），如果obj为null或者空字符串或者格式不对则返回defaultValue 
     * @param obj 
     * @param defaultValue 
     * @return obj为null或者空字符串或者格式不对返回defaultValue 
     */ 
    public static long castLong(Object obj,long defaultValue){ 
        long value = defaultValue;  //声明结果，把默认值赋给结果 
        if (obj!=null){   //判断是否为null 
            String strValue = castString(obj);  //转换为String 
            if (StringUtil.isNotEmpty(strValue)){   //判断字符串是否为空（是否为空只能判断字符串，不能判断Object） 
                try{ 
                    value = Long.parseLong(strValue);  //不为空则把值赋给value 
                }catch (NumberFormatException e){ 
                    value = defaultValue;  //格式不对把默认值赋给value 
                } 
 
            } 
        } 
        return value; 
    } 
 
    /** 
     * 转为int型 
     * @param obj 
     * @return 如果obj为null或者空字符串或者格式不对则返回0 
     */ 
    public static int castInt(Object obj){ 
        return CastUtil.castInt(obj,0); 
    } 
 
    /** 
     * 转为int型(提供默认值) 
     * @param obj 
     * @param defaultValue 
     * @return 如果obj为null或者空字符串或者格式不对则返回defaultValue 
     */ 
    public static int castInt(Object obj,int defaultValue){ 
        int value = defaultValue;  //声明结果，把默认值赋给结果 
        if (obj!=null){   //判断是否为null 
            String strValue = castString(obj);  //转换为String 
            if (StringUtil.isNotEmpty(strValue)){   //判断字符串是否为空（是否为空只能判断字符串，不能判断Object） 
                try{ 
                    value = Integer.parseInt(strValue);  //不为空则把值赋给value 
                }catch (NumberFormatException e){ 
                    value = defaultValue;  //格式不对把默认值赋给value 
                } 
 
            } 
        } 
        return value; 
    } 
 
    /** 
     * 转为boolean型，不是true的返回为false 
     * @param obj 
     * @return 
     */ 
    public static boolean castBoolean(Object obj){ 
        return CastUtil.castBoolean(obj,false); 
    } 
 
 
    /** 
     * 转为boolean型（提供默认值） 
     * @param obj 
     * @param defaultValue 
     * @return 
     */ 
    public static boolean castBoolean(Object obj,boolean defaultValue){ 
        boolean value = defaultValue; 
        if (obj!=null){  //为null则返回默认值 
            value = Boolean.parseBoolean(castString(obj));  //底层会把字符串和true对比，所以不用判断是否为空字符串 
        } 
        return value; 
    } 
}

package com.***.util; 
 
import org.apache.commons.collections4.CollectionUtils; 
import org.apache.commons.collections4.MapUtils; 
import java.util.Collection; 
import java.util.Map; 
 
/** 
 * CollectionUtil 
 * @description: 集合工具类 
 **/ 
public class CollectionUtil { 
    /** 
     * 判断collection是否为空 
     * @param collection 
     * @return 
     */ 
    public static boolean isEmpty(Collection<?> collection){ 
        //return CollectionUtils.isEmpty(collection); 
        return collection == null || collection.isEmpty(); 
    } 
 
    /** 
     * 判断Collection是否非空 
     * @return 
     */ 
    public static boolean isNotEmpty(Collection<?> collection){ 
        return !isEmpty(collection); 
    } 
 
    /** 
     * 判断map是否为空 
     * @param map 
     * @return 
     */ 
    public static boolean isEmpty(Map<?,?> map){ 
        //return MapUtils.isEmpty(map); 
        return map == null || map.isEmpty(); 
    } 
 
    /** 
     * 判断map是否非 
     * @param map 
     * @return 
     */ 
    public static boolean isNotEmpty(Map<?,?> map){ 
        return !isEmpty(map); 
    } 
}

/** 
 * 数组工具类 
 */ 
public class ArrayUtil { 
    /** 
     * 判断数组是否为空 
     * @param array 
     * @return 
     */ 
    public static boolean isNotEmpty(Object[] array){ 
        return !isEmpty(array); 
    } 
 
    /** 
     * 判断数组是否非空 
     * @param array 
     * @return 
     */ 
    public static boolean isEmpty(Object[] array){ 
        return array==null||array.length==0; 
    } 
}

package com.***.util; 
 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
 
import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.Properties; 
 
/** 
 * 属性文件工具类 
 */ 
public class PropsUtil { 
    private static final Logger LOGGER = LoggerFactory.getLogger(PropsUtil.class); 
 
    /** 
     * 加载属性文件 
     * @param fileName fileName一定要在class下面及java根目录或者resource跟目录下 
     * @return 
     */ 
    public static Properties loadProps(String fileName){ 
        Properties props = new Properties(); 
        InputStream is = null; 
        try { 
            //将资源文件加载为流 
            is = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);
            props.load(is); 
            if(is==null){ 
               throw new FileNotFoundException(fileName+"file is not Found"); 
            } 
        } catch (FileNotFoundException e) { 
            LOGGER.error("load properties file filure",e); 
        }finally { 
            if(is !=null){ 
                try { 
                    is.close(); 
                } catch (IOException e) { 
                    LOGGER.error("close input stream failure",e); 
                } 
            } 
        } 
        return props; 
    } 
 
    /** 
     * 获取字符型属性（默认值为空字符串） 
     * @param props 
     * @param key 
     * @return 
     */ 
    public static String getString(Properties props,String key){ 
        return getString(props,key,""); 
    } 
 
    /** 
     * 获取字符型属性（可制定默认值） 
     * @param props 
     * @param key 
     * @param defaultValue 当文件中无此key对应的则返回defaultValue 
     * @return 
     */ 
    public static String getString(Properties props,String key,String defaultValue){ 
        String value = defaultValue; 
        if (props.containsKey(key)){ 
            value = props.getProperty(key); 
        } 
        return value; 
    } 
 
    /** 
     * 获取数值型属性（默认值为0） 
     * @param props 
     * @param key 
     * @return 
     */ 
    public static int getInt(Properties props,String key){ 
        return getInt(props,key,0); 
    } 
 
    /** 
     * 获取数值型属性（可指定默认值） 
     * @param props 
     * @param key 
     * @param defaultValue 
     * @return 
     */ 
    public static int getInt(Properties props,String key,int defaultValue){ 
        int value = defaultValue; 
        if (props.containsKey(key)){ 
            value = CastUtil.castInt(props.getProperty(key)); 
        } 
        return value; 
    } 
 
    /** 
     * 获取布尔型属性（默认值为false） 
     * @param props 
     * @param key 
     * @return 
     */ 
    public static boolean getBoolean(Properties props,String key){ 
        return getBoolean(props,key,false); 
    } 
 
    /** 
     * 获取布尔型属性（可指定默认值） 
     * @param props 
     * @param key 
     * @param defaultValue 
     * @return 
     */ 
    public static boolean getBoolean(Properties props,String key,Boolean defaultValue){ 
        boolean value = defaultValue; 
        if (props.containsKey(key)){ 
            value = CastUtil.castBoolean(props.getProperty(key)); 
        } 
        return value; 
    } 
}

        <!--slf4j--> 
        <dependency> 
            <groupId>org.slf4j</groupId> 
            <artifactId>slf4j-log4j12</artifactId> 
            <version>1.7.9</version> 
        </dependency>

public class StreamUtil { 
    private static final Logger LOGGER = LoggerFactory.getLogger(StreamUtil.class); 
 
    /** 
     * 从输入流中获取字符串 
     * @param is 
     * @return 
     */ 
    public static String getString(InputStream is){ 
        StringBuilder sb = new StringBuilder(); 
        try { 
            BufferedReader reader = new BufferedReader(new InputStreamReader(is)); 
            String line; 
            while((line=reader.readLine())!=null){ 
                sb.append(line); 
            } 
        } catch (IOException e) { 
            LOGGER.error("get string failure",e); 
            throw new RuntimeException(e); 
        } 
        return sb.toString(); 
    } 
 
}

public class CodecUtil { 
    private static final Logger LOGGER = LoggerFactory.getLogger(CodecUtil.class); 
 
    /** 
     * 将URL编码 
     */ 
    public static String encodeURL(String source){ 
        String target; 
        try { 
            target = URLEncoder.encode(source,"utf-8"); 
        } catch (UnsupportedEncodingException e) { 
            LOGGER.error("encode url failure",e); 
            throw new RuntimeException(e); 
            //e.printStackTrace(); 
        } 
        return target; 
    } 
 
    /** 
     * 将URL解码 
     */ 
    public static String dencodeURL(String source){ 
        String target; 
        try { 
            target = URLDecoder.decode(source,"utf-8"); 
        } catch (UnsupportedEncodingException e) { 
            LOGGER.error("encode url failure",e); 
            throw new RuntimeException(e); 
            //e.printStackTrace(); 
        } 
        return target; 
    } 
}

package org.smart4j.framework.util; 
 
import com.fasterxml.jackson.core.JsonProcessingException; 
import com.fasterxml.jackson.databind.ObjectMapper; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
 
import java.io.IOException; 
 
/** 
 * @program: JsonUtil 
 * @description: JSON工具类 
 * @author: Created by QiuYu 
 * @create: 2018-10-24 15:55 
 */ 
 
public class JsonUtil { 
    private static final Logger LOGGER = LoggerFactory.getLogger(JsonUtil.class); 
 
    private static final ObjectMapper OBJECT_MAPPER =new ObjectMapper(); 
 
    /** 
     * 将POJO转换为JSON 
     */ 
    public static <T> String toJson(T obj){ 
        String json; 
        try { 
            json = OBJECT_MAPPER.writeValueAsString(obj); 
        } catch (JsonProcessingException e) { 
            LOGGER.error("convert POJO to JSON failure",e); 
            throw new RuntimeException(e); 
            //e.printStackTrace(); 
        } 
        return json; 
    } 
 
    /** 
     * 将JSON转为POJO 
     */ 
    public static <T> T fromJson(String json,Class<T> type){ 
        T pojo; 
        try { 
            pojo = OBJECT_MAPPER.readValue(json,type); 
        } catch (IOException e) { 
            LOGGER.error("convert JSON to POJO failure",e); 
            throw new RuntimeException(e); 
            //e.printStackTrace(); 
        } 
        return pojo; 
 
    } 
}

     /** 
      * 根据年月获取当月最后一天 
      * @param yearmonth yyyy-MM 
      * @return yyyy-MM-dd 
      * @throws ParseException 
      */ 
     public static String getLastDayOfMonth(String yearmonth) { 
         try { 
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM"); 
             Date dd = format.parse(yearmonth); 
             Calendar cal = Calendar.getInstance(); 
             cal.setTime(dd); 
             int cc=cal.getActualMaximum(Calendar.DAY_OF_MONTH); 
             String result = yearmonth+"-"+cc; 
             return result; 
        } catch (ParseException e) { 
            e.printStackTrace(); 
        } 
        return null; 
     }

    /**  
     * 时间戳转换成日期格式字符串  
     * @param seconds 精确到秒的字符串  
     * @param formatStr 为null时默认yyyy-MM-dd HH:mm:ss 
     * @return 返回日期字符串 
     */   
    public static String timeStamp2Date(String seconds,String format) {   
        if(seconds == null || seconds.isEmpty() || seconds.equals("null")){   
            return "";   
        } 
         
        if(format == null || format.isEmpty()){ 
            format = "yyyy-MM-dd HH:mm:ss"; 
        }    
        SimpleDateFormat sdf = new SimpleDateFormat(format); 
        //Date是精确到毫秒的13位时间戳,所以秒要*1000 
        Date date = new Date(Long.valueOf(seconds+"000")); 
        String dateString = sdf.format(date); 
        return dateString;   
    } 
 
    /**  
     * 日期格式字符串转换成时间戳  
     * @param date 字符串日期  
     * @param format 默认：yyyy-MM-dd HH:mm:ss  
     * @return 精确到秒的时间戳 
     */ 
    public static String date2TimeStamp(String date_str,String format){   
        if(format == null || format.isEmpty()){ 
            format = "yyyy-MM-dd HH:mm:ss"; 
        } 
        try {   
            SimpleDateFormat sdf = new SimpleDateFormat(format);   
            return String.valueOf(sdf.parse(date_str).getTime()/1000);   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
        return "";   
    } 
 
    /**  
     * 取得当前时间戳（精确到秒）  
     * @return  
     */   
    public static String getNowTimeStamp(){   
        long time = System.currentTimeMillis(); 
        String timestamp = String.valueOf(time/1000);   
        return timestamp;   
    }

package com.gmtx.system.tools; 
 
import java.io.Serializable; 
import java.math.BigDecimal; 
import java.math.RoundingMode; 
 
/** 
 * @ClassName: DoubleTool 
 * @Description: java类精确计算小数 
 * double的计算不精确，会有类似0.0000000000000002的误差，正确的方法是使用BigDecimal或者用整型,整型地方法适合于货币精度已知的情况，比如12.11+1.10转成1211+110计算，最后再/100即可 
 * @author 秋雨 
 * 修改历史  
 *  序号------原因------修改人---日期--- 
 *   1.                                
 *   2.                                 
 */ 
public class DoubleTool implements Serializable { 
    private static final long serialVersionUID = -3345205828566485102L; 
    //默认除法运算精度 
    private static final Integer DEF_DIV_SCALE = 2; 
 
    /** 
     * 提供精确的加法运算。 
     * @param value1 被加数 
     * @param value2 加数 
     * @return 两个参数的和 
     */ 
    public static Double add(Double value1, Double value2) { 
        BigDecimal b1 = new BigDecimal(Double.toString(value1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(value2)); 
        return b1.add(b2).doubleValue(); 
    } 
 
    /** 
     * 提供精确的减法运算。 
     * @param value1 被减数 
     * @param value2 减数 
     * @return 两个参数的差 
     */ 
    public static double sub(Double value1, Double value2) { 
        BigDecimal b1 = new BigDecimal(Double.toString(value1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(value2)); 
        return b1.subtract(b2).doubleValue(); 
    } 
 
    /** 
     * 提供精确的乘法运算。 
     * @param value1 被乘数 
     * @param value2 乘数 
     * @return 两个参数的积 
     */ 
    public static Double mul(Double value1, Double value2) { 
        BigDecimal b1 = new BigDecimal(Double.toString(value1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(value2)); 
        return b1.multiply(b2).doubleValue(); 
    } 
 
    /** 
     * 提供（相对）精确的除法运算，当发生除不尽的情况时， 精确到小数点以后10位，以后的数字四舍五入。 
     * @param dividend 被除数 
     * @param divisor  除数 
     * @return 两个参数的商 
     */ 
    public static Double divide(Double dividend, Double divisor) { 
        return divide(dividend, divisor, DEF_DIV_SCALE); 
    } 
 
    /** 
     * 提供（相对）精确的除法运算。 当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。 
     * @param dividend 被除数 
     * @param divisor  除数 
     * @param scale    表示表示需要精确到小数点以后几位。 
     * @return 两个参数的商 
     */ 
    public static Double divide(Double dividend, Double divisor, Integer scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException("The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(Double.toString(dividend)); 
        BigDecimal b2 = new BigDecimal(Double.toString(divisor)); 
        return b1.divide(b2, scale,RoundingMode.HALF_UP).doubleValue(); 
    } 
 
    /** 
     * 提供指定数值的（精确）小数位四舍五入处理。 
     * @param value 需要四舍五入的数字 
     * @param scale 小数点后保留几位 
     * @return 四舍五入后的结果 
     */ 
    public static double round(double value,int scale){ 
        if(scale<0){ 
            throw new IllegalArgumentException("The scale must be a positive integer or zero"); 
        } 
        BigDecimal b = new BigDecimal(Double.toString(value)); 
        BigDecimal one = new BigDecimal("1"); 
        return b.divide(one,scale, RoundingMode.HALF_UP).doubleValue(); 
    } 
}

    /** 
     * 下载url的文件到指定文件路径里面,如果文件父文件夹不存在则自动创建 
     * url 下载的http地址 
     * path 文件存储地址 
     * return 如果文件大小大于2k则返回true 
     */ 
    public static boolean downloadCreateDir(String url,String path){ 
        HttpURLConnection connection=null; 
        InputStream in = null; 
        FileOutputStream o=null; 
        try{ 
            URL httpUrl=new URL(url); 
            connection = (HttpURLConnection) httpUrl.openConnection(); 
            connection.setRequestProperty("accept", "*/*"); 
            connection.setRequestProperty("Charset", "gbk"); 
            connection.setRequestProperty("connection", "Keep-Alive"); 
            connection.setRequestProperty("user-agent","Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)"); 
            connection.setRequestMethod("GET"); 
             
            byte[] data=new byte[1024]; 
            File f=new File(path); 
            File parentDir = f.getParentFile(); 
            if (!parentDir.exists()) { 
                parentDir.mkdirs(); 
            } 
            if(connection.getResponseCode() == 200){ 
                in = connection.getInputStream(); 
                o=new FileOutputStream(path); 
                int n=0; 
                while((n=in.read(data))>0){ 
                    o.write(data, 0, n); 
                    o.flush(); 
                } 
            } 
            if(f.length()>2048){  //代表文件大小 
                return true;  //如果文件大于2k则返回true 
            } 
        }catch(Exception ex){ 
            ex.printStackTrace(); 
        }finally{ 
            try{ 
                if(in != null){ 
                    in.close(); 
                } 
            }catch(IOException ex){ 
                ex.printStackTrace(); 
            } 
            try{o.close();}catch(Exception ex){} 
            try{connection.disconnect();}catch(Exception ex){} 
        } 
        return false; 
    }

package com.***.tools; 
 
import java.io.BufferedOutputStream; 
import java.io.File; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.nio.charset.Charset; 
import java.util.Enumeration; 
import java.util.zip.ZipEntry; 
import java.util.zip.ZipFile; 
 
/** 
 * 解压zip文件 
 */ 
public final class ZipUtil { 
    private static final int buffer = 2048; 
 
    /** 
     * 解压Zip文件 
     * @param path zip文件目录 
     */ 
    public static void unZip(String path) { 
        int count = -1; 
        String savepath = ""; 
 
        File file = null; 
        InputStream is = null; 
        FileOutputStream fos = null; 
        BufferedOutputStream bos = null; 
 
        savepath = path.substring(0, path.lastIndexOf(".")) + File.separator; // 保存解压文件目录 
        new File(savepath).mkdir(); // 创建保存目录 
        ZipFile zipFile = null; 
        try { 
            zipFile = new ZipFile(path,Charset.forName("GBK")); // 解决中文乱码问题 
            Enumeration<?> entries = zipFile.entries();  //枚举ZIP中的所有文件 
 
            while (entries.hasMoreElements()) { 
                byte buf[] = new byte[buffer]; 
 
                ZipEntry entry = (ZipEntry) entries.nextElement(); 
 
                String filename = entry.getName();  //获取文件名 
                filename = savepath + filename; 
                boolean ismkdir = false; 
                if (filename.lastIndexOf("/") != -1) { // 检查此文件是否带有文件夹 
                    ismkdir = true; 
                } 
 
                if (entry.isDirectory()) { // 如果此枚举文件是文件夹则创建,并且遍历下一个 
                    file = new File(filename); 
                    file.mkdirs(); 
                    continue; 
                } 
                file = new File(filename);  //此枚举文件不是目录 
                if (!file.exists()) {  //如果文件不存在并且文件带有目录 
                    if (ismkdir) { 
                        new File(filename.substring(0, filename 
                                .lastIndexOf("/"))).mkdirs(); // 先创建目录 
                    } 
                } 
                file.createNewFile(); //再创建文件 
 
                is = zipFile.getInputStream(entry); 
                fos = new FileOutputStream(file); 
                bos = new BufferedOutputStream(fos, buffer); 
 
                while ((count = is.read(buf)) > -1) { 
                    bos.write(buf, 0, count); 
                } 
                bos.flush(); 
            } 
        } catch (IOException ioe) { 
            ioe.printStackTrace(); 
        } finally { 
            try { 
                if (bos != null) { 
                    bos.close(); 
                } 
                if (fos != null) { 
                    fos.close(); 
                } 
                if (is != null) { 
                    is.close(); 
                } 
                if (zipFile != null) { 
                    zipFile.close(); 
                } 
            } catch (Exception e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
}

    /** 
     * 把GBK文件转为UTF-8 
     * 两个参数值可以为同一个路径 
     * @param srcFileName 源文件 
     * @param destFileName 目标文件 
     * @throws IOException 
     */ 
    private static void transferFile(String srcFileName, String destFileName) throws IOException { 
        String line_separator = System.getProperty("line.separator");  
        FileInputStream fis = new FileInputStream(srcFileName); 
        StringBuffer content = new StringBuffer(); 
        DataInputStream in = new DataInputStream(fis); 
        BufferedReader d = new BufferedReader(new InputStreamReader(in, "GBK"));  //源文件的编码方式 
        String line = null; 
        while ((line = d.readLine()) != null) 
         content.append(line + line_separator); 
        d.close(); 
        in.close(); 
        fis.close(); 
             
        Writer ow = new OutputStreamWriter(new FileOutputStream(destFileName), "utf-8");  //需要转换的编码方式 
        ow.write(content.toString()); 
        ow.close(); 
    }