java经典代码

因为欣赏所以转载 原文地址 http://wuhaidong.iteye.com/blog/1668689

 

  1. package com.common.file;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8. import java.io.InputStream;  
  9. import java.io.OutputStream;  
  10. import java.text.DateFormat;  
  11. import java.util.Date;  
  12. import java.util.Iterator;  
  13.   
  14. import javax.swing.text.html.HTMLDocument.HTMLReader.FormAction;  
  15.   
  16. /** 
  17.  *  
  18.  * 功能描述： 
  19.  *  
  20.  * @author Administrator 
  21.  * @Date Jul 19, 2008 
  22.  * @Time 9:46:11 AM 
  23.  * @version 1.0 
  24.  */  
  25. public class FileUtil {  
  26.   
  27.     /** 
  28.      * 功能描述：列出某文件夹及其子文件夹下面的文件，并可根据扩展名过滤 
  29.      *  
  30.      * @param path 
  31.      *            文件夹 
  32.      */  
  33.     public static void list(File path) {  
  34.         if (!path.exists()) {  
  35.             System.out.println("文件名称不存在!");  
  36.         } else {  
  37.             if (path.isFile()) {  
  38.                 if (path.getName().toLowerCase().endsWith(".pdf")  
  39.                         || path.getName().toLowerCase().endsWith(".doc")  
  40.                         || path.getName().toLowerCase().endsWith(".chm")  
  41.                         || path.getName().toLowerCase().endsWith(".html")  
  42.                         || path.getName().toLowerCase().endsWith(".htm")) {// 文件格式  
  43.                     System.out.println(path);  
  44.                     System.out.println(path.getName());  
  45.                 }  
  46.             } else {  
  47.                 File[] files = path.listFiles();  
  48.                 for (int i = 0; i < files.length; i++) {  
  49.                     list(files[i]);  
  50.                 }  
  51.             }  
  52.         }  
  53.     }  
  54.   
  55.     /** 
  56.      * 功能描述：拷贝一个目录或者文件到指定路径下，即把源文件拷贝到目标文件路径下 
  57.      *  
  58.      * @param source 
  59.      *            源文件 
  60.      * @param target 
  61.      *            目标文件路径 
  62.      * @return void 
  63.      */  
  64.     public static void copy(File source, File target) {  
  65.         File tarpath = new File(target, source.getName());  
  66.         if (source.isDirectory()) {  
  67.             tarpath.mkdir();  
  68.             File[] dir = source.listFiles();  
  69.             for (int i = 0; i < dir.length; i++) {  
  70.                 copy(dir[i], tarpath);  
  71.             }  
  72.         } else {  
  73.             try {  
  74.                 InputStream is = new FileInputStream(source); // 用于读取文件的原始字节流  
  75.                 OutputStream os = new FileOutputStream(tarpath); // 用于写入文件的原始字节的流  
  76.                 byte[] buf = new byte[1024];// 存储读取数据的缓冲区大小  
  77.                 int len = 0;  
  78.                 while ((len = is.read(buf)) != -1) {  
  79.                     os.write(buf, 0, len);  
  80.                 }  
  81.                 is.close();  
  82.                 os.close();  
  83.             } catch (FileNotFoundException e) {  
  84.                 e.printStackTrace();  
  85.             } catch (IOException e) {  
  86.                 e.printStackTrace();  
  87.             }  
  88.         }  
  89.     }  
  90.   
  91.     /** 
  92.      * @param args 
  93.      */  
  94.     public static void main(String[] args) {  
  95.         // TODO Auto-generated method stub  
  96.         File file = new File("F:\\Tomcat");  
  97.         list(file);  
  98.         Date myDate = new Date();   
  99.         DateFormat df = DateFormat.getDateInstance();  
  100.         System.out.println(df.format(myDate));   
  101.     }  
  102.   
  103. }  

 

 

 

