随笔 - 19  文章 - 0  trackbacks - 0
<2012年8月>
2930311234
567891011
12131415161718
19202122232425
2627282930311
2345678

常用链接

留言簿

随笔档案

搜索

  •  

最新评论

阅读排行榜

评论排行榜

第一:

package com.javami.kudy.javaapi1.StringStudy;

public class StringDemo {
    /*面试题:
     * 1.Stirng s = "abc" String s = new String("abc"); //有什么区别?
     * 2.String s = new String("abc"); 创建了几个对象 2个(池里没有)或1个(池里有了),
     * 3.String s = "a" + "b" + "c" + "d"; 创建了几个对象? 创建了1个对象
     * 4.String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;  s3=="ab"?
     */
    
    public static void main(String[]args)
    {
        /*
         * 1.String池,由于字符串操作很频繁.java针对String对象提供了缓冲池
         * s1首先会在缓冲池里面看一下有没有"abc" 如果没有的.那么把对象创建的引用返回给s1
         * 当s2开始执行.会检查缓冲池里面有没有.如果有的.直接把对象的地址返回给s2 .所以是相等的.。
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);
        */
        
        /*
        String s1 = "abc";
        String s2 = new String(s1); 
        outcome : false
        s2在堆内存中创建了一个对象(把地址返回来~),并且在堆内存里面的缓冲池里面创建一个"abc"(这个是对象里面的一个拷贝副本)
        做java的日常维护.所以那么这两个地址一比较.就会不相等..
        */
        
        /*
        String s1 = "a"+"b"+"c";
        String s2 ="abc";
        outCome = "true";
        因为java编译器有个合并已知量的功能,在编译阶段"a"+"b"+"c" 合并为"abc"并且保存在缓冲池里面
        所以s2在检测缓冲池里面.检测到已经有了.直接把对象的引用所返回来.那么证明了s1  s2 是同一个地址/所以比较出来为true
        */
        
        /*
        String s1 = new String("abc");
        String s2 = new String("abc");
        这两个里面创建了多少个对象呢?
        解答:  首先会在堆内存中创建一个对象.在检测池里面有没有,没有也在了缓冲池里面创建了一个.做日常的维护
        s2也会在堆内存中创建一个对象.这时候检测到池里面已经有了.所以就不再创建/
        说百了也就是3个..
        一般面试简单的就直接说:2个就可以.
        */
        
        /*
         * String 是一个常量,是不能改变的量
         * 内部实现:
         * StringBuilder sb = new StringBuilder(s1);
         * sb.append(s2);
         * s3 = sb.toString(); //转换回字符串
         * 返回调用方法的都是创建一个对象的
         * 
         */
        String s1 = "a";
        String s2 = "b";
        String s3 = s1 + s2;
        System.out.println(s3=="ab"); //直接返回一个flase
        
    }

}

第二:

package com.javami.kudy.javaapi1.StringStudy;

import java.io.UnsupportedEncodingException;

public class DecodeTest {
    
    /*
     * 解码: 用错误的码再变回来.然后用正确的编码方式就可以
     * 编码错误: 没办法,神仙也救不了
     */
    public static void main(String[]args) throws UnsupportedEncodingException
    {
        String str1 = "中国人";  //使用gb2312编码
        // 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
        byte[] newbyte = str1.getBytes();
        
        String str2 = new String(newbyte);
        System.out.println(str2);
        
        
        String str3 = new String(newbyte,"iso-8859-1");
        //System.out.println(str3);编码的信息出错
        newbyte = str3.getBytes("iso-8859-1");    
        String str4 = new String(newbyte);
        System.out.println(str4);
        
        byte[]new1 = str1.getBytes("iso-8859-1");
        //一开始编码的信息就出错!因为我的计算机根本就没有这个编码
        String s6 = new String(new1);
        new1 = s6.getBytes("iso-8859-1");
        String st7 = new String(new1);
        System.out.println(st7);
    }
}

第三:

package com.javami.kudy.javaapi1.StringStudy;

public class StringTest {
    /*String 为什么要重写toString()方法呢?
        解答:因为在String如果不重写Object的toString方法.那么直接复用父类的方法.打印出的是对象.
        这显然不是String想要得到的结果
     */
        public static void main(String[]args) 
        {
            String s1 = "kudy";
            System.out.println(s1.charAt(3)); //索引是从零开始\
            String s2 ="abcde";
            String s3 = "aBcddddd";
            System.out.println(s2.compareToIgnoreCase(s3));
            
            String s4 = "abc";
            String s5 = "def";
            System.out.println((s4.concat(s5)).toString());
            
            boolean is = s4.contains(s5);
            System.out.println(is);
            
            String fileName = "Demo.jdk";
            if(fileName.endsWith(".java"))
                    System.out.println("您是java文件");
            
            String s6 = "cnabcdbvklabcjdhfabcdhla";
            int newint = s6.indexOf("abc",0);  //注意:索引是从零开始
            System.out.println(newint);
            
            String s7 = "abc";
            String s8 = new String("abc");
            s8.intern();
            System.out.println(s7 == s8);
            
            String s9 = "cascascacvdfdjkgksd";
            int num = s9.lastIndexOf("k",s9.length()-1);
            System.out.println(num);
            
            String s10 = "abc";
            String s11 = s10.replace("abc","***");
            System.out.println(s11);
            
            String s12 = "hello.java";
            String s13 = s12.replace("java","jdk" );
            System.out.println(s13);
            
            
            /*
             * 把有逗号的内容去掉。
             */
            String s14 = "ab,cd,ef";
            String [] s15 = s14.split(",");
            for(String num1 : s15)
                    System.out.print(num1);
            
            String s16 = "abcbsbdasdas";
            char[] newchar = s16.toCharArray();
            for(char num2 : newchar)
                    System.out.print(num2);
            System.out.println();
            
            /*
             * 但注意中间的是不能去掉的~~
             */
            String s17 = "   abc      def     ";
            String s18 = s17.trim();
            System.out.println(s18);
        }
}

