Java学习笔记五 常用API对象一

常用API:字符串操作:String类,StringBuffer类,StringBulider类

字符串是最重要的数据类型之一,处理字符串也是一种语言的基本工作。

1、String类:

 public class StringDemo {
     public static void main(String[] args)
     {
         StringDemo1();
     }
     protected static void StringDemo1()
     {
         /*java中有两种创建String对象的方法:
          * 1、使用字面量,就是直接用"字符串"即可:！！！是在字符串常量池中,如果没有则创建;如果有则直接使用
          * 2、使用new:和普通对象一样在对内存中创建,！！！是两个对象,先是参数字符串对象,然后是new的一个副本
          */
         String s="abc";
         String s1="abc";
         String s2=new String("abc");
         /*由上面的创建过程可知：字面量相同,则创建的对象相同,而字面量和new方法创建的对象地址不同
          * ！！！但是String类中将equals进行重写,是比较字符串的内容而不是地址
          */
         System.out.println("s==s1是"+(s==s1));
         System.out.println("s==s2是"+(s==s2));
         System.out.println("s.equals(s2)是"+s.equals(s2));
         /*字符串字面量是常量,所以不允许改变值,
          * ！！！下面的操作是重新赋值,同样会在字符串常量池中进行查找,如果没有则会重新创建并返回地址
          */
         s="def";
         System.out.println(s);
     }

 }

String类简介

 public class StringFunction1 {

     public static void main(String[] args)
     {
         StringConstructorDemo();
         StringFunctionGet();
         StringFunctionChance();
         StringFunctionJudge();
         StringFunctionCompare();
         StringFunctionOther();
     }

     private static void StringConstructorDemo()
     {
         /*对于String类中的构造函数,常用的是将byte[]和char[]转换为String对象,并可以截取一段
          * 对于byte[]数组是使用ascii码表进行转换
          */
         byte[] arr={65,66,67,95};
         String s=new String(arr);
         System.out.println("s="+s);
         char[] arr1={'a','s','d','f','g'};
         String s1=new String(arr1,1,3);
         System.out.println("s1="+s1);
     }

     public static void StringFunctionGet() {
         String s="asdfgasd";
         //获取长度
         int length=s.length();
         System.out.println("length="+length);
         //字符串和数组类似,可以看做是包含字符的数组,同样是从0角标开始
         //获取指定角标字符
         int num=4;
         char c=s.charAt(num);    //超出长度报StringIndexOutOfBoundsException
         System.out.println("第"+num+"位角标上的字符是"+c);
         //*获取指定字符(串)出现的角标,这是一系列方法,重要
         char c1='k';
         int i=s.indexOf(c1);    //如果没有改字符(串)则返回-1
         System.out.println("第一次出现"+c1+"的角标是"+i);
         //获取子串
         String substring=s.substring(2, 6);
         System.out.println("substring=\""+substring+"\"");
     }
     public static void StringFunctionChance()
     {
         //字符串的转换:就是将字符串格式转换为其他格式

         //用切割的方式将字符串转换为字符串数组,!!!使用正则表达式规则,特殊字符需要进行转义
         String s="张三.李四.王武";
         String[] arr=s.split("\\.");
         for (int i = 0; i < arr.length; i++)
         {
             System.out.println(arr[i]);
         }
         //转换为char[]
         char[] c=s.toCharArray();
         for (int i = 0; i < c.length; i++)
         {
             System.out.println(c[i]);
         }
         //转换为byte[]，可以指定字符串的编码格式,然后获取其字节值
         s="aB中";
         byte[] b=s.getBytes();
         for (int i = 0; i < b.length; i++)
         {
             System.out.println(b[i]);
         }
         //转换为大/小写格式
         System.out.println(s.toUpperCase());
         System.out.println(s.toLowerCase());
         //转换指定位置的内容:如果找到则替换,没有则不换.返回替换后字符串
         System.out.println(s.replace("中", "中国"));
         //去除两端空格
         System.out.println("-"+"    ab c  ".trim()+"-");
         //字符串连接，将字符串的+操作封装
         System.out.println("abc".concat("kk"));
         System.out.println("abc"+"kk");
     }

     private static void StringFunctionJudge() {
         //String类的判断方法
         //判断两个字符串是否相等,使用equals(),重写了Object的该方法
         String s="abc";
         System.out.println(s+"==Abc是"+s.equals("Abc"));
         //判断两个字符串是否相等(忽略大小写)
         System.out.println("忽略大小写时,"+s+"==Abc是"+s.equalsIgnoreCase("Abc"));
                 //System.out.println(s.equals("Abc".toLowerCase()));
         s="ArrayDemo.java";
         //判断字符串中是否包含某子串
         System.out.println(s+"中包含\"demo\"是"+s.contains("Demo"));
                 //contains()其实就是将indexOf()方法返回-1的情况进行判断
         //判断字符串是否以某字串开始/结束
         System.out.println(s+"以\"Array\"开头是"+s.startsWith("Array"));
         System.out.println(s+"以\".java\"结尾是"+s.endsWith(".java"));
     }

     private static void StringFunctionCompare() {
         //比较方法
         //按字典顺序 (应该是Unicode码表)比较两个字串,即按字符进行比较,大则返回>0数,小则返回<0数,相等返回0
         System.out.println("你".compareTo("我"));
         System.out.println("abc".compareToIgnoreCase("Abc"));
     }

     private static void StringFunctionOther() {
         //这里是String类中的不常用方法
         //intern():检测字符串常量池中是否有该字符串存在,有则直接返回引用;没有则先创建在返回引用
         String s=new String("abc");                //栈中
         String s2=s.intern();                    //常量池中
         System.out.println("s==s2是"+(s==s2));    //false
     }
 }

