须要用到一个jar

http://www.bouncycastle.org/latest_releases.html

须要注意的问题

JS用同一秘钥生成的密文用java解密出来是逆序的，即js加密123456用java解密出来是654321，原因未知，须要解密js加密的密文请使用后缀为byJs的方法。

HexUtil.java

  1. > 1];
  2.  
  3.         // two characters form the hex value.
  4.         for (int i = 0, j = 0; j >> 4];
  5.             out[j++] = toDigits[0x0F & data[i]];
  6.         }
  7.         return out;
  8.     }
  9. }
  10. " data-snippet-id="ext.95f10f39d6786f444dfe7f63f74db7ec" data-snippet-saved="false" data-csrftoken="ccbrPHwP-WyjtuyjuHUnUI5J2rTNMwFME_ks" data-codota-status="done">package cn.edu.zafu.utils;
  12. public class HexUtil {
  13.     private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5',
  14.             '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
  15.     private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5',
  16.             '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  18.     public static byte[] decodeHex(final char[] data) throws Exception {
  20.         final int len = data.length;
  22.         if ((len & 0x01) != 0) {
  23.             throw new Exception("Odd number of characters.");
  24.         }
  26.         final byte[] out = new byte[len >> 1];
  28.         // two characters form the hex value.
  29.         for (int i = 0, j = 0; j < len; i++) {
  30.             int f = toDigit(data[j], j) << 4;
  31.             j++;
  32.             f = f | toDigit(data[j], j);
  33.             j++;
  34.             out[i] = (byte) (f & 0xFF);
  35.         }
  37.         return out;
  38.     }
  40.     protected static int toDigit(final char ch, final int index)
  41.             throws Exception {
  42.         final int digit = Character.digit(ch, 16);
  43.         if (digit == -1) {
  44.             throw new Exception("Illegal hexadecimal character " + ch
  45.                     + " at index " + index);
  46.         }
  47.         return digit;
  48.     }
  50.     public static char[] encodeHex(final byte[] data) {
  51.         return encodeHex(data, true);
  52.     }
  54.     public static char[] encodeHex(final byte[] data, final boolean toLowerCase) {
  55.         return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  56.     }
  58.     protected static char[] encodeHex(final byte[] data, final char[] toDigits) {
  59.         final int l = data.length;
  60.         final char[] out = new char[l << 1];
  61.         // two characters form the hex value.
  62.         for (int i = 0, j = 0; i < l; i++) {
  63.             out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
  64.             out[j++] = toDigits[0x0F & data[i]];
  65.         }
  66.         return out;
  67.     }
  68. }

StringUtil.java

  1. package cn.edu.zafu.utils;
  3. public class StringUtil {
  5.     public static boolean isBlank(final CharSequence cs) {
  6.         int strLen;
  7.         if (cs == null || (strLen = cs.length()) == 0) {
  8.             return true;
  9.         }
  10.         for (int i = 0; i < strLen; i++) {
  11.             if (Character.isWhitespace(cs.charAt(i)) == false) {
  12.                 return false;
  13.             }
  14.         }
  15.         return true;
  16.     }
  18.     public static String reverse(final String str) {
  19.         if (str == null) {
  20.             return null;
  21.         }
  22.         return new StringBuilder(str).reverse().toString();
  23.     }
  24. }

FileUtil.java

  1. package cn.edu.zafu.utils;
  3. import java.io.Closeable;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  11. public class FileUtils {
  13.     public static FileInputStream openInputStream(File file) throws IOException {
  14.         if (file.exists()) {
  15.             if (file.isDirectory()) {
  16.                 throw new IOException("File '" + file
  17.                         + "' exists but is a directory");
  18.             }
  19.             if (file.canRead() == false) {
  20.                 throw new IOException("File '" + file + "' cannot be read");
  21.             }
  22.         } else {
  23.             throw new FileNotFoundException("File '" + file
  24.                     + "' does not exist");
  25.         }
  26.         return new FileInputStream(file);
  27.     }
  29.     public static FileOutputStream openOutputStream(File file)
  30.             throws IOException {
  31.         return openOutputStream(file, false);
  32.     }
  34.     public static FileOutputStream openOutputStream(File file, boolean append)
  35.             throws IOException {
  36.         if (file.exists()) {
  37.             if (file.isDirectory()) {
  38.                 throw new IOException("File '" + file
  39.                         + "' exists but is a directory");
  40.             }
  41.             if (file.canWrite() == false) {
  42.                 throw new IOException("File '" + file
  43.                         + "' cannot be written to");
  44.             }
  45.         } else {
  46.             File parent = file.getParentFile();
  47.             if (parent != null) {
  48.                 if (!parent.mkdirs() && !parent.isDirectory()) {
  49.                     throw new IOException("Directory '" + parent
  50.                             + "' could not be created");
  51.                 }
  52.             }
  53.         }
  54.         return new FileOutputStream(file, append);
  55.     }
  57.     public static void closeQuietly(InputStream input) {
  58.         closeQuietly((Closeable) input);
  59.     }
  61.     public static void closeQuietly(Closeable closeable) {
  62.         try {
  63.             if (closeable != null) {
  64.                 closeable.close();
  65.             }
  66.         } catch (IOException ioe) {
  67.             // ignore
  68.         }
  69.     }
  70. }