Java代码  收藏代码
  1. package com.common.string;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.LinkedHashSet;  
  5. import java.util.Set;  
  6. import java.util.regex.Matcher;  
  7. import java.util.regex.Pattern;  
  8.   
  9. /** 
  10.  * 功能描述：关于字符串的一些实用操作 
  11.  *  
  12.  * @author Administrator 
  13.  * @Date Jul 18, 2008 
  14.  * @Time 2:19:47 PM 
  15.  * @version 1.0 
  16.  */  
  17. public class StringUtil {  
  18.   
  19.     /** 
  20.      * 功能描述：分割字符串 
  21.      *  
  22.      * @param str 
  23.      *            String 原始字符串 
  24.      * @param splitsign 
  25.      *            String 分隔符 
  26.      * @return String[] 分割后的字符串数组 
  27.      */  
  28.     @SuppressWarnings("unchecked")  
  29.     public static String[] split(String str, String splitsign) {  
  30.         int index;  
  31.         if (str == null || splitsign == null) {  
  32.             return null;  
  33.         }  
  34.         ArrayList al = new ArrayList();  
  35.         while ((index = str.indexOf(splitsign)) != -1) {  
  36.             al.add(str.substring(0, index));  
  37.             str = str.substring(index + splitsign.length());  
  38.         }  
  39.         al.add(str);  
  40.         return (String[]) al.toArray(new String[0]);  
  41.     }  
  42.   
  43.     /** 
  44.      * 功能描述：替换字符串 
  45.      *  
  46.      * @param from 
  47.      *            String 原始字符串 
  48.      * @param to 
  49.      *            String 目标字符串 
  50.      * @param source 
  51.      *            String 母字符串 
  52.      * @return String 替换后的字符串 
  53.      */  
  54.     public static String replace(String from, String to, String source) {  
  55.         if (source == null || from == null || to == null)  
  56.             return null;  
  57.         StringBuffer str = new StringBuffer("");  
  58.         int index = -1;  
  59.         while ((index = source.indexOf(from)) != -1) {  
  60.             str.append(source.substring(0, index) + to);  
  61.             source = source.substring(index + from.length());  
  62.             index = source.indexOf(from);  
  63.         }  
  64.         str.append(source);  
  65.         return str.toString();  
  66.     }  
  67.   
  68.     /** 
  69.      * 替换字符串，能能够在HTML页面上直接显示(替换双引号和小于号) 
  70.      *  
  71.      * @param str 
  72.      *            String 原始字符串 
  73.      * @return String 替换后的字符串 
  74.      */  
  75.     public static String htmlencode(String str) {  
  76.         if (str == null) {  
  77.             return null;  
  78.         }  
  79.         return replace("\"", "&quot;", replace("<", "&lt;", str));  
  80.     }  
  81.   
  82.     /** 
  83.      * 替换字符串，将被编码的转换成原始码（替换成双引号和小于号） 
  84.      *  
  85.      * @param str 
  86.      *            String 
  87.      * @return String 
  88.      */  
  89.     public static String htmldecode(String str) {  
  90.         if (str == null) {  
  91.             return null;  
  92.         }  
  93.   
  94.         return replace("&quot;", "\"", replace("&lt;", "<", str));  
  95.     }  
  96.   
  97.     private static final String _BR = "<br/>";  
  98.   
  99.     /** 
  100.      * 功能描述：在页面上直接显示文本内容，替换小于号，空格，回车，TAB 
  101.      *  
  102.      * @param str 
  103.      *            String 原始字符串 
  104.      * @return String 替换后的字符串 
  105.      */  
  106.     public static String htmlshow(String str) {  
  107.         if (str == null) {  
  108.             return null;  
  109.         }  
  110.   
  111.         str = replace("<", "&lt;", str);  
  112.         str = replace(" ", "&nbsp;", str);  
  113.         str = replace("\r\n", _BR, str);  
  114.         str = replace("\n", _BR, str);  
  115.         str = replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;", str);  
  116.         return str;  
  117.     }  
  118.   
  119.     /** 
  120.      * 功能描述：返回指定字节长度的字符串 
  121.      *  
  122.      * @param str 
  123.      *            String 字符串 
  124.      * @param length 
  125.      *            int 指定长度 
  126.      * @return String 返回的字符串 
  127.      */  
  128.     public static String toLength(String str, int length) {  
  129.         if (str == null) {  
  130.             return null;  
  131.         }  
  132.         if (length <= 0) {  
  133.             return "";  
  134.         }  
  135.         try {  
  136.             if (str.getBytes("GBK").length <= length) {  
  137.                 return str;  
  138.             }  
  139.         } catch (Exception e) {  
  140.         }  
  141.         StringBuffer buff = new StringBuffer();  
  142.   
  143.         int index = 0;  
  144.         char c;  
  145.         length -= 3;  
  146.         while (length > 0) {  
  147.             c = str.charAt(index);  
  148.             if (c < 128) {  
  149.                 length--;  
  150.             } else {  
  151.                 length--;  
  152.                 length--;  
  153.             }  
  154.             buff.append(c);  
  155.             index++;  
  156.         }  
  157.         buff.append("...");  
  158.         return buff.toString();  
  159.     }  
  160.   
  161.     /** 
  162.      * 功能描述：判断是否为整数 
  163.      *  
  164.      * @param str 
  165.      *            传入的字符串 
  166.      * @return 是整数返回true,否则返回false 
  167.      */  
  168.     public static boolean isInteger(String str) {  
  169.         Pattern pattern = Pattern.compile("^[-\\+]?[\\d]+$");  
  170.         return pattern.matcher(str).matches();  
  171.     }  
  172.   
  173.     /** 
  174.      * 判断是否为浮点数，包括double和float 
  175.      *  
  176.      * @param str 
  177.      *            传入的字符串 
  178.      * @return 是浮点数返回true,否则返回false 
  179.      */  
  180.     public static boolean isDouble(String str) {  
  181.         Pattern pattern = Pattern.compile("^[-\\+]?\\d+\\.\\d+$");  
  182.         return pattern.matcher(str).matches();  
  183.     }  
  184.   
  185.     /** 
  186.      * 判断是不是合法字符 c 要判断的字符 
  187.      */  
  188.     public static boolean isLetter(String str) {  
  189.         if (str == null || str.length() < 0) {  
  190.             return false;  
  191.         }  
  192.         Pattern pattern = Pattern.compile("[\\w\\.-_]*");  
  193.         return pattern.matcher(str).matches();  
  194.     }  
  195.   
  196.     /** 
  197.      * 从指定的字符串中提取Email content 指定的字符串 
  198.      *  
  199.      * @param content 
  200.      * @return 
  201.      */  
  202.     public static String parse(String content) {  
  203.         String email = null;  
  204.         if (content == null || content.length() < 1) {  
  205.             return email;  
  206.         }  
  207.         // 找出含有@  
  208.         int beginPos;  
  209.         int i;  
  210.         String token = "@";  
  211.         String preHalf = "";  
  212.         String sufHalf = "";  
  213.   
  214.         beginPos = content.indexOf(token);  
  215.         if (beginPos > -1) {  
  216.             // 前项扫描  
  217.             String s = null;  
  218.             i = beginPos;  
  219.             while (i > 0) {  
  220.                 s = content.substring(i - 1, i);  
  221.                 if (isLetter(s))  
  222.                     preHalf = s + preHalf;  
  223.                 else  
  224.                     break;  
  225.                 i--;  
  226.             }  
  227.             // 后项扫描  
  228.             i = beginPos + 1;  
  229.             while (i < content.length()) {  
  230.                 s = content.substring(i, i + 1);  
  231.                 if (isLetter(s))  
  232.                     sufHalf = sufHalf + s;  
  233.                 else  
  234.                     break;  
  235.                 i++;  
  236.             }  
  237.             // 判断合法性  
  238.             email = preHalf + "@" + sufHalf;  
  239.             if (isEmail(email)) {  
  240.                 return email;  
  241.             }  
  242.         }  
  243.         return null;  
  244.     }  
  245.   
  246.     /** 
  247.      * 功能描述：判断输入的字符串是否符合Email样式. 
  248.      *  
  249.      * @param str 
  250.      *            传入的字符串 
  251.      * @return 是Email样式返回true,否则返回false 
  252.      */  
  253.     public static boolean isEmail(String email) {  
  254.         if (email == null || email.length() < 1 || email.length() > 256) {  
  255.             return false;  
  256.         }  
  257.         Pattern pattern = Pattern  
  258.                 .compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");  
  259.         return pattern.matcher(email).matches();  
  260.     }  
  261.   
  262.     /** 
  263.      * 功能描述：判断输入的字符串是否为纯汉字 
  264.      *  
  265.      * @param str 
  266.      *            传入的字符窜 
  267.      * @return 如果是纯汉字返回true,否则返回false 
  268.      */  
  269.     public static boolean isChinese(String str) {  
  270.         Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");  
  271.         return pattern.matcher(str).matches();  
  272.     }  
  273.   
  274.     /** 
  275.      * 功能描述：是否为空白,包括null和"" 
  276.      *  
  277.      * @param str 
  278.      * @return 
  279.      */  
  280.     public static boolean isBlank(String str) {  
  281.         return str == null || str.trim().length() == 0;  
  282.     }  
  283.   
  284.     /** 
  285.      * 功能描述：判断是否为质数 
  286.      *  
  287.      * @param x 
  288.      * @return 
  289.      */  
  290.     public static boolean isPrime(int x) {  
  291.         if (x <= 7) {  
  292.             if (x == 2 || x == 3 || x == 5 || x == 7)  
  293.                 return true;  
  294.         }  
  295.         int c = 7;  
  296.         if (x % 2 == 0)  
  297.             return false;  
  298.         if (x % 3 == 0)  
  299.             return false;  
  300.         if (x % 5 == 0)  
  301.             return false;  
  302.         int end = (int) Math.sqrt(x);  
  303.         while (c <= end) {  
  304.             if (x % c == 0) {  
  305.                 return false;  
  306.             }  
  307.             c += 4;  
  308.             if (x % c == 0) {  
  309.                 return false;  
  310.             }  
  311.             c += 2;  
  312.             if (x % c == 0) {  
  313.                 return false;  
  314.             }  
  315.             c += 4;  
  316.             if (x % c == 0) {  
  317.                 return false;  
  318.             }  
  319.             c += 2;  
  320.             if (x % c == 0) {  
  321.                 return false;  
  322.             }  
  323.             c += 4;  
  324.             if (x % c == 0) {  
  325.                 return false;  
  326.             }  
  327.             c += 6;  
  328.             if (x % c == 0) {  
  329.                 return false;  
  330.             }  
  331.             c += 2;  
  332.             if (x % c == 0) {  
  333.                 return false;  
  334.             }  
  335.             c += 6;  
  336.         }  
  337.         return true;  
  338.     }  
  339.   
  340.     /** 
  341.      * 功能描述：人民币转成大写 
  342.      *  
  343.      * @param str 
  344.      *            数字字符串 
  345.      * @return String 人民币转换成大写后的字符串 
  346.      */  
  347.     public static String hangeToBig(String str) {  
  348.         double value;  
  349.         try {  
  350.             value = Double.parseDouble(str.trim());  
  351.         } catch (Exception e) {  
  352.             return null;  
  353.         }  
  354.         char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示  
  355.         char[] vunit = { '万', '亿' }; // 段名表示  
  356.         char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示  
  357.         long midVal = (long) (value * 100); // 转化成整形  
  358.         String valStr = String.valueOf(midVal); // 转化成字符串  
  359.   
  360.         String head = valStr.substring(0, valStr.length() - 2); // 取整数部分  
  361.         String rail = valStr.substring(valStr.length() - 2); // 取小数部分  
  362.   
  363.         String prefix = ""; // 整数部分转化的结果  
  364.         String suffix = ""; // 小数部分转化的结果  
  365.         // 处理小数点后面的数  
  366.         if (rail.equals("00")) { // 如果小数部分为0  
  367.             suffix = "整";  
  368.         } else {  
  369.             suffix = digit[rail.charAt(0) - '0'] + "角"  
  370.                     + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来  
  371.         }  
  372.         // 处理小数点前面的数  
  373.         char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组  
  374.         char zero = '0'; // 标志'0'表示出现过0  
  375.         byte zeroSerNum = 0; // 连续出现0的次数  
  376.         for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字  
  377.             int idx = (chDig.length - i - 1) % 4; // 取段内位置  
  378.             int vidx = (chDig.length - i - 1) / 4; // 取段位置  
  379.             if (chDig[i] == '0') { // 如果当前字符是0  
  380.                 zeroSerNum++; // 连续0次数递增  
  381.                 if (zero == '0') { // 标志  
  382.                     zero = digit[0];  
  383.                 } else if (idx == 0 && vidx > 0 && zeroSerNum < 4) {  
  384.                     prefix += vunit[vidx - 1];  
  385.                     zero = '0';  
  386.                 }  
  387.                 continue;  
  388.             }  
  389.             zeroSerNum = 0; // 连续0次数清零  
  390.             if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的  
  391.                 prefix += zero;  
  392.                 zero = '0';  
  393.             }  
  394.             prefix += digit[chDig[i] - '0']; // 转化该数字表示  
  395.             if (idx > 0)  
  396.                 prefix += hunit[idx - 1];  
  397.             if (idx == 0 && vidx > 0) {  
  398.                 prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿  
  399.             }  
  400.         }  
  401.   
  402.         if (prefix.length() > 0)  
  403.             prefix += '圆'; // 如果整数部分存在,则有圆的字样  
  404.         return prefix + suffix; // 返回正确表示  
  405.     }  
  406.   
  407.     /** 
  408.      * 功能描述：去掉字符串中重复的子字符串 
  409.      *  
  410.      * @param str 
  411.      *            原字符串，如果有子字符串则用空格隔开以表示子字符串 
  412.      * @return String 返回去掉重复子字符串后的字符串 
  413.      */  
  414.     @SuppressWarnings("unused")  
  415.     private static String removeSameString(String str) {  
  416.         Set<String> mLinkedSet = new LinkedHashSet<String>();// set集合的特征：其子集不可以重复  
  417.         String[] strArray = str.split(" ");// 根据空格(正则表达式)分割字符串  
  418.         StringBuffer sb = new StringBuffer();  
  419.   
  420.         for (int i = 0; i < strArray.length; i++) {  
  421.             if (!mLinkedSet.contains(strArray[i])) {  
  422.                 mLinkedSet.add(strArray[i]);  
  423.                 sb.append(strArray[i] + " ");  
  424.             }  
  425.         }  
  426.         System.out.println(mLinkedSet);  
  427.         return sb.toString();  
  428.     }  
  429.   
  430.     /** 
  431.      * 功能描述：过滤特殊字符 
  432.      *  
  433.      * @param src 
  434.      * @return 
  435.      */  
  436.     public static String encoding(String src) {  
  437.         if (src == null)  
  438.             return "";  
  439.         StringBuilder result = new StringBuilder();  
  440.         if (src != null) {  
  441.             src = src.trim();  
  442.             for (int pos = 0; pos < src.length(); pos++) {  
  443.                 switch (src.charAt(pos)) {  
  444.                 case '\"':  
  445.                     result.append("&quot;");  
  446.                     break;  
  447.                 case '<':  
  448.                     result.append("&lt;");  
  449.                     break;  
  450.                 case '>':  
  451.                     result.append("&gt;");  
  452.                     break;  
  453.                 case '\'':  
  454.                     result.append("&apos;");  
  455.                     break;  
  456.                 case '&':  
  457.                     result.append("&amp;");  
  458.                     break;  
  459.                 case '%':  
  460.                     result.append("&pc;");  
  461.                     break;  
  462.                 case '_':  
  463.                     result.append("&ul;");  
  464.                     break;  
  465.                 case '#':  
  466.                     result.append("&shap;");  
  467.                     break;  
  468.                 case '?':  
  469.                     result.append("&ques;");  
  470.                     break;  
  471.                 default:  
  472.                     result.append(src.charAt(pos));  
  473.                     break;  
  474.                 }  
  475.             }  
  476.         }  
  477.         return result.toString();  
  478.     }  
  479.   
  480.     /** 
  481.      * 功能描述：判断是不是合法的手机号码 
  482.      *  
  483.      * @param handset 
  484.      * @return boolean 
  485.      */  
  486.     public static boolean isHandset(String handset) {  
  487.         try {  
  488.             String regex = "^1[\\d]{10}$";  
  489.             Pattern pattern = Pattern.compile(regex);  
  490.             Matcher matcher = pattern.matcher(handset);  
  491.             return matcher.matches();  
  492.   
  493.         } catch (RuntimeException e) {  
  494.             return false;  
  495.         }  
  496.     }  
  497.   
  498.     /** 
  499.      * 功能描述：反过滤特殊字符 
  500.      *  
  501.      * @param src 
  502.      * @return 
  503.      */  
  504.     public static String decoding(String src) {  
  505.         if (src == null)  
  506.             return "";  
  507.         String result = src;  
  508.         result = result.replace("&quot;", "\"").replace("&apos;", "\'");  
  509.         result = result.replace("&lt;", "<").replace("&gt;", ">");  
  510.         result = result.replace("&amp;", "&");  
  511.         result = result.replace("&pc;", "%").replace("&ul", "_");  
  512.         result = result.replace("&shap;", "#").replace("&ques", "?");  
  513.         return result;  
  514.     }  
  515.   
  516.     /** 
  517.      * @param args 
  518.      */  
  519.     public static void main(String[] args) {  
  520.          String source = "abcdefgabcdefgabcdefgabcdefgabcdefgabcdefg";  
  521.          String from = "efg";  
  522.          String to = "房贺威";  
  523.          System.out.println("在字符串source中，用to替换from，替换结果为："  
  524.          + replace(from, to, source));  
  525.          System.out.println("返回指定字节长度的字符串："  
  526.          + toLength("abcdefgabcdefgabcdefgabcdefgabcdefgabcdefg", 9));  
  527.          System.out.println("判断是否为整数：" + isInteger("+0"));  
  528.          System.out.println("判断是否为浮点数，包括double和float：" + isDouble("+0.36"));  
  529.          System.out.println("判断输入的字符串是否符合Email样式：" +  
  530.          isEmail("fhwbj@163.com"));  
  531.          System.out.println("判断输入的字符串是否为纯汉字：" + isChinese("你好！"));  
  532.          System.out.println("判断输入的数据是否是质数：" + isPrime(12));  
  533.          System.out.println("人民币转换成大写：" + hangeToBig("10019658"));  
  534.          System.out.println("去掉字符串中重复的子字符串：" + removeSameString("100 100 9658"));  
  535.          System.out.println("过滤特殊字符：" + encoding("100\"s<>fdsd100 9658"));  
  536.          System.out.println("判断是不是合法的手机号码：" + isHandset("15981807340"));  
  537.          System.out.println("从字符串中取值Email：" + parse("159818 fwhbj@163.com07340"));  
  538.     }  
  539. }  

 

 

 

Java代码  收藏代码
  1. package com.common.time;  
  2.   
  3. import java.text.DateFormat;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.Calendar;  
  6. import java.util.Date;  
  7.   
  8. /** 
  9.  *  
  10.  * 功能描述： 
  11.  *  
  12.  * @author Administrator 
  13.  * @Date Jul 19, 2008 
  14.  * @Time 9:47:53 AM 
  15.  * @version 1.0 
  16.  */  
  17. public class DateUtil {  
  18.   
  19.     public static Date date = null;  
  20.   
  21.     public static DateFormat dateFormat = null;  
  22.   
  23.     public static Calendar calendar = null;  
  24.   
  25.     /** 
  26.      * 功能描述：格式化日期 
  27.      *  
  28.      * @param dateStr 
  29.      *            String 字符型日期 
  30.      * @param format 
  31.      *            String 格式 
  32.      * @return Date 日期 
  33.      */  
  34.     public static Date parseDate(String dateStr, String format) {  
  35.         try {  
  36.             dateFormat = new SimpleDateFormat(format);  
  37.             String dt = dateStr.replaceAll("-", "/");  
  38.             if ((!dt.equals("")) && (dt.length() < format.length())) {  
  39.                 dt += format.substring(dt.length()).replaceAll("[YyMmDdHhSs]",  
  40.                         "0");  
  41.             }  
  42.             date = (Date) dateFormat.parse(dt);  
  43.         } catch (Exception e) {  
  44.         }  
  45.         return date;  
  46.     }  
  47.   
  48.     /** 
  49.      * 功能描述：格式化日期 
  50.      *  
  51.      * @param dateStr 
  52.      *            String 字符型日期：YYYY-MM-DD 格式 
  53.      * @return Date 
  54.      */  
  55.     public static Date parseDate(String dateStr) {  
  56.         return parseDate(dateStr, "yyyy/MM/dd");  
  57.     }  
  58.   
  59.     /** 
  60.      * 功能描述：格式化输出日期 
  61.      *  
  62.      * @param date 
  63.      *            Date 日期 
  64.      * @param format 
  65.      *            String 格式 
  66.      * @return 返回字符型日期 
  67.      */  
  68.     public static String format(Date date, String format) {  
  69.         String result = "";  
  70.         try {  
  71.             if (date != null) {  
  72.                 dateFormat = new SimpleDateFormat(format);  
  73.                 result = dateFormat.format(date);  
  74.             }  
  75.         } catch (Exception e) {  
  76.         }  
  77.         return result;  
  78.     }  
  79.   
  80.     /** 
  81.      * 功能描述： 
  82.      *  
  83.      * @param date 
  84.      *            Date 日期 
  85.      * @return 
  86.      */  
  87.     public static String format(Date date) {  
  88.         return format(date, "yyyy/MM/dd");  
  89.     }  
  90.   
  91.     /** 
  92.      * 功能描述：返回年份 
  93.      *  
  94.      * @param date 
  95.      *            Date 日期 
  96.      * @return 返回年份 
  97.      */  
  98.     public static int getYear(Date date) {  
  99.         calendar = Calendar.getInstance();  
  100.         calendar.setTime(date);  
  101.         return calendar.get(Calendar.YEAR);  
  102.     }  
  103.   
  104.     /** 
  105.      * 功能描述：返回月份 
  106.      *  
  107.      * @param date 
  108.      *            Date 日期 
  109.      * @return 返回月份 
  110.      */  
  111.     public static int getMonth(Date date) {  
  112.         calendar = Calendar.getInstance();  
  113.         calendar.setTime(date);  
  114.         return calendar.get(Calendar.MONTH) + 1;  
  115.     }  
  116.   
  117.     /** 
  118.      * 功能描述：返回日份 
  119.      *  
  120.      * @param date 
  121.      *            Date 日期 
  122.      * @return 返回日份 
  123.      */  
  124.     public static int getDay(Date date) {  
  125.         calendar = Calendar.getInstance();  
  126.         calendar.setTime(date);  
  127.         return calendar.get(Calendar.DAY_OF_MONTH);  
  128.     }  
  129.   
  130.     /** 
  131.      * 功能描述：返回小时 
  132.      *  
  133.      * @param date 
  134.      *            日期 
  135.      * @return 返回小时 
  136.      */  
  137.     public static int getHour(Date date) {  
  138.         calendar = Calendar.getInstance();  
  139.         calendar.setTime(date);  
  140.         return calendar.get(Calendar.HOUR_OF_DAY);  
  141.     }  
  142.   
  143.     /** 
  144.      * 功能描述：返回分钟 
  145.      *  
  146.      * @param date 
  147.      *            日期 
  148.      * @return 返回分钟 
  149.      */  
  150.     public static int getMinute(Date date) {  
  151.         calendar = Calendar.getInstance();  
  152.         calendar.setTime(date);  
  153.         return calendar.get(Calendar.MINUTE);  
  154.     }  
  155.   
  156.     /** 
  157.      * 返回秒钟 
  158.      *  
  159.      * @param date 
  160.      *            Date 日期 
  161.      * @return 返回秒钟 
  162.      */  
  163.     public static int getSecond(Date date) {  
  164.         calendar = Calendar.getInstance();  
  165.         calendar.setTime(date);  
  166.         return calendar.get(Calendar.SECOND);  
  167.     }  
  168.   
  169.     /** 
  170.      * 功能描述：返回毫秒 
  171.      *  
  172.      * @param date 
  173.      *            日期 
  174.      * @return 返回毫秒 
  175.      */  
  176.     public static long getMillis(Date date) {  
  177.         calendar = Calendar.getInstance();  
  178.         calendar.setTime(date);  
  179.         return calendar.getTimeInMillis();  
  180.     }  
  181.   
  182.     /** 
  183.      * 功能描述：返回字符型日期 
  184.      *  
  185.      * @param date 
  186.      *            日期 
  187.      * @return 返回字符型日期 yyyy/MM/dd 格式 
  188.      */  
  189.     public static String getDate(Date date) {  
  190.         return format(date, "yyyy/MM/dd");  
  191.     }  
  192.   
  193.     /** 
  194.      * 功能描述：返回字符型时间 
  195.      *  
  196.      * @param date 
  197.      *            Date 日期 
  198.      * @return 返回字符型时间 HH:mm:ss 格式 
  199.      */  
  200.     public static String getTime(Date date) {  
  201.         return format(date, "HH:mm:ss");  
  202.     }  
  203.   
  204.     /** 
  205.      * 功能描述：返回字符型日期时间 
  206.      *  
  207.      * @param date 
  208.      *            Date 日期 
  209.      * @return 返回字符型日期时间 yyyy/MM/dd HH:mm:ss 格式 
  210.      */  
  211.     public static String getDateTime(Date date) {  
  212.         return format(date, "yyyy/MM/dd HH:mm:ss");  
  213.     }  
  214.   
  215.     /** 
  216.      * 功能描述：日期相加 
  217.      *  
  218.      * @param date 
  219.      *            Date 日期 
  220.      * @param day 
  221.      *            int 天数 
  222.      * @return 返回相加后的日期 
  223.      */  
  224.     public static Date addDate(Date date, int day) {  
  225.         calendar = Calendar.getInstance();  
  226.         long millis = getMillis(date) + ((long) day) * 24 * 3600 * 1000;  
  227.         calendar.setTimeInMillis(millis);  
  228.         return calendar.getTime();  
  229.     }  
  230.   
  231.     /** 
  232.      * 功能描述：日期相减 
  233.      *  
  234.      * @param date 
  235.      *            Date 日期 
  236.      * @param date1 
  237.      *            Date 日期 
  238.      * @return 返回相减后的日期 
  239.      */  
  240.     public static int diffDate(Date date, Date date1) {  
  241.         return (int) ((getMillis(date) - getMillis(date1)) / (24 * 3600 * 1000));  
  242.     }  
  243.   
  244.     /** 
  245.      * 功能描述：取得指定月份的第一天 
  246.      *  
  247.      * @param strdate 
  248.      *            String 字符型日期 
  249.      * @return String yyyy-MM-dd 格式 
  250.      */  
  251.     public static String getMonthBegin(String strdate) {  
  252.         date = parseDate(strdate);  
  253.         return format(date, "yyyy-MM") + "-01";  
  254.     }  
  255.   
  256.     /** 
  257.      * 功能描述：取得指定月份的最后一天 
  258.      *  
  259.      * @param strdate 
  260.      *            String 字符型日期 
  261.      * @return String 日期字符串 yyyy-MM-dd格式 
  262.      */  
  263.     public static String getMonthEnd(String strdate) {  
  264.         date = parseDate(getMonthBegin(strdate));  
  265.         calendar = Calendar.getInstance();  
  266.         calendar.setTime(date);  
  267.         calendar.add(Calendar.MONTH, 1);  
  268.         calendar.add(Calendar.DAY_OF_YEAR, -1);  
  269.         return formatDate(calendar.getTime());  
  270.     }  
  271.   
  272.     /** 
  273.      * 功能描述：常用的格式化日期 
  274.      *  
  275.      * @param date 
  276.      *            Date 日期 
  277.      * @return String 日期字符串 yyyy-MM-dd格式 
  278.      */  
  279.     public static String formatDate(Date date) {  
  280.         return formatDateByFormat(date, "yyyy-MM-dd");  
  281.     }  
  282.   
  283.     /** 
  284.      * 功能描述：以指定的格式来格式化日期 
  285.      *  
  286.      * @param date 
  287.      *            Date 日期 
  288.      * @param format 
  289.      *            String 格式 
  290.      * @return String 日期字符串 
  291.      */  
  292.     public static String formatDateByFormat(Date date, String format) {  
  293.         String result = "";  
  294.         if (date != null) {  
  295.             try {  
  296.                 SimpleDateFormat sdf = new SimpleDateFormat(format);  
  297.                 result = sdf.format(date);  
  298.             } catch (Exception ex) {  
  299.                 ex.printStackTrace();  
  300.             }  
  301.         }  
  302.         return result;  
  303.     }  
  304.   
  305.     public static void main(String[] args) {  
  306.         Date d = new Date();  
  307.         System.out.println(d.toString());  
  308.         System.out.println(formatDate(d).toString());  
  309.         System.out.println(getMonthBegin(formatDate(d).toString()));  
  310.         System.out.println(getMonthBegin("2008/07/19"));  
  311.         System.out.println(getMonthEnd("2008/07/19"));  
  312.         System.out.println(addDate(d,15).toString());  
  313.     }  
  314.   
  315. }  

 

 

 

