题目：编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表），
* 例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”， 截取3个字节也要是"HM"而不要出现半个中文。

1. public class Test10 {
   
2.         public static void main(String[] args) throws Exception {
   
3.                 String str = "HM程序员";
   
4.                 int num = trimGBK(str.getBytes("GBK"),3);
   
5.         System.out.println(str.substring(0,num) );
   
6.         }
   
7. 
   
8.         private static int trimGBK(byte[] buf, int n) {
   
9.                 // TODO Auto-generated method stub
   
10.                 int num = 0;
    
11.                 boolean bChineseFirstHalf = false;
    
12.                 for (int i = 0; i < n; i++)
    
13.                 {
    
14.                         if (buf[i] < 0 && !bChineseFirstHalf) {
    
15.                                 bChineseFirstHalf = true;
    
16.                         } else {
    
17.                                 num++;
    
18.                                 bChineseFirstHalf = false;
    
19.                         }
    
20.                 }
    
21.                 return num;
    
22.         }
    
23. }

复制代码

【这是一道基础测试题，我照着面试宝典上敲出来的，小弟基础不怎么好，有些代码还是看不懂，麻烦大神们附上注释。越详细越好，在此谢过！】

你如果使用substring方法的话,其实它的内部已经实现了取舍。这是我自己写的，你可以看一下：

1. /*
   
2.         需求：编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表），
   
3.                 例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”， 截取3个字节也要是"HM"而不要出现半个中文。
   
4.         分析：
   
5.                 1.要截取字符串，首先想到substring方法。
   
6.                 2.但是经过测试可知，substring方法其实，已经实现了取舍功能。
   
7.                 3.为了实现中文的自动截取，要知道中文编码GBK有如下特点：
   
8.                         中文的字节编码为负数。
   
9.                                
   
10. */
    
11. import java.lang.*;
    
12. 
    
13. class CutTest
    
14. {
    
15.         public static void main(String[] args) throws Exception
    
16.                 {
    
17.                         String str = "HM程序员";
    
18.                         byte[] b = str.getBytes("GBK");        //将字符串转变为GBK编码的字节数组
    
19.                         String str1 = trimGBK(b,3);                //调用函数获取截取后的子串
    
20.                         System.out.println(str1);
    
21.         }
    
22. 
    
23.         private static String trimGBK(byte[] buf, int num)throws Exception
    
24.                 {
    
25.                         StringBuilder s = new StringBuilder();         //使用该对象的append函数用于字符串拼接
    
26.                         for(int i=0;i<num;i++)
    
27.                         {
    
28.                                 if(buf[i]>0)        //如果大于零，说明是英文，直接加入字符串末尾
    
29.                                         s.append((char)buf[i]);
    
30.                                 else
    
31.                                 {
    
32.                                         if(buf[i]<0 && i<num-1)        //如果小于0,说明是中文，如果i<num-1，说明没到结尾，将中文加大结尾
    
33.                                         {
    
34.                                                 String str = new String(buf,i,2,"GBK");
    
35.                                                 s.append(str);
    
36.                                                 i++;
    
37.                                         }
    
38.                                 }
    
39.                         }
    
40.                         return s.toString();
    
41.         }
    
42. }

复制代码

zhaozhao 发表于 2015-1-2 18:29
你如果使用substring方法的话,其实它的内部已经实现了取舍。这是我自己写的，你可以看一下： ...

虽然下面的trimGBK方法中还是有点不太理解，不过还是要谢谢大神了:handshake

package com.itheima;
/*
编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表），
例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，
截取3个字节也要是"HM"而不要出现半个中文
*/
public class Test10 {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
        String str="HM程序员";
        //测试程序
        String newStr=splitString(str,1);
        System.out.println(newStr);
        }
   
        public static String splitString(String str,int len)
        {
                String newStr=null;
                byte[] bytes=str.getBytes();//将字符串转换成字节数组。
                if(len>=bytes.length)
                {
                        return str;
                }else
                {
                        //按照给定角标，截取一个新字符串。
                        newStr=new String(bytes,0,len);
                        //新字符串的长度。
                        int newlen=newStr.length();
                        //比较截取后的新字符串最后一个元素与原字符串最后一个元素是否相等
                        if(newlen>=2)
                        {       
                                if(newStr.charAt(newlen-1)!=str.charAt(newlen-1))
                                {   
                                        //如果新字符串最后一个元素与原字符串最后一个元素不等，则比较倒数第二个元素，如果不相等，则去掉最后两元素
                                        if(newStr.charAt(newlen-2)!=str.charAt(newlen-2))
                                        {
                                                newStr=new String(bytes,0,len-2);
                                        }else
                                        {   //如果相等，则只去掉最后一个元素。
                                                newStr=new String(bytes,0,len-1);
                                        }
                                }
                        }else{
                                //否则如果新字符串长度为1
                                if(newStr.charAt(newlen-1)!=str.charAt(newlen-1))
                                {
                                        newStr=null;
                                }
                        }
                               
                }
                return newStr;
        }
}

参看一下