String类常用方法示例

 public class StringTest {
     public static void main(String[] args){
         //1、字符串数组排序:和int[]排序相似,只是比较时使用的是方法而不是>或<
         String[] arr={"asd","wer","hehe","xfg","bcd","xgg"};
         StringArraySort(arr);
         printArray(arr);
         //2、检测子串在字符串中的出现次数:用indexOf()循环判断,注意该方法返回的是角标值
         String s="   aasnbafuhuus nbadiloveyouuelinbasod       ",sub="nba";
         int count=subStringCount(s,sub);
         System.out.println("count="+count);
         //3、寻找两字串中最大相同子串:就是判断大串中是否有小串,并将小串进行截取循环判断
         String s1="abweiloveyouefhur";
         String sameSubstring=sameSubstring(s,s1);
         System.out.println(s+"和"+s1+"的最大相同子串是:"+sameSubstring);
         //4、模拟trim()功能:获取第一个/最后一个非空格字符的角标进行截取
         System.out.println("-"+myTrim(s)+"-");
     }
     //1、
     public static void printArray(String[] arr){
         System.out.print("[");
         for(int i=0;i<arr.length;i++){
             if(i!=arr.length-1){
                 System.out.print(arr[i]+",");
             }else{
                 System.out.print(arr[i]);
             }
         }
         System.out.println("]");
     }

     public static void StringArraySort(String[] arr) {
         for(int i=0;i<arr.length;i++){
             for(int j=0;j<arr.length-1;j++){
                 if(arr[j].compareTo(arr[j+1])<0){
                     swap(arr,j,j+1);
                 }
             }
         }
     }
     private static void swap(String[] arr,int a,int b){
         String temp=arr[a];
         arr[a]=arr[b];
         arr[b]=temp;
     }

     //2、
     private static int subStringCount(String s,String sub) {
         int num=0;
         int slength=s.length(),sublength=sub.length();
         if(slength<sublength){
             return num;
         }
         if(s.contains(sub)){
             /*
             for (int i = 0; i <= slength-sublength;) {
                 i=s.indexOf(sub,i);
                 if(i!=-1){
                     num+=1;
                     i+=sublength;
                 }else{
                     break;
                 }
             }
             */
             int index=0;
             while((index=s.indexOf(sub))!=-1){
                 num+=1;
                 s=s.substring(index+sublength);
             }
             return num;
         }else{
             return num;
         }
     }

     //3、
     public  static String sameSubstring(String s,String s1) {
         if(s.length()<s1.length()){
             swap(s,s1);
         }
         int s1length=s1.length();
         if(s.contains(s1)){
             return s1;
         }
         String substring="";
         for (int i = s1length; i>0; i--) {
             for (int j = 0; j < s1length-i+1; j++) {
                 substring=s1.substring(j, j+i);
                 if(s.contains(substring)){
                     return substring;
                 }
             }
         }
         return substring;
     }
     private static void swap(String a,String b){
         String Temp=a;
         a=b;
         b=Temp;
     }

     //4、
     public static String myTrim(String str) {
         int indexstart=0,indexend=str.length();
         while(str.charAt(indexstart)==' '){
             indexstart++;
         }
         if(indexstart!=indexend){
             while(str.charAt(indexend-1)==' '){
                 indexend--;
             }
         }
         return str.substring(indexstart,indexend);
     }

 }

String类方法的简单应用

2、StringBuffer类:

public class StringBufferClass {
    public static void main(String[] args){
        StringBufferDemo();
        StringBufferCURDFunction();
        StringBufferOtherFunction();
        //下面是StringBuilder(也就是StringBuffer类的示例),注意看区别
        int[] arr={3,6,2,6,8,1};
        System.out.println(StringBufferTest1(arr));
        System.out.println(StringBufferTest2(arr));
    }

    private static void StringBufferDemo() {
        /*StringBuffer是一个容器,和数组不同的是
         * 1、长度可变(初始长度为16字符)：其实是在创建一(多)个16长度的数组,在将字串值复制过来,然后装入新内容
         * 2、可以存储不同类型值(注意不是所有类型:例如不包括byte)
         * 3、最终会转换为字符串类型
         * ！！！4、和String不同的是,该类可以修改字符串值而不创建新空间
         */
        StringBuffer sb=new StringBuffer();
        //创建StringBuffer对象时也可以指定长度,效率较高
        StringBuffer s1=new StringBuffer(40);
        StringBuffer s=sb.append(4);
        /* ！！！注意:有些操作返回本类对象,其实就是操作后  容器中  字符串的地址,所以两者是相等的
         * 并且该对象还可以继续进行操作,就是链式操作
         */
        System.out.println("s==sb是"+(s==sb));
        sb.append(true).append("haha");
        System.out.println(sb);
    }

    private static void StringBufferCURDFunction() {
        StringBuffer sb=new StringBuffer("i");
        //C:create,增
            //append()是向后追加
        StringBuffer s=sb.append("you");
            //insert()是在指定位置插入
        s.insert(1, "hate");
        System.out.println(s);
        //D:delete,删。注意没有清空的方法,可以用删除方法代替。
            //delete()删除指定位置,包含头,不含尾
        s.delete(5,8);
            //deleteCharAt()删除一个字符
        s.deleteCharAt(0);
        System.out.println(s);
        //R:read,查。和String的方法类似,indexOf(),charAt(),lastIndexOf()等
        //U:update:改
            //replace()替换一段字符,包含头,不含尾
        s.replace(1,4,"ove");
            //setCharAt()替换一个字符,！！！注意该方法返回void
        s.setCharAt(0, 'l');
        System.out.println(s);
    }

    private static void StringBufferOtherFunction() {
        StringBuffer s=new StringBuffer("test");
        //setLength():设置长度,长则补空字符,并修改长度属性;短则剪切,并修改长度属性。
        s.setLength(10);
        System.out.println(s);
        s.setLength(4);
        //reverse():反转字符串内容
        System.out.println(s.reverse());
    }

    /*下面两种方法看似类似,其实后者更好,
     * 因为使用+的字符串连接操作每次都会在字符串常量池中产生一个新字符串对象,浪费空间
     * 而后者是容器可修改
     */
    private static String StringBufferTest1(int[] arr) {
        String str="[";
        for (int i = 0; i < arr.length; i++) {
            if(i!=arr.length-1){
                str+=arr[i]+", ";
            }else{
                str+=arr[i]+"]";
            }
        }
        return str;
    }

    private static String StringBufferTest2(int[] arr) {
        StringBuilder sb=new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
            if(i!=arr.length-1){
                sb.append(arr[i]+", ");
            }else{
                sb.append(arr[i]+"]");
            }
        }
        return sb.toString();
    }
}

StringBuffer类和StringBuilder类

3、StringBuilder类: