Java開發經常使用Util工具類-StringUtil、CastUtil、CollectionUtil、ArrayUtil、PropsUtil

字符串工具類

StringUtil.java

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);
    }
}

數據類型轉換類

CastUtil.java

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;
    }
}

集合工具類

CollectionUtil.java

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);
    }
}

數組工具類

ArrayUtil.java

/**
 * 數組工具類
 */
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;
    }
}

Properties文件操做類

PropsUtil.java

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;
    }
}

用到的maven座標

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

經常使用流操做工具類

 StreamUtil.java

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;
    }
}

Json工具類

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;

    }
}

日期工具類

DataUtil.java

     /**
      * 根據年月獲取當月最後一天
      * @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;
     }

下載文件工具類

    /**
     * 下載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;
    }

解壓ZIP工具類

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編碼的文件

常常配合上一個使用，下載的壓縮包解壓爲文件而後解碼。

    /**
     * 把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();
    }