文档章节

JAVA实用工具类

maskleo
 maskleo
发布于 2015/10/18 19:56
字数 3211
阅读 22
收藏 0
点赞 0
评论 0

        在开发java项目时,经常都需要频繁处理数据,如果能非常合适、严谨的处理数据,那么将对程序有莫大的好处,例如,提高程序的稳定性,而且有时候数据在使用前是必须处理的,否则就会出错。例如,在操作前对被除数的处理(如果是0怎么办)、字符串转化、编码转换等,针对项目开发中对数据的频繁操作,在我们程序的开发过程中是很有必要对这些处理数据的工具方法进行统一归类使用的,而下面的这个工具类就封装了很多对基础数据的处理操作的方法。因为方法很多,为了方便查询,我先对方法及其实现的功能列了一个清单,如下:

        同时也希望大家能把自己使用的工具类发上来共享,谢谢。

 

一、功能方法目录清单:

1、getString(String sSource)的功能是判断参数是否为空,为空返回"",否则返回其值;

2、getString(int iSource)的功能是判断参数是否为0,为0则返回"",否则返回其值;

3、GBKtoISO(String s)的功能是进行编码转换,由GBK转为 iso-8859-1;

4、ISOtoGBK(String s)的功能是进行编码转换,由iso-8859-1 转为 GBK;

5、getArray(String[] aSource)的功能是判断参数是否为空,为空则返回一个长度为0的字符串数组,否则返回其值;

6、getInt(String sSource)的功能是判断参数是否为空,为空则返回0,不为空则返回其整型值;

7、getIntArray(String[] aSource)的功能是判断参数是否为空,为空则返回一个长度为0的整形数组,否则返回其值;

8、getDouble(String sSource)的功能是判断参数是否为空,为空则返回0,不为空则返回其整型值;

9、isContain(String sSource, String sItem)的功能是查找以逗号分隔的源字符串是否包含给定字符串;

10、isContain(String[] aSource, String sItem)的功能是查找源字符串数组中是否包含给定字符串;

11、delete(String source, String subString)的功能是将指定字符串从源字符串中删除掉,并返回替换后的结果字符串;

12、replace(String source, String oldString, String newString)的功能是用新字符串替换源字符串中的旧字符串;

13、increaseOne(String sSource)的功能是将给定的源字符串加1 例如:“0001” 经本函数转换后返回为“0002”;

14、intToStr(int val, int len)的功能是将给定的整数转化成字符串,结果字符串的长度为给定长度,不足位数的左端补"0";

15、arrayAddSign(String[] aSource, String sChar)的功能是将数组中的每个元素两端加上给定的符号;

16、arrayToString(String[] aSource)的功能是将数组中的元素连成一个以逗号分隔的字符串;

17、arrayToString(int[] aSource)的功能是将数组中的元素连成一个以逗号分隔的字符串;

18、arrayToString(String[] aSource, String sChar)的功能是将数组中的元素连成一个以给定字符分隔的字符串;

19、arrayAppend(String[] array1, String[] array2)的功能是将两个字符串的所有元素连结为一个字符串数组;

20、arrayAppend(Object[] array1, Object[] array2)的功能是将两个对象数组中的所有元素连结为一个对象数组;

21、strToArray(String sSource)的功能是拆分以逗号分隔的字符串,并存入String数组中;

22、strToArray(String sSource, String sChar)的功能是拆分以给定分隔符分隔的字符串,并存入字符串数组中;

23、strToArray(String sSource, char sChar)的功能是拆分以给定分隔符分隔的字符串,并存入整型数组中;

24、addMark(String sSource)的功能是将以逗号分隔的字符串的每个元素加上单引号 如: 1000,1001,1002 --> '1000','1001','1002';

25、deleteFile(String fileName)的功能是删除磁盘上的文件;

26、isNumber(String strInput)的功能是判断字符串是否可转换成数字;

27、isIp(String strIp)的功能是判断输入的字符是否是IP地址的形式;

  1. import java.io.File;
  2. import java.io.Serializable;
  3. import java.math.BigDecimal;
  4. import java.util.Hashtable;
  5. import java.util.Set;
  6. import java.util.StringTokenizer;
  7. import java.util.Vector;
  8. /*******************************************************************************
  9.  * 文件名称:Function.java<br>
  10.  * 功能描述:工具类,封装一些常用的操作<br>
  11.  ******************************************************************************/
  12. public class Function implements Serializable {
  13.     private static final long serialVersionUID = 1L;
  14.     public Function() {
  15.     }
  16.     public static void main(String args[]) {
  17.     }
  18.     /**
  19.      * 判断参数是否为空,为空则返回"",否则返回其值
  20.      * @param sSource 源字符串
  21.      * @return 字符串
  22.      */
  23.     public String getString(String sSource) {
  24.         String sReturn = "";
  25.         if (sSource != null) {
  26.             sReturn = sSource;
  27.         }
  28.         return sReturn;
  29.     }
  30.     /**
  31.      * 判断参数是否为0,为0则返回"",否则返回其值
  32.      * @param iSource 源字符串
  33.      * @return 字符串
  34.      */
  35.     public static String getString(int iSource) {
  36.         if (iSource == 0) {
  37.             return "";
  38.         } else {
  39.             return "" + iSource;
  40.         }
  41.     }
  42.     /**
  43.      * 转码:GBK ----> iso-8859-1
  44.      * @param s 转码字段
  45.      * @return 转码后的字段
  46.      */
  47.     public static String GBKtoISO(String s) {
  48.         try {
  49.             s = new String(s.getBytes("GBK"), "iso-8859-1");
  50.         } catch (Exception e) {
  51.         }
  52.         return s;
  53.     }
  54.     /**
  55.      * 转码:iso-8859-1 ----> GBK
  56.      * @param s 转码字段
  57.      * @return 转码后的字段
  58.      */
  59.     public static String ISOtoGBK(String s) {
  60.         try {
  61.             s = new String(s.getBytes("iso-8859-1"), "GBK");
  62.         } catch (Exception e) {
  63.         }
  64.         return s;
  65.     }
  66.     /**
  67.      * 判断参数是否为空,为空则返回一个长度为0的字符串数组,否则返回其值
  68.      * @param aSource 源字符串数组
  69.      * @return 字符串
  70.      */
  71.     public String[] getArray(String[] aSource) {
  72.         String aReturn[] = new String[0];
  73.         if (aSource != null) {
  74.             aReturn = aSource;
  75.         }
  76.         return aReturn;
  77.     }
  78.     /**
  79.      * 判断参数是否为空,为空则返回0,不为空则返回其整型值
  80.      * @param sSource  源字符串
  81.      * @return 整型数
  82.      */
  83.     public int getInt(String sSource) {
  84.         int iReturn = 0;
  85.         if (sSource != null && !sSource.equals("")) {
  86.             iReturn = Integer.parseInt(sSource);
  87.         }
  88.         return iReturn;
  89.     }
  90.     /**
  91.      * 判断参数是否为空,为空则返回一个长度为0的整形数组,否则返回其值
  92.      * @param aSource 源字符串数组
  93.      * @return 整形数组
  94.      */
  95.     public int[] getIntArray(String[] aSource) {
  96.         int iReturn[] = new int[0];
  97.         if (aSource != null) {
  98.             iReturn = new int[aSource.length];
  99.             for (int i = 0; i < aSource.length; i++) {
  100.                 iReturn[i] = Integer.parseInt(aSource[i]);
  101.             }
  102.         }
  103.         return iReturn;
  104.     }
  105.     /**
  106.      * 判断参数是否为空,为空则返回0,不为空则返回其整型值 
  107.      * @param sSource 源字符串
  108.      * @return Double数
  109.      */
  110.     public double getDouble(String sSource) {
  111.         double dReturn = 0.00;
  112.         if (sSource != null && !sSource.equals("")) {
  113.             dReturn = (new Double(sSource)).doubleValue();
  114.         }
  115.         return dReturn;
  116.     }
  117.     /**
  118.      * 查找以逗号分隔的源字符串是否包含给定字符串
  119.      * @param sSource :源字符串
  120.      * @param sItem :子串
  121.      * @return 是否包含
  122.      */
  123.     public boolean isContain(String sSource, String sItem) {
  124.         boolean isReturn = false;
  125.         StringTokenizer st = null;
  126.         st = new StringTokenizer(sSource, ",");
  127.         while (st.hasMoreTokens()) {
  128.             if (sItem.equals(st.nextToken())) {
  129.                 isReturn = true;
  130.                 break;
  131.             }
  132.         }
  133.         return isReturn;
  134.     }
  135.     /**
  136.      * 查找源字符串数组中是否包含给定字符串
  137.      * @param aSource :源字符串数组
  138.      * @param sItem :子串
  139.      * @return 是否包含
  140.      */
  141.     public boolean isContain(String[] aSource, String sItem) {
  142.         boolean isReturn = false;
  143.         for (int i = 0; i < aSource.length; i++) {
  144.             if (sItem.equals(aSource[i])) {
  145.                 isReturn = true;
  146.                 break;
  147.             }
  148.         }
  149.         return isReturn;
  150.     }
  151.     /**
  152.      * 将指定字符串从源字符串中删除掉,并返回替换后的结果字符串
  153.      * @param source 源字符串
  154.      * @param subString 要删除的字符
  155.      * @return 替换后的字符串
  156.      */
  157.     public String delete(String source, String subString) {
  158.         StringBuffer output = new StringBuffer();
  159.          //源字符串长度
  160.         int lengthOfSource = source.length();
  161.         //开始搜索位置
  162.         int posStart = 0
  163.         //搜索到老字符串的位置
  164.         int pos; 
  165.         while ((pos = source.indexOf(subString, posStart)) >= 0) {
  166.             output.append(source.substring(posStart, pos));
  167.             posStart = pos + 1;
  168.         }
  169.         if (posStart < lengthOfSource) {
  170.             output.append(source.substring(posStart));
  171.         }
  172.         return output.toString();
  173.     }
  174.     /**
  175.      * 此函数有三个输入参数,源字符串(将被操作的字符串),原字符串中被替换的字符串(旧字符串)
  176.      * 替换的字符串(新字符串),函数接收源字符串、旧字符串、新字符串三个值后,
  177.      * 用新字符串代替源字符串中的旧字符串并返回结果
  178.      * @param source 源字符串
  179.      * @param oldString 旧字符串
  180.      * @param newString 新字符串
  181.      * @return 替换后的字符串
  182.      */
  183.     public static String replace(String source, String oldString,
  184.             String newString) {
  185.         StringBuffer output = new StringBuffer();
  186.         int lengthOfSource = source.length(); // 源字符串长度
  187.         int lengthOfOld = oldString.length(); // 老字符串长度
  188.         int posStart = 0// 开始搜索位置
  189.         int pos; // 搜索到老字符串的位置
  190.         while ((pos = source.indexOf(oldString, posStart)) >= 0) {
  191.             output.append(source.substring(posStart, pos));
  192.             output.append(newString);
  193.             posStart = pos + lengthOfOld;
  194.         }
  195.         if (posStart < lengthOfSource) {
  196.             output.append(source.substring(posStart));
  197.         }
  198.         return output.toString();
  199.     }
  200.     /**
  201.      * 将给定的源字符串加1 例如:“0001” 经本函数转换后返回为“0002”
  202.      * @param sSource :源字符串
  203.      * @return 返回字符串
  204.      */
  205.     public String increaseOne(String sSource) {
  206.         String sReturn = null;
  207.         int iSize = 0;
  208.         iSize = sSource.length();
  209.         long l = (new Long(sSource)).longValue();
  210.         l++;
  211.         sReturn = String.valueOf(l);
  212.         for (int i = sReturn.length(); i < iSize; i++) {
  213.             sReturn = "0" + sReturn;
  214.         }
  215.         return sReturn;
  216.     }
  217.     /**
  218.      * 将给定的整数转化成字符串,结果字符串的长度为给定长度,不足位数的左端补"0"
  219.      * 例如val=10,len=5,那么生成的字符串为"00010"
  220.      * @param val 将被转化成字符串的整数
  221.      * @param len 转化后的长度
  222.      * @return String 返回值
  223.      */
  224.     public String intToStr(int val, int len) {
  225.         String sReturn = new String();
  226.         sReturn = String.valueOf(val);
  227.         if (sReturn.length() < len) {
  228.             for (int i = len - sReturn.length(); i > 0; i--) {
  229.                 sReturn = "0" + sReturn;
  230.             }
  231.         }
  232.         return sReturn;
  233.     }
  234.     /**
  235.      * 将数组中的每个元素两端加上给定的符号
  236.      * @param aSource 源数组
  237.      * @param sChar 符号
  238.      * @return 处理后的字符串数组
  239.      */
  240.     public String[] arrayAddSign(String[] aSource, String sChar) {
  241.         String aReturn[] = new String[aSource.length];
  242.         for (int i = 0; i < aSource.length; i++) {
  243.             aReturn[i] = sChar + aSource[i] + sChar;
  244.         }
  245.         return aReturn;
  246.     }
  247.     /**
  248.      * 将数组中的元素连成一个以逗号分隔的字符串
  249.      * @param aSource 源数组
  250.      * @return 字符串
  251.      */
  252.     public String arrayToString(String[] aSource) {
  253.         String sReturn = "";
  254.         for (int i = 0; i < aSource.length; i++) {
  255.             if (i > 0) {
  256.                 sReturn += ",";
  257.             }
  258.             sReturn += aSource[i];
  259.         }
  260.         return sReturn;
  261.     }
  262.     /**
  263.      * 将数组中的元素连成一个以逗号分隔的字符串
  264.      * @param aSource 源数组
  265.      * @return 字符串
  266.      */
  267.     public String arrayToString(int[] aSource) {
  268.         String sReturn = "";
  269.         for (int i = 0; i < aSource.length; i++) {
  270.             if (i > 0) {
  271.                 sReturn += ",";
  272.             }
  273.             sReturn += aSource[i];
  274.         }
  275.         return sReturn;
  276.     }
  277.     /**
  278.      * 将数组中的元素连成一个以给定字符分隔的字符串
  279.      * @param aSource 源数组
  280.      * @param sChar 分隔符
  281.      * @return 字符串
  282.      */
  283.     public String arrayToString(String[] aSource, String sChar) {
  284.         String sReturn = "";
  285.         for (int i = 0; i < aSource.length; i++) {
  286.             if (i > 0) {
  287.                 sReturn += sChar;
  288.             }
  289.             sReturn += aSource[i];
  290.         }
  291.         return sReturn;
  292.     }
  293.     /**
  294.      * 将两个字符串的所有元素连结为一个字符串数组
  295.      * @param array1 源字符串数组1
  296.      * @param array2 源字符串数组2
  297.      * @return String[]
  298.      */
  299.     public String[] arrayAppend(String[] array1, String[] array2) {
  300.         int iLen = 0;
  301.         String aReturn[] = null;
  302.         if (array1 == null) {
  303.             array1 = new String[0];
  304.         }
  305.         if (array2 == null) {
  306.             array2 = new String[0];
  307.         }
  308.         iLen = array1.length;
  309.         aReturn = new String[iLen + array2.length];
  310.         /**
  311.          * 将第一个字符串数组的元素加到结果数组中
  312.          */
  313.         for (int i = 0; i < iLen; i++) {
  314.             aReturn[i] = array1[i];
  315.         }
  316.         /**
  317.          * 将第二个字符串数组的元素加到结果数组中
  318.          */
  319.         for (int i = 0; i < array2.length; i++) {
  320.             aReturn[iLen + i] = array2[i];
  321.         }
  322.         return aReturn;
  323.     }
  324.     /**
  325.      * 将两个对象数组中的所有元素连结为一个对象数组
  326.      * @param array1 源字符串数组1
  327.      * @param array2 源字符串数组2
  328.      * @return Object[]
  329.      */
  330.     public Object[] arrayAppend(Object[] array1, Object[] array2) {
  331.         int iLen = 0;
  332.         Object aReturn[] = null;
  333.         if (array1 == null) {
  334.             array1 = new Object[0];
  335.         }
  336.         if (array2 == null) {
  337.             array2 = new Object[0];
  338.         }
  339.         iLen = array1.length;
  340.         aReturn = new Object[iLen + array2.length];
  341.         /**
  342.          * 将第一个对象数组的元素加到结果数组中
  343.          */
  344.         for (int i = 0; i < iLen; i++) {
  345.             aReturn[i] = array1[i];
  346.         }
  347.         /**
  348.          * 将第二个对象数组的元素加到结果数组中
  349.          */
  350.         for (int i = 0; i < array2.length; i++) {
  351.             aReturn[iLen + i] = array2[i];
  352.         }
  353.         return aReturn;
  354.     }
  355.     /**
  356.      * 拆分以逗号分隔的字符串,并存入String数组中
  357.      * @param sSource 源字符串
  358.      * @return String[]
  359.      */
  360.     public String[] strToArray(String sSource) {
  361.         String aReturn[] = null;
  362.         StringTokenizer st = null;
  363.         st = new StringTokenizer(sSource, ",");
  364.         aReturn = new String[st.countTokens()];
  365.         int i = 0;
  366.         while (st.hasMoreTokens()) {
  367.             aReturn[i] = st.nextToken();
  368.             i++;
  369.         }
  370.         return aReturn;
  371.     }
  372.     /**
  373.      * 拆分以给定分隔符分隔的字符串,并存入字符串数组中
  374.      * @param sSource  源字符串
  375.      * @param sChar 分隔符
  376.      * @return String[]
  377.      */
  378.     public static String[] strToArray(String sSource, String sChar) {
  379.         String aReturn[] = null;
  380.         StringTokenizer st = null;
  381.         st = new StringTokenizer(sSource, sChar);
  382.         int i = 0;
  383.         aReturn = new String[st.countTokens()];
  384.         while (st.hasMoreTokens()) {
  385.             aReturn[i] = st.nextToken();
  386.             i++;
  387.         }
  388.         return aReturn;
  389.     }
  390.     /**
  391.      * 拆分以给定分隔符分隔的字符串,并存入整型数组中
  392.      * @param sSource 源字符串
  393.      * @param sChar 分隔符
  394.      * @return int[]
  395.      */
  396.     public static int[] strToArray(String sSource, char sChar) {
  397.         int aReturn[] = null;
  398.         StringTokenizer st = null;
  399.         st = new StringTokenizer(sSource, String.valueOf(sChar));
  400.         int i = 0;
  401.         aReturn = new int[st.countTokens()];
  402.         while (st.hasMoreTokens()) {
  403.             aReturn[i] = Integer.parseInt(st.nextToken());
  404.             i++;
  405.         }
  406.         return aReturn;
  407.     }
  408.     /**
  409.      * 将以逗号分隔的字符串的每个元素加上单引号 如: 1000,1001,1002 --> '1000','1001','1002'
  410.      * @param sSource 源串
  411.      * @return String
  412.      */
  413.     public String addMark(String sSource) {
  414.         String sReturn = "";
  415.         StringTokenizer st = null;
  416.         st = new StringTokenizer(sSource, ",");
  417.         if (st.hasMoreTokens()) {
  418.             sReturn += "'" + st.nextToken() + "'";
  419.         }
  420.         while (st.hasMoreTokens()) {
  421.             sReturn += "," + "'" + st.nextToken() + "'";
  422.         }
  423.         return sReturn;
  424.     }
  425.     /**
  426.      * 删除磁盘上的文件
  427.      * @param fileName 文件全路径
  428.      * @return boolean
  429.      */
  430.     public boolean deleteFile(String fileName) {
  431.         File file = new File(fileName);
  432.         return file.delete();
  433.     }
  434.     /**
  435.      * 判断字符串是否可转换成数字
  436.      * @param fileName 源串
  437.      * @return boolean
  438.      */
  439.     public static boolean isNumber(String strInput){
  440.         boolean bRs=false;
  441.         int nRs=0;
  442.         try{
  443.             nRs=Integer.parseInt(strInput);
  444.             bRs=true;
  445.         }catch(Exception e){
  446.             bRs=false;
  447.         }
  448.             return bRs;
  449.     }
  450.     /**
  451.      * 判断输入的字符是否是IP地址的形式
  452.      * @param fileName 源串
  453.      * @return boolean
  454.      */
  455.     public static boolean isIp(String strIp){
  456.         boolean bRs=false;
  457.         int nCount=0;
  458.         try{
  459.             String strTmp="";
  460.             StringTokenizer st=new StringTokenizer(strIp,".");
  461.             while (st.hasMoreElements()){
  462.                 nCount++;
  463.                 strTmp=st.nextToken();
  464.                 if(isBigger("1",strTmp) || isBigger(strTmp,"255"))
  465.                     return false;
  466.             }
  467.             if (nCount==4)
  468.                 bRs=true;
  469.         } catch(Exception e){
  470.             bRs=false;
  471.         }
  472.         return bRs;
  473.     }
  474. }

        此类包含的方法已经在实际项目开发中使用通过,这样把平常开发中经常用到的小功能封装到一个公共类里面,即减少了代码量、提高了代码重用率,又可以很方便的查询、使用,统一修改,提高了劳动率,甚至有些结构功能相似的系统间接口小程序都可以直接保留其他接口的功能框架,只改变其中的业务逻辑就可以了,非常方便。

        另外,如果大家有什么好的功能函数,希望大家也能够贴上来分享一下^-^

版权声明:本文为博主原创文章,未经博主允许不得转载。

本文转载自:http://blog.csdn.net/wlq1983/article/details/2816730

共有 人打赏支持
maskleo
粉丝 14
博文 128
码字总数 17344
作品 0
深圳
程序员
java8中的时间处理0 - api介绍

Java 8 Date Time API是我们java开发一直寻找的时间处理工具。java从一开始设计的时间类就让人头疼,好在现在终于有了java8。 为什么我们需要这套API 只要是有这么几个理由: Java的日期和时...

davelet
02/22
0
0
从Java小白到架构师必须要看的书籍,真正的“武林秘籍”!

少年,我看你骨骼精奇,将是未来万中无一的IT精英,很是适合学JAVA。维护世界和平就看你的了,我这里有能让你成为IT精英的办法!还不来看看! 基础类 1、《Thinking in Java》,入门第一位是...

启示录是真的
05/25
0
0
day14_DBUtils学习笔记

一、DBUtils介绍 Apache公司开发的框架。   DBUtils是java编程中的数据库操作实用工具,小巧简单实用。   DBUtils封装了对JDBC的操作,简化了JDBC操作。可以少写代码。 commons-dbutils 是...

黑泽明军
05/20
0
0
IBM和SAP开源其JVM诊断工具

IBM最近发布了其Java诊断工具套件,该套件包含如下工具:面向Java的产品转储分析器(Dump Analyzer)、处理垃圾收集(GC,即Garbage Collection)的Extensible Verbose Toolkit和Java锁分析器...

JavaGG
2010/03/24
0
0
JDK 1.7 基本概念和目录结构

参考资料: http://blog.csdn.net/kindazrael/article/details/7270673 http://docs.oracle.com/javase/7/docs/index.html JDK and JRE File Structure http://docs.oracle.com/javase/7/doc......

jack688
06/26
0
0
Common Gui Tools 1.4 发布,Java GUI 实用小工具集

Java GUI实用小工具集 Common Gui Tools 新增:二维码生成解析、时间戳转换、Json格式化、文本文件切分等。 Common Gui Tools 是用java编写,GUI界面的实用小工具集,1.4版有20个小工具: 1,...

bs2004
04/22
0
0
8个超实用的Java测试工具和框架

Java入门 如果你才刚开始接触Java世界,那么要做的第一件事情是,安装JDK——Java Development Kit(Java开发工具包),它自带有Java Runtime Environment(JRE)和JVM(Java运行时环境)。它...

拉偶有所依
2015/06/24
0
0
Apache Commons包简介

Components Description Latest Version Released BeanUtils 易于使用的包装在Java反射和内省API 1.9.2 2014-05-29 CLI 命令行参数解析 1.2 2009-03-19 Codec 一般的编码/解码算法(例如语音...

银月光海
2015/01/15
0
0
JDK、JRE、JVM三者间的关系

  JDK(Java Development Kit)是针对Java开发员的产品,是整个Java的核心,包括了Java运行环境JRE、Java工具和Java基础类库。Java Runtime Environment(JRE)是运行JAVA程序所必须的环境...

张德德
2014/02/28
0
0
JNA调用DLL函数遇到的几个问题

最近一个JSP项目需要用到分词模块,而分词模块实用C++写成的DLL库。于是上网搜各种方法,最后选择了JNA作为JSP调用DLL的工具。 JNA(Java Native Access )提供一组Java工具类用于在运行期动...

雷霄骅
2013/09/30
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

CentoOS6.6安装netcat

CentOS下安装netcat 使用zookeeper过程中,需要监控集群状态。在使用四字命令时(echo conf | nc localhost 2181),报出如下错误:-bash: netcat: command not found。 我的系统是CentOS 6....

ghou-靠墙哭
8分钟前
0
0
es6之解构赋值巧用

ES6 允许按照一定模式,从数组、对象等中提取值,对变量进行赋值,这被称为解构赋值。 如何进行解构赋值我这里就不赘述,本篇文章主要是将解构赋值的巧妙使用之处。 1、交互变量的值 常用交互...

秋季长青
13分钟前
0
0
Elasitcsearch High Level Rest Client学习笔记(三)批量api

Bulk Request BulkRequest可以在一起从请求执行批量添加、更新和删除,至少需要添加一个操作 BulkRequest request = new BulkRequest(); //创建BulkRequestrequest.add(new IndexRequest("...

木子SMZ
17分钟前
0
0
mybatis-dynamic sql

OGNL expressions if 判断是否存在值 <select id="findActiveBlogLike" resultType="Blog"> SELECT * FROM BLOG WHERE state = ‘ACTIVE’ <if test="title != null"> AND title like #{tit......

writeademo
24分钟前
0
0
社交系统ThinkSNS+ V1.8.3更新播报

     研发发布版本号:1.8.3   本次版本于2018年7月16日发布   本次发布类型:新增功能、细节调整与优化   社交系统ThinkSNSPlus更新体验:请于官网下载/安装最新版或联系QQ35159...

ThinkSNS账号
28分钟前
0
0
教育思考:选择编程是一场父母和孩子的和解[图]

教育思考:选择编程是一场父母和孩子的和解[图]: 之前有个很热的段子是这样讲的:深夜十点的时候,某小区一女子大声喊叫“什么关系?啊?!到底什么关系?你说!”最后发现原来是一位妈妈陪...

原创小博客
28分钟前
0
0
X64汇编之指令格式解析

最近由于项目组内要做特征码搜索的东西,便于去Hook一些未导出函数,你懂得...于是就闲着学习了一下x86/x64的汇编指令格式。x86的汇编指令格式请参照http://bbs.pediy.com/showthread.php?t...

simpower
31分钟前
0
0
rust 语法概要(只适合不熟悉时快速查阅使用,不适合理解其精髓。未完待续)

注意:本内容只适合快查,不适合理解精髓。精髓请研读 https://kaisery.github.io/trpl-zh-cn/foreword.html 基本数据类型 i8,i16,i32,i64,i128 u8,u16,u32,u64,u128 f32,f64 char bool:true...

捍卫机密
34分钟前
0
0
JS中严格模式和非严格模式

1,使用 严格模式的使用很简单,只有在代码首部加入字符串 "use strict"。必须在首部即首部指其前面没有任何有效js代码除注释,否则无效 2.注意事项 (1)不使用var声明变量严格模式中将不通...

AndyZhouX
34分钟前
0
0
Nginx配置error_page 404 500等自定义的错误页面

Nginx 做web server时, 开发中发现有时候的网站代码有错误,我们需要跳转到一个指定内容的错误页面: 1. 在nginx.conf配置文件上加上一句: fastcgi_intercept_errors on; 2. 服务中加上: er...

MichaelShu
37分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部