1. package taotao.montao.demo.util; 
    2.  
         
  2.  
    3.  
         
  3. /** 
    4.  
         
  4.  * 获取文章的字数或则字符数 
    5.  
         
  5.  * @author montao 
    6.  
         
  6.  */ 
    7.  
         
  7. public class StatWordCount { 
    8.  
         
  8.      
    9.  
         
  9.     private final char[] CHS = { 
          ',','；','!','.','!','?',';','+','，','？','！','/'};  //符号数组 
    10.  
         
  10.      
    11.  
         
  11.     private final char[] CHN = { 
          '\r','\n'}; //转义符数组 
    12.  
         
  12.      
    13.  
         
  13.     private final char[] SPACE = { 
          ' ','　'}; //空格的数组(前半角，后全角) 
    14.  
         
  14.      
    15.  
         
  15.     /** 
    16.  
         
  16.      * 根据指定条件来筛选文章的字数 
    17.  
         
  17.      * @param wordContent  文章内容 
    18.  
         
  18.      * @param compriseInterpunction  是否包含指定字符 
    19.  
         
  19.      * @param compriseSpace  是否包含空格 
    20.  
         
  20.      * @return 返回文章经过指定筛选后的长度 
    21.  
         
  21.      */ 
    22.  
         
  22.     public int getWordCount(String wordContent,boolean compriseInterpunction,boolean compriseSpace) 
    23.  
         
  23.     { 
    24.  
         
  24.         if(wordContent==null){ 
    25.  
         
  25.             return 0; 
    26.  
         
  26.         }else if(wordContent.length()==0){ 
    27.  
         
  27.             return 0;  
    28.  
         
  28.         }else{ 
    29.  
         
  29.             //既要包含符号又要包含空格 
    30.  
         
  30.             if(compriseInterpunction && compriseSpace){ 
    31.  
         
  31.                 //清除转义符 
    32.  
         
  32.                 String regex = "["+new String(CHN)+"]"; 
    33.  
         
  33.                 wordContent = wordContent.replaceAll(regex," "); 
    34.  
         
  34.                 return this.getWordCount(wordContent); 
    35.  
         
  35.             } 
    36.  
         
  36.             //不包含符号包含空格 
    37.  
         
  37.             else if(!compriseInterpunction && compriseSpace){ 
    38.  
         
  38.                 //使用正则表达式去掉指定的符号和转义符 
    39.  
         
  39.                 String regex1 = "["+new String(CHN)+"]"; 
    40.  
         
  40.                 String regex2 = "["+new String(CHS)+"]"; 
    41.  
         
  41.                 wordContent = wordContent.replaceAll(regex1," "); 
    42.  
         
  42.                 wordContent = wordContent.replaceAll(regex2," "); 
    43.  
         
  43.                 return this.getWordCount(wordContent); 
    44.  
         
  44.             } 
    45.  
         
  45.             //包含指定符号不包含空格 
    46.  
         
  46.             else if(compriseInterpunction && !compriseSpace){ 
    47.  
         
  47.                 //使用正则表达式去掉空格和转义符 
    48.  
         
  48.                 String regex1 = "["+new String(CHN)+"]"; 
    49.  
         
  49.                 String regex2 = "["+new String(SPACE)+"]"; 
    50.  
         
  50.                 wordContent = wordContent.replaceAll(regex1," "); 
    51.  
         
  51.                 wordContent = wordContent.replaceAll(regex2," "); 
    52.  
         
  52.                 return this.getWordCount(wordContent); 
    53.  
         
  53.             } 
    54.  
         
  54.             //空格和指定符号都不包含 
    55.  
         
  55.             else{ 
    56.  
         
  56.                 //使用正则表达式去掉空格,指定符号和转义符 
    57.  
         
  57.                 String regex1 = "["+new String(CHN)+"]"; 
    58.  
         
  58.                 String regex3 = "["+new String(CHS)+"]"; 
    59.  
         
  59.                 String regex2 = "["+new String(SPACE)+"]"; 
    60.  
         
  60.                 wordContent = wordContent.replaceAll(regex1," "); 
    61.  
         
  61.                 wordContent = wordContent.replaceAll(regex2," "); 
    62.  
         
  62.                 wordContent = wordContent.replaceAll(regex3," "); 
    63.  
         
  63.                 return this.getWordCount(wordContent); 
    64.  
         
  64.             } 
    65.  
         
  65.         } 
    66.  
         
  66.     } 
    67.  
         
  67.      
    68.  
         
  68.     /** 
    69.  
         
  69.      * 返回文章中的字数 
    70.  
         
  70.      * @param wordCount 文章内容 
    71.  
         
  71.      * @return 
    72.  
         
  72.      */ 
    73.  
         
  73.     @SuppressWarnings("unused") 
    74.  
         
  74.     private int getWordCount(String wordContent){ 
    75.  
         
  75.         int count = 0; 
    76.  
         
  76.         if(wordContent==null){ //判断是否为null,如果为null直接返回0 
    77.  
         
  77.             count = 0; 
    78.  
         
  78.         }else if(wordContent.length()==0){ //判断是否为空,如果为空直接返回0 
    79.  
         
  79.             count = 0; 
    80.  
         
  80.         }else{ //判断获取字数 
    81.  
         
  81.             wordContent = wordContent.trim(); //清空空格 
    82.  
         
  82.             //临时变量 
    83.  
         
  83.             String s4 = ""; 
    84.  
         
  84.             String s3 = ""; 
    85.  
         
  85.             String s2 = ""; 
    86.  
         
  86.             String s1 = ""; 
    87.  
         
  87.             boolean bb = false; 
    88.  
         
  88.             if(wordContent.length()>0){ 
    89.  
         
  89.                 s4 = String.valueOf(wordContent.charAt(wordContent.length()-1)); 
    90.  
         
  90.             } 
    91.  
         
  91.             for(int i=0;i<wordContent.length();i++){ 
    92.  
         
  92.                 s3 = String.valueOf(wordContent.charAt(i)); 
    93.  
         
  93.                 int num = s3.getBytes().length; 
    94.  
         
  94.                 if(s3.hashCode()==32||s3.getBytes().length==2){ 
    95.  
         
  95.                     bb=true; 
    96.  
         
  96.                 }if(num==2){ 
    97.  
         
  97.                     count++; 
    98.  
         
  98.                 }else{ 
    99.  
         
  99.                         if(i+1<wordContent.length()){ 
    100.  
         
  100.                             s1 = String.valueOf(wordContent.charAt(i+1)); 
    101.  
         
  101.                             if((s1.hashCode()==32 && (s3.hashCode()!=32)) || ((s1.getBytes().length==2)&& (s3.hashCode()!=32))){ 
    102.  
         
  102.                                 count++; 
    103.  
         
  103.                             } 
    104.  
         
  104.                         } 
    105.  
         
  105.                 } 
    106.  
         
  106.             } 
    107.  
         
  107.             if(!bb){ 
    108.  
         
  108.                 count++; 
    109.  
         
  109.             }else{ 
    110.  
         
  110.                 if(s4.getBytes().length==1){ 
    111.  
         
  111.                     count++; 
    112.  
         
  112.                 } 
    113.  
         
  113.             } 
    114.  
         
  114.         } 
    115.  
         
  115.         return count; 
    116.  
         
  116.     } 
    117.  
         
  117.      
    118.  
         
  118.     /** 
    119.  
         
  119.      * 根据条件来获取文章的字符数 
    120.  
         
  120.      * @param wordContent 文章内容 
    121.  
         
  121.      * @param compriseInterpunction 是否包含指定符号 
    122.  
         
  122.      * @param compriseSpace 是否包含空格 
    123.  
         
  123.      * @return 返回字符长度 
    124.  
         
  124.      */ 
    125.  
         
  125.     public int getWordCharacter(String wordContent,boolean compriseInterpunction,boolean compriseSpace) 
    126.  
         
  126.     { 
    127.  
         
  127.         //既要包含符号又要包含空格 
    128.  
         
  128.         if(compriseInterpunction && compriseSpace){ 
    129.  
         
  129.             //清除转义符 
    130.  
         
  130.             String regex = "["+new String(CHN)+"]"; 
    131.  
         
  131.             wordContent = wordContent.replaceAll(regex,""); 
    132.  
         
  132.             //首部的空格不算 
    133.  
         
  133.             wordContent = wordContent.replaceAll("^\\s+",""); 
    134.  
         
  134.             return wordContent.length(); 
    135.  
         
  135.         }//不包含符号包含空格 
    136.  
         
  136.         else if(!compriseInterpunction && compriseSpace){ 
    137.  
         
  137.             //首部的空格不算 
    138.  
         
  138.             wordContent = wordContent.replaceAll("^\\s+",""); 
    139.  
         
  139.             //使用正则表达式去掉指定的符号和转义符 
    140.  
         
  140.             String regex1 = "["+new String(CHN)+"]"; 
    141.  
         
  141.             String regex2 = "["+new String(CHS)+"]"; 
    142.  
         
  142.             wordContent = wordContent.replaceAll(regex1,""); 
    143.  
         
  143.             wordContent = wordContent.replaceAll(regex2,""); 
    144.  
         
  144.             return wordContent.length(); 
    145.  
         
  145.         }//包含指定符号不包含空格 
    146.  
         
  146.         else if(compriseInterpunction && !compriseSpace){ 
    147.  
         
  147.             //使用正则表达式去掉空格和转义符 
    148.  
         
  148.             String regex = "["+new String(SPACE)+"]"; 
    149.  
         
  149.             wordContent = wordContent.replaceAll(regex," "); 
    150.  
         
  150.             return this.getNoSpaceCount(wordContent); 
    151.  
         
  151.         }//空格和指定符号都不包含 
    152.  
         
  152.         else{ 
    153.  
         
  153.             //使用正则表达式去掉指定符号 
    154.  
         
  154.             String regex1 = "["+new String(CHS)+"]"; 
    155.  
         
  155.             String regex2 = "["+new String(SPACE)+"]"; 
    156.  
         
  156.             wordContent = wordContent.replaceAll(regex1," "); 
    157.  
         
  157.             wordContent = wordContent.replaceAll(regex2," "); 
    158.  
         
  158.             return this.getNoSpaceCount(wordContent); 
    159.  
         
  159.         } 
    160.  
         
  160.     } 
    161.  
         
  161.  
    162.  
         
  162.     /** 
    163.  
         
  163.      * 获取文章中非空格的字符总数 
    164.  
         
  164.      * @param wordContent 文章内容 
    165.  
         
  165.      * @return 
    166.  
         
  166.      */ 
    167.  
         
  167.     private int getNoSpaceCount(String wordContent) { 
    168.  
         
  168.         int spaceCount = 0; 
    169.  
         
  169.         if(wordContent==null) 
    170.  
         
  170.         { 
    171.  
         
  171.             spaceCount = 0; 
    172.  
         
  172.         }else if(wordContent.length()==0) 
    173.  
         
  173.         { 
    174.  
         
  174.             spaceCount = 0; 
    175.  
         
  175.         }else 
    176.  
         
  176.         { 
    177.  
         
  177.             //替换首部的 
    178.  
         
  178.             wordContent = wordContent.replaceAll("^\\s+",""); 
    179.  
         
  179.             wordContent = wordContent.replaceAll(" ",""); 
    180.  
         
  180.             //使用正则替换转义符 
    181.  
         
  181.             String regex = "["+new String(CHN)+"]"; 
    182.  
         
  182.             wordContent = wordContent.replaceAll(regex,""); 
    183.  
         
  183.             spaceCount = wordContent.length(); 
    184.  
         
  184.         } 
    185.  
         
  185.         return spaceCount; 
    186.  
         
  186.     } 
    187.  
         
  187. } 
    188.