第四:

  1 package com.javami.kudy.javaapi1.StringStudy;
  2 
  3 import java.io.IOException;
  4 
  5 public class StringUtil {
  6     private StringUtil(){} //私有化
  7     
  8     /* 查找子字符串在字符串中出现的位置 例:“ab”在"habjklabljhlabhjdjfla"出现的位置为:1 6  12 
  9      * 思路:
 10      * 1.定义一个StringBuilder容器,用于存储位置,定义一个pos变量记住出现的位置,初始值为0
 11      * 2.定义一个while循环,查找子串出现的位置
 12      * 3.调用indexOf方法,从起始位置开始查找出子串首次出现的位置
 13      * 4.如果pos为-1,说明没找到,应该结束循环
 14      * 5.将位置存入StringBuilder容器,再加一个逗号分隔
 15      * 6.从找到的位置加上子串的长度作为新的起始位置,
 16      * 7.循环结束,将StringBuffer转为String字符串,调用split方法以逗号进行分隔,获得了String数组
 17      * 8.准备一个新的int数组,长度和String数组一样,遍历String数组,将每个元素转为int存入int数组
 18      */
 19     public static int[]findIndexOfSubstr(String str, String substr)
 20     {
 21         StringBuilder sb = new StringBuilder();
 22         int pos = 0;
 23         while(true)
 24         {
 25              pos = str.indexOf(substr,pos);
 26              if(pos ==-1)
 27                  break;
 28              sb.append(pos+",");
 29              pos+=substr.length(); //pos假设找ab 找到1 + 2 等于三.刚好从第三个开始找~
 30         }
 31         if(sb.length() == 0) //容器什么都没有!
 32             return null;  //一个都找不到
 33         String s = sb.toString(); //转换成字符串形式
 34         String[] parts = s.split(",");
 35         int[] arr = new int[parts.length];
 36         for(int i=0; i<parts.length; i++)
 37         {
 38             arr[i] = Integer.parseInt(parts[i]);
 39         }
 40         return arr;
 41     }
 42     
 43     /*
 44      * 设计一个方法,读取键盘输入的一行(只支持英文字母)
 45      * 提示:System.in.read()读取键盘上的一个字符
 46      * 思路: 
 47      * 1.定义一个容器StringBuilder容器
 48      * 2.定义一个while循环,循环读取键盘.
 49      * 3.如果读到回车或者\n 就跳出循环
 50      * 4.存入StringBuilfer容器中
 51      * 5.循环结束,返回一个toString转换为字符串
 52      */
 53         public static String readLine() throws IOException
 54         {
 55             StringBuilder sb = new StringBuilder();
 56             while(true)
 57             {
 58                 int ch = System.in.read();
 59                 if(ch == '\r')  //如果回车 跳出去
 60                     continue;
 61                 if(ch == '\n')  //等上面的执行完毕.再来
 62                     break;
 63                 sb.append((char)ch);
 64             }
 65             return sb.toString(); //转换成字符串
 66         }
 67         
 68         /*
 69          * *将给定的字节数组截取一部分,进行解码,要求输出完整的汉字,例如:"abc中国人"截取6个 输出的是abc中
 70          * 思路:
 71          *     1.遍历数组被截取的部分,
 72          * 2.判断正负数,统计负数个数为count
 73          * 3.判断count的奇偶,奇数减去1,偶数不变
 74          * 4.解码
 75          * 汉字是占了2个字节?我们怎么判断它是汉字呢?
 76          * 汉字的第一位字节保证是负数!第二个是正数
 77          * 
 78          */
 79         public static String decode(byte[]buf, int len)
 80         {
 81             int count = 0;
 82             for(int i=0; i<buf.length;i++)
 83                 if(buf[i]<0)
 84                         count++; //如果第一个字节是负数的.是代表汉字马上来到.咱们+1
 85             if(count % 2 == 1)
 86                 len--;
 87             return new String(buf,0,len);
 88             /*程序流程图: 咱们输入一个buf   len = 5
 89              * for 执行5次
 90              * 因为一个汉字是占了2个字节.而第一个字节保证是负数
 91              * 如果 buf[i]里面的是负数的 count +1 = 1
 92              * 如果   % 2  等于1代表的是:   咱们len 传递进来的就减去一个字节.
 93              * 
 94              */
 95         }
 96         
 97         public static String decodeBYGBK(byte[]buf,int len)
 98         {
 99             boolean b = false; 
100             for(int i=0; i<buf.length; i++)
101                 if(b)
102                     b = false;
103                 else if(buf[i]<0)
104                     b = true;
105             if(b)
106                 len --;
107             return new String(buf,0,len);
108             
109         }
110         
111         /*
112          * 查找一个字符串出现次数最多的字符     abvjdabahabballfja   出现次数最多的为:a  6
113          * 思路:
114          * 1.调用toCharArray字符串把字符串转换成字符数组
115          * 2.定义max,用于记住出现最多字符的次数,定义一个maxChar记住出现最多的字符
116          * 3.定义一个循环,每次循环都统计一个字符出现最多的次数,每次让次数和max比.谁最大就换,结束条件。当长度的数组
117          * 为零
118          * 4.定义一个count,记住本次统计字符的次数
119          * 5.循环遍历数组,统计第一个字符出现的次数
120          * 6.让次数和max比,如果max大,让max记住它的次数,让maxchar记住当前的字符
121          * 7.将当前的字符从数组中删除
122          * ------
123          * 将此字符串转换为一个新的字符数组。
124          */
125 
126         public static char searchMaxChar(String str)
127         {
128             char[] buf = str.toCharArray();
129             int max = 0;
130             char maxChar = 0;
131             while(buf.length>0)
132             {
133                 int count = 0; //个数等于0
134                 char firstChar = buf[0];
135                 for(char c : buf)
136                     if(c ==firstChar)
137                         count++;
138                 if(count>max) //max 已经是默认记住上一个的值!
139                 {
140                     max = count;
141                     maxChar = firstChar; //如果你是最多的就让给你~~
142                 }
143                 //把当前的字符删除!
144                 buf = deleteChar(buf,firstChar,count);
145             }
146             return maxChar;
147         }
148 
149         private static char[] deleteChar(char[] buf, char firstChar, int count)
150         {
151             char[]arr = new char[buf.length-count];
152             int pos = 0;
153             for(int i=0; i<buf.length; i++)
154             {
155                 if(buf[i]==firstChar)
156                         continue;
157                 arr[pos++] = buf[i];
158             }
159             return arr;
160         }
161         /* 查找两个字符串中的最大子串  jflwertyakjfa;l    fjdlkwertyjf;ajf 最大子串:werty
162          * 1.判断出两个字符串的长短,找出较长的和较短的
163          * 2.循环遍历较短的字符串的所有子串,由长到短遍历
164          *         定义一个循环,每次遍历一种长度的子串,将i作为长度,i的取值: length~1
165          *         定义一个内层循环,具体遍历某一种长度的子串,j做为子串的开始位置, j取值:0~length-i
166          *         截取子串,substring  起始位置:j  结束位置:j+i
167          * 3.每次变量,都判断子串是否为较长的字符串的子串,如果是,直接返回
168          * 4.循环结束,依然没有返回,说明没有相同子串,返回null
169          */
170         public static String searchMaxSubStr(String s1, String s2) 
171         {
172             String longStr = s1.length() > s2.length() ? s1 : s2;
173             String shortStr = s1.length() > s2.length() ? s2 : s1; 
174             for(int i=shortStr.length(); i>0; i--)
175             {
176                 for(int j=0;j<shortStr.length()-i+1;j++)
177                 {
178                     String sub = shortStr.substring(j, j+i); //例如: abcd 放到sub里面去
179                     //abcd abc ab  a 和它里面的做一个对比  
180                     //当且仅当此字符串包含指定的 char 值序列时,返回 true。 
181                     if(longStr.contains(sub)) 
182                         //判断长的字符串里面是否包含这个
183                         return sub; //如果包含直接返回.没有包含
184                 }
185             }
186             return null;
187         }
188 }
189 
190 
191 ----------------------
192 
193 package com.javami.kudy.javaapi1.StringStudy;
194 
195 public class StringUtilTest {
196         public static void main(String[]args) throws Exception
197         {
198             /*
199             String str = "dsdcvcvxvczxbedfaacff";
200             String substr = "y";
201             //遍历a 出现的位置
202             int[]arr =  StringUtil.findIndexOfSubstr(str, substr);
203             if(arr ==null)
204             {
205                 System.out.println("找不到!");
206                 return ;
207             }
208             for(int num : arr)
209             {
210                     System.out.print(num+" ");
211             }
212             System.out.println();
213             
214             */
215             /*
216              * 再输入byte的时候就结束,不断的去读
217 
218             while(true)
219             {
220                 String str2 = StringUtil.readLine();
221                 if("bye".equals(str2))
222                     break;
223                 System.out.println(str2);
224             }
225             System.out.println("程序结束");    
226             */
227             byte[] buf = "abc中国人".getBytes();
228             //String s3 = StringUtil.decode(buf, 3);
229             String s3 = StringUtil.decodeBYGBK(buf, 5);
230             System.out.println(s3);
231             
232             char maxChar = StringUtil.searchMaxChar("dasfasdfaaaaaaaasfgdagfafgsad");
233             System.out.println(maxChar);
234             
235             String s33 = "jflwertyakjfa;l";
236             String s44 = "fjdlkwertyjf;ajf";
237             String s55 =StringUtil.searchMaxSubStr(s33,s44);
238             System.out.print(s55);
239         }
240 
241 }
posted on 2012-08-07 01:07 、小细 阅读(200) 评论(0)  编辑  收藏

只有注册用户登录后才能发表评论。


网站导航: