javase_10(String类日常操作)

第一:

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);
        }
}

第四:

package com.javami.kudy.javaapi1.StringStudy;
 
 import java.io.IOException;
 
 public class StringUtil {
     private StringUtil(){} //私有化
     
     /* 查找子字符串在字符串中出现的位置 例：“ab”在"habjklabljhlabhjdjfla"出现的位置为：1 6  12 
      * 思路：
      * 1.定义一个StringBuilder容器，用于存储位置，定义一个pos变量记住出现的位置，初始值为0
      * 2.定义一个while循环，查找子串出现的位置
      * 3.调用indexOf方法，从起始位置开始查找出子串首次出现的位置
      * 4.如果pos为-1，说明没找到，应该结束循环
      * 5.将位置存入StringBuilder容器，再加一个逗号分隔
      * 6.从找到的位置加上子串的长度作为新的起始位置，
      * 7.循环结束，将StringBuffer转为String字符串，调用split方法以逗号进行分隔，获得了String数组
      * 8.准备一个新的int数组，长度和String数组一样，遍历String数组，将每个元素转为int存入int数组
      */
     public static int[]findIndexOfSubstr(String str, String substr)
     {
         StringBuilder sb = new StringBuilder();
         int pos = 0;
         while(true)
         {
              pos = str.indexOf(substr,pos);
              if(pos ==-1)
                  break;
              sb.append(pos+",");
              pos+=substr.length(); //pos假设找ab 找到1 + 2 等于三.刚好从第三个开始找~
         }
         if(sb.length() == 0) //容器什么都没有！
             return null;  //一个都找不到
         String s = sb.toString(); //转换成字符串形式
         String[] parts = s.split(",");
         int[] arr = new int[parts.length];
         for(int i=0; i<parts.length; i++)
         {
             arr[i] = Integer.parseInt(parts[i]);
         }
         return arr;
     }
     
     /*
      * 设计一个方法，读取键盘输入的一行（只支持英文字母）
      * 提示：System.in.read()读取键盘上的一个字符
      * 思路： 
      * 1.定义一个容器StringBuilder容器
      * 2.定义一个while循环,循环读取键盘.
      * 3.如果读到回车或者\n 就跳出循环
      * 4.存入StringBuilfer容器中
      * 5.循环结束,返回一个toString转换为字符串
      */
         public static String readLine() throws IOException
         {
             StringBuilder sb = new StringBuilder();
             while(true)
             {
                 int ch = System.in.read();
                 if(ch == '\r')  //如果回车 跳出去
                     continue;
                 if(ch == '\n')  //等上面的执行完毕.再来
                     break;
                 sb.append((char)ch);
             }
             return sb.toString(); //转换成字符串
         }
         
         /*
          * *将给定的字节数组截取一部分，进行解码，要求输出完整的汉字，例如："abc中国人"截取6个 输出的是abc中
          * 思路：
          *     1.遍历数组被截取的部分,
          * 2.判断正负数，统计负数个数为count
          * 3.判断count的奇偶，奇数减去1，偶数不变
          * 4.解码
          * 汉字是占了2个字节?我们怎么判断它是汉字呢?
          * 汉字的第一位字节保证是负数!第二个是正数
          * 
          */
         public static String decode(byte[]buf, int len)
         {
             int count = 0;
             for(int i=0; i<buf.length;i++)
                 if(buf[i]<0)
                         count++; //如果第一个字节是负数的.是代表汉字马上来到.咱们+1
             if(count % 2 == 1)
                 len--;
             return new String(buf,0,len);
             /*程序流程图： 咱们输入一个buf   len = 5
              * for 执行5次
              * 因为一个汉字是占了2个字节.而第一个字节保证是负数
              * 如果 buf[i]里面的是负数的 count +1 = 1
              * 如果   % 2  等于1代表的是：   咱们len 传递进来的就减去一个字节.
              * 
              */
         }
         
         public static String decodeBYGBK(byte[]buf,int len)
         {
             boolean b = false; 
             for(int i=0; i<buf.length; i++)
                 if(b)
                     b = false;
                 else if(buf[i]<0)
                     b = true;
             if(b)
                 len --;
             return new String(buf,0,len);
             
         }
         
         /*
          * 查找一个字符串出现次数最多的字符     abvjdabahabballfja   出现次数最多的为:a  6
          * 思路：
          * 1.调用toCharArray字符串把字符串转换成字符数组
          * 2.定义max，用于记住出现最多字符的次数，定义一个maxChar记住出现最多的字符
          * 3.定义一个循环，每次循环都统计一个字符出现最多的次数，每次让次数和max比.谁最大就换,结束条件。当长度的数组
          * 为零
          * 4.定义一个count，记住本次统计字符的次数
          * 5.循环遍历数组，统计第一个字符出现的次数
          * 6.让次数和max比，如果max大，让max记住它的次数，让maxchar记住当前的字符
          * 7.将当前的字符从数组中删除
          * ------
          * 将此字符串转换为一个新的字符数组。
          */
 
         public static char searchMaxChar(String str)
         {
             char[] buf = str.toCharArray();
             int max = 0;
             char maxChar = 0;
             while(buf.length>0)
             {
                 int count = 0; //个数等于0
                 char firstChar = buf[0];
                 for(char c : buf)
                     if(c ==firstChar)
                         count++;
                 if(count>max) //max 已经是默认记住上一个的值！
                 {
                     max = count;
                     maxChar = firstChar; //如果你是最多的就让给你~~
                 }
                 //把当前的字符删除！
                 buf = deleteChar(buf,firstChar,count);
             }
             return maxChar;
         }
 
         private static char[] deleteChar(char[] buf, char firstChar, int count)
         {
             char[]arr = new char[buf.length-count];
             int pos = 0;
             for(int i=0; i<buf.length; i++)
             {
                 if(buf[i]==firstChar)
                         continue;
                 arr[pos++] = buf[i];
             }
             return arr;
         }
         /* 查找两个字符串中的最大子串  jflwertyakjfa;l    fjdlkwertyjf;ajf 最大子串：werty
          * 1.判断出两个字符串的长短，找出较长的和较短的
          * 2.循环遍历较短的字符串的所有子串，由长到短遍历
          *         定义一个循环，每次遍历一种长度的子串，将i作为长度，i的取值: length~1
          *         定义一个内层循环，具体遍历某一种长度的子串，j做为子串的开始位置， j取值：0~length-i
          *         截取子串，substring  起始位置:j  结束位置:j+i
          * 3.每次变量，都判断子串是否为较长的字符串的子串，如果是，直接返回
          * 4.循环结束，依然没有返回，说明没有相同子串，返回null
          */
         public static String searchMaxSubStr(String s1, String s2) 
         {
             String longStr = s1.length() > s2.length() ? s1 : s2;
             String shortStr = s1.length() > s2.length() ? s2 : s1; 
             for(int i=shortStr.length(); i>0; i--)
             {
                 for(int j=0;j<shortStr.length()-i+1;j++)
                 {
                     String sub = shortStr.substring(j, j+i); //例如： abcd 放到sub里面去
                     //abcd abc ab  a 和它里面的做一个对比  
                     //当且仅当此字符串包含指定的 char 值序列时，返回 true。 
                     if(longStr.contains(sub)) 
                         //判断长的字符串里面是否包含这个
                         return sub; //如果包含直接返回.没有包含
                 }
             }
             return null;
         }
 }
 
 
 ----------------------
 
 package com.javami.kudy.javaapi1.StringStudy;
 
 public class StringUtilTest {
         public static void main(String[]args) throws Exception
         {
             /*
             String str = "dsdcvcvxvczxbedfaacff";
             String substr = "y";
             //遍历a 出现的位置
             int[]arr =  StringUtil.findIndexOfSubstr(str, substr);
             if(arr ==null)
             {
                 System.out.println("找不到！");
                 return ;
             }
             for(int num : arr)
             {
                     System.out.print(num+" ");
             }
             System.out.println();
             
             */
             /*
              * 再输入byte的时候就结束,不断的去读
 
             while(true)
             {
                 String str2 = StringUtil.readLine();
                 if("bye".equals(str2))
                     break;
                 System.out.println(str2);
             }
             System.out.println("程序结束");    
             */
             byte[] buf = "abc中国人".getBytes();
             //String s3 = StringUtil.decode(buf, 3);
             String s3 = StringUtil.decodeBYGBK(buf, 5);
             System.out.println(s3);
             
             char maxChar = StringUtil.searchMaxChar("dasfasdfaaaaaaaasfgdagfafgsad");
             System.out.println(maxChar);
             
             String s33 = "jflwertyakjfa;l";
             String s44 = "fjdlkwertyjf;ajf";
             String s55 =StringUtil.searchMaxSubStr(s33,s44);
             System.out.print(s55);
         }
 
 }