RSAUtil.java

  1. package cn.edu.zafu.utils;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.ObjectInputStream;
  7. import java.io.ObjectOutputStream;
  8. import java.math.BigInteger;
  9. import java.security.KeyPair;
  10. import java.security.KeyFactory;
  11. import java.security.KeyPairGenerator;
  12. import java.security.Provider;
  13. import java.security.PublicKey;
  14. import java.security.PrivateKey;
  15. import java.security.SecureRandom;
  16. import java.security.NoSuchAlgorithmException;
  17. import java.security.InvalidParameterException;
  18. import java.security.interfaces.RSAPublicKey;
  19. import java.security.interfaces.RSAPrivateKey;
  20. import java.security.spec.RSAPublicKeySpec;
  21. import java.text.SimpleDateFormat;
  22. import java.util.Date;
  23. import java.security.spec.RSAPrivateKeySpec;
  24. import java.security.spec.InvalidKeySpecException;
  26. import javax.crypto.Cipher;
  28. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  30. /**
  31.  * RSA算法加密/解密工具类。
  32.  *
  33.  *
  34.  */
  35. public abstract class RSAUtil {
  37.     /** 算法名称 */
  38.     private static final String ALGORITHOM = "RSA";
  39.     /**保存生成的密钥对的文件名。 */
  40.     private static final String RSA_PAIR_FILENAME = "/__RSA_PAIR.txt";
  41.     /** 密钥大小 */
  42.     private static final int KEY_SIZE = 1024;
  43.     /** 默认的安全服务提供者 */
  44.     private static final Provider DEFAULT_PROVIDER = new BouncyCastleProvider();
  46.     private static KeyPairGenerator keyPairGen = null;
  47.     private static KeyFactory keyFactory = null;
  48.     /** 缓存的密钥对。 */
  49.     private static KeyPair oneKeyPair = null;
  51.     private static File rsaPairFile = null;
  53.     static {
  54.         try {
  55.             keyPairGen = KeyPairGenerator.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
  56.             keyFactory = KeyFactory.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
  57.         } catch (NoSuchAlgorithmException ex) {
  58.             System.out.println(ex.getMessage());
  59.         }
  60.         rsaPairFile = new File(getRSAPairFilePath());
  61.     }
  63.     private RSAUtil() {
  64.     }
  66.     /**
  67.      * 生成并返回RSA密钥对。
  69. */
  70.     private static synchronized KeyPair generateKeyPair() {
  71.         try {
  72.             keyPairGen.initialize(KEY_SIZE, new SecureRandom(new SimpleDateFormat("yyyyMMdd").format(new Date()).getBytes()));
  73.             oneKeyPair = keyPairGen.generateKeyPair();
  74.             saveKeyPair(oneKeyPair);
  75.             return oneKeyPair;
  76.         } catch (InvalidParameterException ex) {
  77.             System.out.println("KeyPairGenerator does not support a key length of " + KEY_SIZE + ".");
  78.             ex.printStackTrace();
  79.         } catch (NullPointerException ex) {
  80.             System.out.println("RSAUtils#KEY_PAIR_GEN is null, can not generate KeyPairGenerator instance.");
  81.             ex.printStackTrace();
  82.         }
  83.         return null;
  84.     }
  86.     /**
  87.      * 返回生成/读取的密钥对文件的路径。
  88.      */
  89.     private static String getRSAPairFilePath() {
  90.         String urlPath = RSAUtil.class.getResource("/").getPath();
  91.         return (new File(urlPath).getParent() + RSA_PAIR_FILENAME);
  92.     }
  94.     /**
  95.      * 若须要创建新的密钥对文件，则返回 {@code true}。否则 {@code false}。
  97. */
  98.     private static boolean isCreateKeyPairFile() {
  99.         // 是否创建新的密钥对文件
  100.         boolean createNewKeyPair = false;
  101.         if (!rsaPairFile.exists() || rsaPairFile.isDirectory()) {
  102.             createNewKeyPair = true;
  103.         }
  104.         return createNewKeyPair;
  105.     }
  107.     /**
  108.      * 将指定的RSA密钥对以文件形式保存。
  109.      *
  110.      * @param keyPair 要保存的密钥对。
  112. */
  113.     private static void saveKeyPair(KeyPair keyPair) {
  114.         FileOutputStream fos = null;
  115.         ObjectOutputStream oos = null;
  116.         try {
  117.             fos = FileUtils.openOutputStream(rsaPairFile);
  118.             oos = new ObjectOutputStream(fos);
  119.             oos.writeObject(keyPair);
  120.         } catch (Exception ex) {
  121.             ex.printStackTrace();
  122.         } finally {
  123.             FileUtils.closeQuietly(oos);
  124.             FileUtils.closeQuietly(fos);
  125.         }
  126.     }
  128.     /**
  129.      * 返回RSA密钥对。
  131. */
  132.     public static KeyPair getKeyPair() {
  133.         // 首先推断是否须要又一次生成新的密钥对文件
  134.         if (isCreateKeyPairFile()) {
  135.             // 直接强制生成密钥对文件，并存入缓存。
  136.             return generateKeyPair();
  137.         }
  138.         if (oneKeyPair != null) {
  139.             return oneKeyPair;
  140.         }
  141.         return readKeyPair();
  142.     }
  144.     // 同步读出保存的密钥对
  145.     private static KeyPair readKeyPair() {
  146.         FileInputStream fis = null;
  147.         ObjectInputStream ois = null;
  148.         try {
  149.             fis = FileUtils.openInputStream(rsaPairFile);
  150.             ois = new ObjectInputStream(fis);
  151.             oneKeyPair = (KeyPair) ois.readObject();
  152.             return oneKeyPair;
  153.         } catch (Exception ex) {
  154.             ex.printStackTrace();
  155.         } finally {
  156.             FileUtils.closeQuietly(ois);
  157.             FileUtils.closeQuietly(fis);
  158.         }
  159.         return null;
  160.     }
  162.     /**
  163.      * 依据给定的系数和专用指数构造一个RSA专用的公钥对象。
  165. *
  166.      * @param modulus 系数。
  167.      * @param publicExponent 专用指数。
  169. * @return RSA专用公钥对象。
  171. */
  172.     public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) {
  173.         RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(new BigInteger(modulus),
  174.                 new BigInteger(publicExponent));
  175.         try {
  176.             return (RSAPublicKey) keyFactory.generatePublic(publicKeySpec);
  177.         } catch (InvalidKeySpecException ex) {
  178.             System.out.println("RSAPublicKeySpec is unavailable.");
  179.             ex.printStackTrace();
  180.         } catch (NullPointerException ex) {
  181.             System.out.println("RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance.");
  182.             ex.printStackTrace();
  183.         }
  184.         return null;
  185.     }
  187.     /**
  188.      * 依据给定的系数和专用指数构造一个RSA专用的私钥对象。
  189.      *
  190.      * @param modulus 系数。
  191.      * @param privateExponent 专用指数。
  192.      * @return RSA专用私钥对象。
  193.      */
  194.     public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) {
  195.         RSAPrivateKeySpec privateKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus),
  196.                 new BigInteger(privateExponent));
  197.         try {
  198.             return (RSAPrivateKey) keyFactory.generatePrivate(privateKeySpec);
  199.         } catch (InvalidKeySpecException ex) {
  200.             System.out.println("RSAPrivateKeySpec is unavailable.");
  201.             ex.printStackTrace();
  202.         } catch (NullPointerException ex) {
  203.             System.out.println("RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance.");
  204.             ex.printStackTrace();
  205.         }
  206.         return null;
  207.     }
  209.     /**
  210.      * 依据给定的16进制系数和专用指数字符串构造一个RSA专用的私钥对象。
  211.      *
  212.      * @param modulus 系数。
  213.      * @param privateExponent 专用指数。
  215. * @return RSA专用私钥对象。
  217. */
  218.     public static RSAPrivateKey getRSAPrivateKey(String hexModulus, String hexPrivateExponent) {
  219.         if(StringUtil.isBlank(hexModulus) || StringUtil.isBlank(hexPrivateExponent)) {
  220.             System.out.println("hexModulus and hexPrivateExponent cannot be empty. RSAPrivateKey value is null to return.");
  221.             return null;
  222.         }
  223.         byte[] modulus = null;
  224.         byte[] privateExponent = null;
  225.         try {
  226.             modulus = HexUtil.decodeHex(hexModulus.toCharArray());
  227.             privateExponent = HexUtil.decodeHex(hexPrivateExponent.toCharArray());
  228.         } catch(Exception ex) {
  229.             System.out.println("hexModulus or hexPrivateExponent value is invalid. return null(RSAPrivateKey).");
  230.             ex.printStackTrace();
  231.         }
  232.         if(modulus != null && privateExponent != null) {
  233.             return generateRSAPrivateKey(modulus, privateExponent);
  234.         }
  235.         return null;
  236.     }
  237.     /**
  238.      * 依据给定的16进制系数和专用指数字符串构造一个RSA专用的公钥对象。
  240. *
  241.      * @param modulus 系数。
  243. * @param publicExponent 专用指数。
  245. * @return RSA专用公钥对象。
  246.      */
  247.     public static RSAPublicKey getRSAPublicKey(String hexModulus, String hexPublicExponent) {
  248.         if(StringUtil.isBlank(hexModulus) || StringUtil.isBlank(hexPublicExponent)) {
  249.                 System.out.println("hexModulus and hexPublicExponent cannot be empty. return null(RSAPublicKey).");
  250.             return null;
  251.         }
  252.         byte[] modulus = null;
  253.         byte[] publicExponent = null;
  254.         try {
  255.             modulus = HexUtil.decodeHex(hexModulus.toCharArray());
  256.             publicExponent = HexUtil.decodeHex(hexPublicExponent.toCharArray());
  257.         } catch(Exception ex) {
  258.             System.out.println("hexModulus or hexPublicExponent value is invalid. return null(RSAPublicKey).");
  259.             ex.printStackTrace();
  260.         }
  261.         if(modulus != null && publicExponent != null) {
  262.             return generateRSAPublicKey(modulus, publicExponent);
  263.         }
  264.         return null;
  265.     }
  266.     /**
  267.      * 使用指定的公钥加密数据。
  268.      *
  269.      * @param publicKey 给定的公钥。
  270.      * @param data 要加密的数据。
  271.      * @return 加密后的数据。
  273. */
  274.     public static byte[] encrypt(PublicKey publicKey, byte[] data) throws Exception {
  275.         Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
  276.         ci.init(Cipher.ENCRYPT_MODE, publicKey);
  277.         return ci.doFinal(data);
  278.     }
  280.     /**
  281.      * 使用指定的私钥解密数据。
  282.      *
  283.      * @param privateKey 给定的私钥。
  284.      * @param data 要解密的数据。
  285.      * @return 原数据。
  286.      */
  287.     public static byte[] decrypt(PrivateKey privateKey, byte[] data) throws Exception {
  288.         Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
  289.         ci.init(Cipher.DECRYPT_MODE, privateKey);
  290.         return ci.doFinal(data);
  291.     }
  293.     /**
  294.      * 使用给定的公钥加密给定的字符串。
  296. * <p />
  297.      * 若 {@code publicKey} 为 {@code null}。或者 {@code plaintext} 为 {@code null} 则返回 {@code
  298.      * null}。
  299.      *
  300.      * @param publicKey 给定的公钥。
  301.      * @param plaintext 字符串。
  302.      * @return 给定字符串的密文。
  303.      */
  304.     public static String encryptString(PublicKey publicKey, String plaintext) {
  305.         if (publicKey == null || plaintext == null) {
  306.             return null;
  307.         }
  308.         byte[] data = plaintext.getBytes();
  309.         try {
  310.             byte[] en_data = encrypt(publicKey, data);
  311.             return new String(HexUtil.encodeHex(en_data));
  312.         } catch (Exception ex) {
  313.             ex.printStackTrace();
  314.         }
  315.         return null;
  316.     }
  318.     /**
  319.      * 使用默认的公钥加密给定的字符串。
  320.      * <p />
  321.      * 若{@code plaintext} 为 {@code null} 则返回 {@code null}。
  322.      *
  323.      * @param plaintext 字符串。
  324.      * @return 给定字符串的密文。
  325.      */
  326.     public static String encryptString(String plaintext) {
  327.         if(plaintext == null) {
  328.             return null;
  329.         }
  330.         byte[] data = plaintext.getBytes();
  331.         KeyPair keyPair = getKeyPair();
  332.         try {
  333.             byte[] en_data = encrypt((RSAPublicKey)keyPair.getPublic(), data);
  334.             return new String(HexUtil.encodeHex(en_data));
  335.         } catch(NullPointerException ex) {
  336.             System.out.println("keyPair cannot be null.");
  337.             ex.printStackTrace();
  338.         } catch(Exception ex) {
  339.             ex.printStackTrace();
  340.         }
  341.         return null;
  342.     }
  344.     /**
  345.      * 生成由JS的RSA加密的字符串。
  347. * @param publicKey 公钥
  348.      * @param plaintext 原文字符串
  349.      * @return 加密后的字符串
  350.      */
  351.     public static String encryptStringByJs(PublicKey publicKey, String plaintext) {
  352.          if(plaintext == null) {
  353.              return null;
  354.          }
  355.         String text = encryptString(publicKey,StringUtil.reverse(plaintext));
  357.         return text;
  358.     }
  359.     /**
  360.      * 用默认公钥生成由JS的RSA加密的字符串。
  361.      * @param publicKey 公钥
  362.      * @param plaintext 原文字符串
  363.      * @return 加密后的字符串
  364.      */
  365.     public static String encryptStringByJs( String plaintext) {
  366.          if(plaintext == null) {
  367.              return null;
  368.          }
  369.         String text = encryptString(StringUtil.reverse(plaintext));
  371.         return text;
  372.     }
  373.     /**
  374.      * 使用给定的私钥解密给定的字符串。
  376. * <p />
  377.      * 若私钥为 {@code null}，或者 {@code encrypttext} 为 {@code null}或空字符串则返回 {@code null}。
  378.      * 私钥不匹配时，返回 {@code null}。
  379.      *
  380.      * @param privateKey 给定的私钥。
  382. * @param encrypttext 密文。
  384. * @return 原文字符串。
  386. */
  387.     public static String decryptString(PrivateKey privateKey, String encrypttext) {
  388.         if (privateKey == null || StringUtil.isBlank(encrypttext)) {
  389.             return null;
  390.         }
  391.         try {
  392.             byte[] en_data =HexUtil.decodeHex(encrypttext.toCharArray());
  393.             byte[] data = decrypt(privateKey, en_data);
  394.             return new String(data);
  395.         } catch (Exception ex) {
  396.             System.out.println(String.format("\"%s\" Decryption failed. Cause: %s", encrypttext, ex.getCause().getMessage()));
  398.         }
  399.         return null;
  400.     }
  402.     /**
  403.      * 使用默认的私钥解密给定的字符串。
  404.      * <p />
  405.      * 若{@code encrypttext} 为 {@code null}或空字符串则返回 {@code null}。
  406.      * 私钥不匹配时，返回 {@code null}。
  407.      *
  408.      * @param encrypttext 密文。
  409.      * @return 原文字符串。
  410.      */
  411.     public static String decryptString(String encrypttext) {
  412.         if(StringUtil.isBlank(encrypttext)) {
  413.             return null;
  414.         }
  415.         KeyPair keyPair = getKeyPair();
  416.         try {
  417.             byte[] en_data = HexUtil.decodeHex(encrypttext.toCharArray());
  418.             byte[] data = decrypt((RSAPrivateKey)keyPair.getPrivate(), en_data);
  419.             return new String(data);
  420.         } catch(NullPointerException ex) {
  421.             System.out.println("keyPair cannot be null.");
  422.             ex.printStackTrace();
  423.         } catch (Exception ex) {
  424.             System.out.println(String.format("\"%s\" Decryption failed. Cause: %s", encrypttext, ex.getMessage()));
  425.             ex.printStackTrace();
  426.         }
  427.         return null;
  428.     }
  430.     /**
  431.      * 使用指定的私钥解密由JS加密的字符串。
  432.      * @param privateKey 私钥
  433.      * @param encrypttext 密文
  434.      * @return {@code encrypttext} 的原文字符串
  435.      */
  436.     public static String decryptStringByJs(PrivateKey privateKey,String encrypttext) {
  437.         String text = decryptString(privateKey,encrypttext);
  438.         if(text == null) {
  439.             return null;
  440.         }
  441.         return StringUtil.reverse(text);
  442.     }
  443.     /**
  444.      * 使用默认的私钥解密由JS加密（使用此类提供的公钥加密）的字符串。
  445.      *
  446.      * @param encrypttext 密文。
  448. * @return {@code encrypttext} 的原文字符串。
  449.      */
  450.     public static String decryptStringByJs(String encrypttext) {
  451.         String text = decryptString(encrypttext);
  452.         if(text == null) {
  453.             return null;
  454.         }
  455.         return StringUtil.reverse(text);
  456.     }
  458.     /** 返回已初始化的默认的公钥。
  460. */
  461.     public static RSAPublicKey getDefaultPublicKey() {
  462.         KeyPair keyPair = getKeyPair();
  463.         if(keyPair != null) {
  464.             return (RSAPublicKey)keyPair.getPublic();
  465.         }
  466.         return null;
  467.     }
  469.     /** 返回已初始化的默认的私钥。*/
  470.     public static RSAPrivateKey getDefaultPrivateKey() {
  471.         KeyPair keyPair = getKeyPair();
  472.         if(keyPair != null) {
  473.             return (RSAPrivateKey)keyPair.getPrivate();
  474.         }
  475.         return null;
  476.     }
  478. }

源代码下载

http://download.csdn.net/detail/sbsujjbcy/8897029

JAVA的RSA加密算法工具类的更多相关文章

  1. Rhino+envjs-1.2.js 在java运行网站js 工具类

    java爬虫遇到个页面加密的东西,找了些资料学习学习 做了个java运行js的工具类,希望对大家有用,其中用到client(获取js)可以自行换成自己的client.主要是用了 Rhino就是Java ...

  2. java中常用的工具类（一）

    我们java程序员在开发项目的是常常会用到一些工具类.今天我汇总了一下java中常用的工具方法.大家可以在项目中使用.可以收藏!加入IT江湖官方群:383126909 我们一起成长 一.String工 ...

  3. Java学习-041-颜色工具类（RGB,HEX）

    在日常的网页开发中,经常需要进行颜色数值获取.转换,例如获取红色,获取蓝色,获取绿色,RGB转十六进制颜色,十六进制颜色转RGB等,因而在学习过程中,写了一个小工具类,仅供各位小主参考! 多不闲言,直 ...

  4. JAVA中封装JSONUtils工具类及使用

    在JAVA中用json-lib-2.3-jdk15.jar包中提供了JSONObject和JSONArray基类,用于JSON的序列化和反序列化的操作.但是我们更习惯将其进一步封装,达到更好的重用. ...

  5. JAVA自动生成正则表达式工具类

    经过很久的努力,终于完成了JAVA自动生成正则表达式工具类.还记得之前需要正则,老是从网上找吗?找了想修改也不会修改.现在不用再为此烦恼了,使用此生成类轻松搞定所有正则表达式.赶快在同事面前炫一下吧. ...

  6. java 二进制数字符串转换工具类

    java 二进制数字符串转换工具类 将二进制转换成八进制 将二进制转换成十进制 将二进制转换成十六进制 将十进制转换成二进制 package com.iteye.injavawetrust.ad; i ...

  7. Java学习-049-正则工具类

    自去年九月份决定再次入学和职业资格进阶,开始备战二者考试至今,以及当下进行中的职称申请,犹如孤独的狼,不断前行在路上,而今凡凡总总的已历8月... 不感慨了,如下为一园友需要的正则工具类,直接上码: ...

  8. Java 后台验证的工具类

    Java 后台验证的工具类 public class ValidationUtil {         //手机号     public static String mobile = "^( ...

  9. java后端时间处理工具类，返回 "XXX 前" 的字符串

    转自:https://www.cnblogs.com/devise/p/9974672.html 我们经常会遇到显示 "某个之间之前" 的需求(比如各种社交软件,在回复消息时,显示 ...

随机推荐

  1. jQuery回到顶部

    jquery回到顶部 <!DOCTYPE html> <html lang="zh-cn"> <head> <meta charset=& ...

  2. DedeCMS批量替换栏目文件保存目录的方法

    学点sql还是很有必要的.   有时候由于栏目太多,但是要修改一下栏目的保存目录.一个一个修改真的有点费事和慢.所以想了一个方法来批量修改栏目的保存目录.就是批量替换: update dede_arc ...

  3. Nginx环境下常见的开源项目重写汇总

    我们做PHP开发的,作者寒冰我觉得大部分时候都在跟开源的系统打交道.比如:Discuz.PHPCMS.ecshop.wordpress等开源系统.一般我们都是在本地搭建测试环境,用的web服务器都是a ...

  4. TreeView 数据绑定及选中命令处理

    昨天接近下班,一个群里面的网友,问treeView绑定后  选中命令怎么来处理,怎么没有效果,而且用MVVM的方式来写:快下班了本来想远程帮他看下,结果就说写个Demo给他看:再加上选中传参: 下面分 ...

  5. 东软实训1 -jsp内置对象及其常用方法

    JSP 的内置对象及方法详细说明 一. request 对象 客户端的请求信息被封装在 request 对象中,通过它才能了解到客户的需 求,然后做出响应.它是 HttpServletRequest ...

  6. PHP学习系列（1）——字符串处理函数（3）

    11.crc32() 函数计算一个字符串的 crc32 多项式.生成 string 参数的 32 位循环冗余校验码多项式.该函数可用于验证数据的完整性. 语法:crc32(string) 注意:由于 ...

  7. Python自动化运维之2、运算符与数据类型

    python对象的相关术语: python程序中保存的所有数据都是围绕对象这个概念展开的: 程序中存储的所有数据都是对象 每个对象都有一个身份.一个类型和一个值 例如,school='MaGe Lin ...

  8. Objective C内存管理之理解autorelease------面试题

    Objective C内存管理之理解autorelease   Autorelease实际上只是把对release的调用延迟了,对于每一个Autorelease,系统只是把该Object放入了当前的A ...

  9. DbUtility-查询DataTable

    直接上源码 using System; using System.Data; using System.Threading.Tasks; using DbUtility; namespace Test ...

  10. 浅析Android中的消息机制

    在分析Android消息机制之前,我们先来看一段代码: public class MainActivity extends Activity implements View.OnClickListen ...