Java代码  收藏代码
  1. /*[java]一个压缩工具类 zip2008年05月28日 星期三 17:48/* 
  2. * Zip.java 
  3. * 
  4. * Created on 2008年4月2日, 下午2:20 
  5. * 
  6. * To change this template, choose Tools | Template Manager 
  7. * and open the template in the editor. 
  8. */  
  9.   
  10. package com.founder.mnp.utl;  
  11.   
  12. /** 
  13. * 
  14. * @author GuoJiale 
  15. */  
  16. import java.io.BufferedInputStream;  
  17. import java.io.BufferedOutputStream;  
  18. import java.io.File;  
  19. import java.io.FileInputStream;  
  20. import java.io.FileOutputStream;  
  21. import java.util.zip.ZipEntry;  
  22. import java.util.zip.ZipOutputStream;  
  23.   
  24.   
  25. public class ZipUtils {  
  26.     static final int BUFFER = 2048;  
  27.       
  28.     public static boolean zip( String[] filename ,String outname){  
  29.           
  30.         boolean test = true;  
  31.         try {  
  32.             BufferedInputStream origin = null;  
  33.             FileOutputStream dest = new FileOutputStream(outname);  
  34.             ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(  
  35.                     dest));  
  36.             byte data[] = new byte[BUFFER];  
  37.             // File f= new File("d:\\111\\");  
  38.             //   File files[] = f.listFiles();  
  39.               
  40.             for (int i = 0; i < filename.length; i++) {  
  41.                 File file = new File(filename[i]);  
  42.                 FileInputStream fi = new FileInputStream(file);  
  43.                 origin = new BufferedInputStream(fi, BUFFER);  
  44.                 ZipEntry entry = new ZipEntry(file.getName());  
  45.                 out.putNextEntry(entry);  
  46.                 int count;  
  47.                 while ((count = origin.read(data, 0, BUFFER)) != -1) {  
  48.                     out.write(data, 0, count);  
  49.                 }  
  50.                 origin.close();  
  51.             }  
  52.             out.close();  
  53.         } catch (Exception e) {  
  54.             test = false;  
  55.             e.printStackTrace();  
  56.         }  
  57.         return test;  
  58.     }  
  59.       
  60.       
  61.       
  62.     public static void main(String argv[]) {  
  63.         // File f= new File("d:\\111\\");  
  64.         String[] filenames = new String[]{"F:\\12.jpg"};  
  65.         zip(filenames,"F:/12.zip");  
  66.     }  
  67. }  
  68.    

 

 

 

Java代码  收藏代码
  1. package com.test.test;  
  2.   
  3. /************************************************ 
  4. MD5 算法的Java Bean 
  5. Last Modified:10,Mar,2001 
  6.  *************************************************/  
  7. import java.io.File;  
  8. import java.io.FileInputStream;  
  9. import java.io.FileNotFoundException;  
  10. import java.io.IOException;  
  11. import java.math.BigInteger;  
  12. import java.security.MessageDigest;  
  13. import java.util.HashMap;  
  14. import java.util.Map;  
  15. import java.util.zip.CRC32;  
  16. import java.util.zip.CheckedInputStream;  
  17.   
  18. /************************************************* 
  19.  * md5 类实现了RSA Data Security, Inc.在提交给IETF 的RFC1321中的MD5 message-digest 算法。 
  20.  *************************************************/  
  21. public class MD5 {  
  22.     /* 
  23.      * 下面这些S11-S44实际上是一个44的矩阵，在原始的C实现中是用#define 实现的， 这里把它们实现成为static 
  24.      * final是表示了只读，切能在同一个进程空间内的多个 Instance间共享 
  25.      */  
  26.     private static final int S11 = 7;  
  27.     private static final int S12 = 12;  
  28.     private static final int S13 = 17;  
  29.     private static final int S14 = 22;  
  30.     private static final int S21 = 5;  
  31.     private static final int S22 = 9;  
  32.     private static final int S23 = 14;  
  33.     private static final int S24 = 20;  
  34.     private static final int S31 = 4;  
  35.     private static final int S32 = 11;  
  36.     private static final int S33 = 16;  
  37.     private static final int S34 = 23;  
  38.     private static final int S41 = 6;  
  39.     private static final int S42 = 10;  
  40.     private static final int S43 = 15;  
  41.     private static final int S44 = 21;  
  42.     private static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
  43.             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
  44.             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
  45.             0, 0, 0, 0, 0, 0, 0 };  
  46.     /* 
  47.      * 下面的三个成员是MD5计算过程中用到的3个核心数据，在原始的C实现中 被定义到MD5_CTX结构中 
  48.      */  
  49.     private long[] state = new long[4]; // state (ABCD)  
  50.     private long[] count = new long[2]; // number of bits, modulo 2^64 (lsb  
  51.                                         // first)  
  52.     private byte[] buffer = new byte[64]; // input buffer  
  53.     /* 
  54.      * digestHexStr是MD5的唯一一个公共成员，是最新一次计算结果的 16进制ASCII表示. 
  55.      */  
  56.     private String digestHexStr;  
  57.     /* 
  58.      * digest,是最新一次计算结果的2进制内部表示，表示128bit的MD5值. 
  59.      */  
  60.     private byte[] digest = new byte[16];  
  61.   
  62.     /** 
  63.      * getMD5ofStr是类MD5最主要的公共方法，入口参数是你想要进行MD5变换的字符串 
  64.      * 返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的． 
  65.      */  
  66.     public String getMD5ofStr(String inbuf) {  
  67.         md5Init();  
  68.         md5Update(inbuf.getBytes(), inbuf.length());  
  69.         md5Final();  
  70.         digestHexStr = "";  
  71.         for (int i = 0; i < 16; i++) {  
  72.             digestHexStr += byteHEX(digest[i]);  
  73.         }  
  74.         return digestHexStr;  
  75.     }  
  76.   
  77.     // 这是MD5这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数  
  78.     public MD5() {  
  79.         md5Init();  
  80.         return;  
  81.     }  
  82.   
  83.     /* md5Init是一个初始化函数，初始化核心变量，装入标准的幻数 */  
  84.     private void md5Init() {  
  85.         count[0] = 0L;  
  86.         count[1] = 0L;  
  87.         // /* Load magic initialization constants.  
  88.         state[0] = 0x67452301L;  
  89.         state[1] = 0xefcdab89L;  
  90.         state[2] = 0x98badcfeL;  
  91.         state[3] = 0x10325476L;  
  92.         return;  
  93.     }  
  94.   
  95.     /*  
  96.      * F, G, H ,I 是4个基本的MD5函数，在原始的MD5的C实现中，由于它们是  
  97.      * 简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们 实现成了private方法，名字保持了原来C中的。  
  98.      */  
  99.     private long F(long x, long y, long z) {  
  100.         return (x & y) | ((~x) & z);  
  101.     }  
  102.   
  103.     private long G(long x, long y, long z) {  
  104.         return (x & z) | (y & (~z));  
  105.     }  
  106.   
  107.     private long H(long x, long y, long z) {  
  108.         return x ^ y ^ z;  
  109.     }  
  110.   
  111.     private long I(long x, long y, long z) {  
  112.         return y ^ (x | (~z));  
  113.     }  
  114.   
  115.     /* 
  116.      * Rotation is separate from addition to prevent recomputation. 
  117.      */  
  118.     private long FF(long a, long b, long c, long d, long x, long s, long ac) {  
  119.         a += F(b, c, d) + x + ac;  
  120.         a = ((int) a << s) | ((int) a >>> (32 - s));  
  121.         a += b;  
  122.         return a;  
  123.     }  
  124.   
  125.     private long GG(long a, long b, long c, long d, long x, long s, long ac) {  
  126.         a += G(b, c, d) + x + ac;  
  127.         a = ((int) a << s) | ((int) a >>> (32 - s));  
  128.         a += b;  
  129.         return a;  
  130.     }  
  131.   
  132.     private long HH(long a, long b, long c, long d, long x, long s, long ac) {  
  133.         a += H(b, c, d) + x + ac;  
  134.         a = ((int) a << s) | ((int) a >>> (32 - s));  
  135.         a += b;  
  136.         return a;  
  137.     }  
  138.   
  139.     private long II(long a, long b, long c, long d, long x, long s, long ac) {  
  140.         a += I(b, c, d) + x + ac;  
  141.         a = ((int) a << s) | ((int) a >>> (32 - s));  
  142.         a += b;  
  143.         return a;  
  144.     }  
  145.   
  146.     /* 
  147.      * md5Update是MD5的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个 
  148.      * 函数由getMD5ofStr调用，调用之前需要调用md5init，因此把它设计成private的 
  149.      */  
  150.     private void md5Update(byte[] inbuf, int inputLen) {  
  151.         int i, index, partLen;  
  152.         byte[] block = new byte[64];  
  153.         index = (int) (count[0] >>> 3) & 0x3F;  
  154.         // /* Update number of bits */  
  155.         if ((count[0] += (inputLen << 3)) < (inputLen << 3))  
  156.             count[1]++;  
  157.         count[1] += (inputLen >>> 29);  
  158.         partLen = 64 - index;  
  159.         // Transform as many times as possible.  
  160.         if (inputLen >= partLen) {  
  161.             md5Memcpy(buffer, inbuf, index, 0, partLen);  
  162.             md5Transform(buffer);  
  163.             for (i = partLen; i + 63 < inputLen; i += 64) {  
  164.                 md5Memcpy(block, inbuf, 0, i, 64);  
  165.                 md5Transform(block);  
  166.             }  
  167.             index = 0;  
  168.         } else  
  169.             i = 0;  
  170.         // /* Buffer remaining input */  
  171.         md5Memcpy(buffer, inbuf, index, i, inputLen - i);  
  172.     }  
  173.   
  174.     /* 
  175.      * md5Final整理和填写输出结果 
  176.      */  
  177.     private void md5Final() {  
  178.         byte[] bits = new byte[8];  
  179.         int index, padLen;  
  180.         // /* Save number of bits */  
  181.         Encode(bits, count, 8);  
  182.         // /* Pad out to 56 mod 64.  
  183.         index = (int) (count[0] >>> 3) & 0x3f;  
  184.         padLen = (index < 56) ? (56 - index) : (120 - index);  
  185.         md5Update(PADDING, padLen);  
  186.         // /* Append length (before padding) */  
  187.         md5Update(bits, 8);  
  188.         // /* Store state in digest */  
  189.         Encode(digest, state, 16);  
  190.     }  
  191.   
  192.     /* 
  193.      * md5Memcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把len长度的 
  194.      * 字节拷贝到output的outpos位置开始 
  195.      */  
  196.     private void md5Memcpy(byte[] output, byte[] input, int outpos, int inpos,  
  197.             int len) {  
  198.         int i;  
  199.         for (i = 0; i < len; i++)  
  200.             output[outpos + i] = input[inpos + i];  
  201.     }  
  202.   
  203.     /* 
  204.      * md5Transform是MD5核心变换程序，有md5Update调用，block是分块的原始字节 
  205.      */  
  206.     private void md5Transform(byte block[]) {  
  207.         long a = state[0], b = state[1], c = state[2], d = state[3];  
  208.         long[] x = new long[16];  
  209.         Decode(x, block, 64);  
  210.   
  211.         /* Round 1 */  
  212.         a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */  
  213.         d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */  
  214.         c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */  
  215.         b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */  
  216.         a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */  
  217.         d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */  
  218.         c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */  
  219.         b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */  
  220.         a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */  
  221.         d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */  
  222.         c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */  
  223.         b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */  
  224.         a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */  
  225.         d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */  
  226.         c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */  
  227.         b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */  
  228.         /* Round 2 */  
  229.         a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */  
  230.         d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */  
  231.         c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */  
  232.         b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */  
  233.         a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */  
  234.         d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */  
  235.         c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */  
  236.         b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */  
  237.         a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */  
  238.         d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */  
  239.         c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */  
  240.         b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */  
  241.         a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */  
  242.         d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */  
  243.         c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */  
  244.         b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */  
  245.         /* Round 3 */  
  246.         a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */  
  247.         d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */  
  248.         c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */  
  249.         b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */  
  250.         a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */  
  251.         d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */  
  252.         c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */  
  253.         b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */  
  254.         a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */  
  255.         d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */  
  256.         c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */  
  257.         b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */  
  258.         a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */  
  259.         d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */  
  260.         c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */  
  261.         b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */  
  262.         /* Round 4 */  
  263.         a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */  
  264.         d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */  
  265.         c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */  
  266.         b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */  
  267.         a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */  
  268.         d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */  
  269.         c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */  
  270.         b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */  
  271.         a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */  
  272.         d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */  
  273.         c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */  
  274.         b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */  
  275.         a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */  
  276.         d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */  
  277.         c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */  
  278.         b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */  
  279.         state[0] += a;  
  280.         state[1] += b;  
  281.         state[2] += c;  
  282.         state[3] += d;  
  283.     }  
  284.   
  285.     /* 
  286.      * Encode把long数组按顺序拆成byte数组，因为java的long类型是64bit的， 只拆低32bit，以适应原始C实现的用途 
  287.      */  
  288.     private void Encode(byte[] output, long[] input, int len) {  
  289.         int i, j;  
  290.         for (i = 0, j = 0; j < len; i++, j += 4) {  
  291.             output[j] = (byte) (input[i] & 0xffL);  
  292.             output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);  
  293.             output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);  
  294.             output[j + 3] = (byte) ((input[i] >>> 24) & 0xffL);  
  295.         }  
  296.     }  
  297.   
  298.     /* 
  299.      * Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的， 
  300.      * 只合成低32bit，高32bit清零，以适应原始C实现的用途 
  301.      */  
  302.     private void Decode(long[] output, byte[] input, int len) {  
  303.         int i, j;  
  304.         for (i = 0, j = 0; j < len; i++, j += 4)  
  305.             output[i] = b2iu(input[j]) | (b2iu(input[j + 1]) << 8)  
  306.                     | (b2iu(input[j + 2]) << 16) | (b2iu(input[j + 3]) << 24);  
  307.         return;  
  308.     }  
  309.   
  310.     /** 
  311.      * b2iu是我写的一个把byte按照不考虑正负号的原则的＂升位＂程序，因为java没有unsigned运算 
  312.      */  
  313.     public static long b2iu(byte b) {  
  314.         return b < 0 ? b & 0x7F + 128 : b;  
  315.     }  
  316.   
  317.     /** 
  318.      * byteHEX()，用来把一个byte类型的数转换成十六进制的ASCII表示， 
  319.      * 因为java中的byte的toString无法实现这一点，我们又没有C语言中的 sprintf(outbuf,"%02X",ib) 
  320.      */  
  321.     public static String byteHEX(byte ib) {  
  322.         char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',  
  323.                 'B', 'C', 'D', 'E', 'F' };  
  324.         char[] ob = new char[2];  
  325.         ob[0] = Digit[(ib >>> 4) & 0X0F];  
  326.         ob[1] = Digit[ib & 0X0F];  
  327.         String s = new String(ob);  
  328.         return s;  
  329.     }  
  330.       
  331.       
  332.     //-----------------------------------------------------------  
  333.   
  334.     /** 
  335.      * 获取单个文件的MD5值！ 
  336.      * @param file 
  337.      * @return 
  338.      */  
  339.     public static String getFileMD5(File file) {  
  340.         if (!file.isFile()) {  
  341.             return null;  
  342.         }  
  343.         MessageDigest digest = null;  
  344.         FileInputStream in = null;  
  345.         byte buffer[] = new byte[1024];  
  346.         int len;  
  347.         try {  
  348.             digest = MessageDigest.getInstance("MD5");  
  349.             in = new FileInputStream(file);  
  350.             while ((len = in.read(buffer, 0, 1024)) != -1) {  
  351.                 digest.update(buffer, 0, len);  
  352.             }  
  353.             in.close();  
  354.         } catch (Exception e) {  
  355.             e.printStackTrace();  
  356.             return null;  
  357.         }  
  358.         BigInteger bigInt = new BigInteger(1, digest.digest());  
  359.         return bigInt.toString(16).toUpperCase();  
  360.     }  
  361.         
  362.     /** 
  363.      * 获取单个文件的SHA1值！ 
  364.      *  
  365.      * @param file 
  366.      * @return 
  367.      */  
  368.     public static String getFileSHA1(File file) {  
  369.         if (!file.isFile()) {  
  370.             return null;  
  371.         }  
  372.         MessageDigest digest = null;  
  373.         FileInputStream in = null;  
  374.         byte buffer[] = new byte[1024];  
  375.         int len;  
  376.         try {  
  377.             digest = MessageDigest.getInstance("SHA1");  
  378.             in = new FileInputStream(file);  
  379.             while ((len = in.read(buffer, 0, 1024)) != -1) {  
  380.                 digest.update(buffer, 0, len);  
  381.             }  
  382.             in.close();  
  383.         } catch (Exception e) {  
  384.             e.printStackTrace();  
  385.             return null;  
  386.         }  
  387.         BigInteger bigInt = new BigInteger(1, digest.digest());  
  388.         return bigInt.toString(16).toUpperCase();  
  389.     }  
  390.       
  391.     /** 
  392.      * 获取单个文件的CRC32值！ 
  393.      * @param file 
  394.      * @return 
  395.      * @throws Exception 
  396.      */  
  397.     public static String getFileCRC32(File file) {  
  398.         FileInputStream fileinputstream;  
  399.         try {  
  400.             fileinputstream = new FileInputStream(file);  
  401.             CRC32 crc32 = new CRC32();  
  402.             for (CheckedInputStream checkedinputstream = new CheckedInputStream(  
  403.                     fileinputstream, crc32); checkedinputstream.read() != -1;) {  
  404.             }  
  405.             return Long.toHexString(crc32.getValue());  
  406.         } catch (FileNotFoundException e) {  
  407.             e.printStackTrace();  
  408.         } catch (IOException e) {  
  409.             e.printStackTrace();  
  410.         }  
  411.         return null;  
  412.     }  
  413.   
  414.       
  415.     /** 
  416.      * 获取文件夹中文件的MD5值 
  417.      *  
  418.      * @param file 
  419.      * @param listChild 
  420.      *            ;true递归子目录中的文件 
  421.      * @return 
  422.      */  
  423.     public static Map<String, String> getDirMD5(File file, boolean listChild) {  
  424.         if (!file.isDirectory()) {  
  425.             return null;  
  426.         }  
  427.         // <filepath,md5>  
  428.         Map<String, String> map = new HashMap<String, String>();  
  429.         String md5;  
  430.         File files[] = file.listFiles();  
  431.         for (int i = 0; i < files.length; i++) {  
  432.             File f = files[i];  
  433.             if (f.isDirectory() && listChild) {  
  434.                 map.putAll(getDirMD5(f, listChild));  
  435.             } else {  
  436.                 md5 = getFileMD5(f);  
  437.                 if (md5 != null) {  
  438.                     map.put(f.getPath(), md5);  
  439.                 }  
  440.             }  
  441.         }  
  442.         return map;  
  443.     }  
  444.       
  445.     /** 
  446.      * 获取文件夹中文件的SHA1值 
  447.      *  
  448.      * @param file 
  449.      * @param listChild 
  450.      *            ;true递归子目录中的文件 
  451.      * @return 
  452.      */  
  453.     public static Map<String, String> getDirSHA1(File file, boolean listChild) {  
  454.         if (!file.isDirectory()) {  
  455.             return null;  
  456.         }  
  457.         // <filepath,SHA1>  
  458.         Map<String, String> map = new HashMap<String, String>();  
  459.         String sha1;  
  460.         File files[] = file.listFiles();  
  461.         for (int i = 0; i < files.length; i++) {  
  462.             File f = files[i];  
  463.             if (f.isDirectory() && listChild) {  
  464.                 map.putAll(getDirSHA1(f, listChild));  
  465.             } else {  
  466.                 sha1 = getFileSHA1(f);  
  467.                 if (sha1 != null) {  
  468.                     map.put(f.getPath(), sha1);  
  469.                 }  
  470.             }  
  471.         }  
  472.         return map;  
  473.     }  
  474.   
  475.     /** 
  476.      * 获取文件夹中文件的CRC32值 
  477.      *  
  478.      * @param file 
  479.      * @param listChild 
  480.      *            ;true递归子目录中的文件 
  481.      * @return 
  482.      */  
  483.     public static Map<String, String> getDirCRC32(File file, boolean listChild) {  
  484.         if (!file.isDirectory()) {  
  485.             return null;  
  486.         }  
  487.         // <filepath,CRC32>  
  488.         Map<String, String> map = new HashMap<String, String>();  
  489.         String crc32;  
  490.         File files[] = file.listFiles();  
  491.         for (int i = 0; i < files.length; i++) {  
  492.             File f = files[i];  
  493.             if (f.isDirectory() && listChild) {  
  494.                 map.putAll(getDirCRC32(f, listChild));  
  495.             } else {  
  496.                 crc32 = getFileCRC32(f);  
  497.                 if (crc32 != null) {  
  498.                     map.put(f.getPath(), crc32);  
  499.                 }  
  500.             }  
  501.         }  
  502.         return map;  
  503.     }  
  504. }  
posted on 2020-01-02 16:50  雨燕赵  阅读(924)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 雨燕赵
Powered by .NET 8.0 on Kubernetes