day13 String method StringBuffer method 基本数据类型封装类

class StringDemo
{
    public static void main(String[] args)
    {
        String s1 = "abc";//s1是一个类类型变量。 "abc" 是一个对象。
                    //字符串最大的特点：一旦被初始化就不可以被改变。
                    
        String s2 = new String("abc");
        
        //s1 和 s2有什么区别；
        //s1 在内存中有一个对象
        //s2 在内存中有两个对象
        
        
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));//String类复写了Object类中的equal方法，该方法用于判断字符串是否相同。
    }
}

结果  false
　　  true

 
String 类适用于描述字符串事物。
那么他就提供了多个方法对字符串进行操作。

常见的操作有哪些？
 "abcd"
 
 1,获取。
    |--字符串中的包含的字符数。--字符串的长度
        int length(); 获取长度。
    |--根据位置获取位置上某个字符。
        char charAt(int index);
    |--根据字符获取该字符在字符串中位置
        int indexOf(int ch); 返回的ch在字符串中第一次出现的位置。
        int indexOf(int ch,int fromIndex);从fromIndex指定位置开始，获取ch在字符串只能怪出现的位置
        
        int indexOf(String str); 返回的str在字符串中第一次出现的位置。
        int indexOf(String str,int fromIndex);从fromIndex指定位置开始，获取str在字符串只能怪出现的位置
    
        int lastIndexOf(int ch);
    
2,判断。
    
    |--字符串是否包含某一个子串
        boolean contains(str);

　　　特殊之处：indexOf(str);可以索引第一次出现位置，如果返回-1，表示该str不在字符串中字符。
            所以也可以用于对指定字符串判断是否包含。
    |--字符串是否有内容
        boolean isEmpty();
    |--字符串是否以指定内容开头
        boolean startsWith(str);
    |--字符串是否以指定内容结束
        boolean endsWith(str);

　 |--判断字符串内容是否相同--复写了Object类中方法
        boolean quals(str);
    |--判断内容是否相同，并忽视大小写、
        boolean equalsIgnoreCase();　　

String类中判断函数的使用场景

class StringMethodDemo
{
    public static void method_is()
    {
        String str = "ArrayDemo.java";
        
        sop(str.startsWith("Array"));//判断文件名称是否是Array单词开头。
        sop(str.endsWith(".java"));//判断文件名是否是.java的文件
        sop(str.contains("Demo"));//判断文件是否包含Demo
    }
    /*
    public static void mathod_get()
    {
        String str = "abcdef";
        
        sop(str.length());
        
        sop(str.charAt(4));
        
        sop(str.indexOf('a',3));
        
    }
    */
    public static void main(String[] args)
    {
        method_is();
    }
    
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

 

3，转换
    |--将字符数组转成字符串。
        构造函数：String(char[]);
                  String(char[],offset,count);将字符数组中的一部分转成字符串。
                  
            静 态方法；
                  static String copyValueOf(charp[]);
                  copyValueOf(char[] data,int offset,int count);
    |--将字符串转成字符数组。**
        char[] toStringArray();
    
    |--将字节数组转成字符串。
            String(byte[]);
            String(byte[],offset,count);将字节数组中的一部分转成字符串
    |--将字符串转成字节数组。
        byte[] getBytes();
    |--将基本数据类型转换成字符串。
        static String valueOf(int);
        static String valueOf(double);
        3+ "";//String.valueOf(3);  都转化成字符串"3";
        
        
    特殊：字符串和字节数组在转化过程中，是可以指定编码表的。
    
4,替换
    |--
        String replace(oldchar,newchar);//如果没有替换返回的是原串，否则返回新串
    |--
        String replace(oldstr,newstr);
        
5，切割
    
    String[] split(regex);
    
6,子串     获取字符串的一部分
    String substring(begin)
    String substring(begin,end)

7,转换，去除空格，比较。
    
        
    |--将字符串转换成大写或小写
        String toUpperCase()
        String toLowerCase()
    |--将字符串两端的多个空格去除
        String trim();
    |--将两个字符串进行自然顺序的比较。
        int compareTo(String)
 

class StringMethodDemo
{
    
    public static void method_7()
    {
        String s = "        Hello Java           ";
        
        sop(s.toLowerCase());
        sop(s.toUpperCase());
        sop(s.trim());
        String s1 = "abc";
        String s2 = "aaaa";
        
        sop(s1.compareTo(s2));
    }
    
    /*
    public static void method_sub()
    {
        String s = "abcdef";
        
        sop(s.substring(2));
        sop(s.substring(2,4));
    }
    
    public static void method_split()
    {
        String s = "zhangsa,lisi,wangwu";
        
        String[] arr = s.split(",");
        
        for(int x = 0 ;x<arr.length;x++)
        {
            sop(arr[x]);
        }
    }
    
    public static void method_replace()
    {
        String s = "hello java";
        
        String s1 = s.replace('q','n');
        
        String s1 = s.replace("java","world");
        
        sop("s="+s);
        sop("s1="+s1);
    }
    
    public static void method_trans()
    {
        char[] arr = { 'a','b','c','d' };
        
        String s = new String(arr,1,3);
        
        sop("s="+s);
    }
    
    public static void method_is()
    {
        String str = "ArrayDemo.java";
        
        sop(str.startsWith("Array"));
        sop(str.endsWith(".java"));
        sop(str.contains("Demo"));
    }
    
    public static void mathod_get()
    {
        String str = "abcdef";
        
        sop(str.length());
        
        sop(str.charAt(4));
        
        sop(str.indexOf('a',3));
        
    }
    */
    public static void main(String[] args)
    {
        method_7();
    }
    
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

练习二：将字符串反转
    思路：
    1，将字符串变成数组
    2，对数组进行反转
    3，将数组变成字符串

练习三：获取一个字符串在另一个字符串中出现的次数

    "abkksdkkefkkskk"
    
    思路：
    1，定义个计数器
    2，获取kk第一次出现的位置
    3，从第一次出现为位置后剩余的字符串中继续获取kk出现的位置。
        当获取一次就计数一次
    4，当获取不到是，计数完成。
    
练习四：获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度依次递减的子串打印。
    "abcwerthelloyuiodef"
    "cvhellobnm"
    
    思路：
    1，将短的那个子串按照长度递减的方式获取
    2，将每次获取到子串去长传中判断是否包含，如果包含找到。



class StringTest
{
    public static void sop(String str)
    {
        System.out.println(str);
    }
    
    public static void main(String[] args)
    {
        String s1 = "abcwerthelloyuiodef";
        String s2 = "cvhellobnm";
        
        //sop("("+s+")");
        
        
        sop("count="+getMaxSubString(s1,s2));
        //System.out.println();
    }
    
    public static String getMaxSubString(String s1,String s2)
    {
        String Max= "",min = "";
        Max = (s1.length()>s2.length())?s1:s2;
        min = (Max==s1)?s2:s1;
        for(int x =0;x<min.length();x++)
        {
            for(int y = 0,z=min.length()-x;z!=s2.length()+1;y++,z++)
            {
                String temp= min.substring(y,z);
                
                //sop(temp);
                if(Max.contains(tem))//if(s1.indexOf(temp))!=-1)
                    return temp;
            }
            
        
        }
        return "";
    }
    

    
    /*
    public static int getSubCount_2(String str,String key)
    {
        int count = 0;
        int index = 0;
        
        while((index=str.indexOf(key,index))!=-1)
        {
            sop("index="+index);
            //str=str.substring(index+key.length());
            index=index+key.length();
            count++;
        }
        return count;
    }
    
    public static int getSubCount(String str,String key)
    {
        int count = 0;
        int index = 0;
        
        while((index=str.indexOf(key))!=-1)
        {
            sop("str="+str);
            str=str.substring(index+key.length());
            count++;
        }
        return count;
    }
    
    
    public static String reverseString(String s,int start,int end)
    {
        char[] chs= s.toCharArray();
        
        reverse(chs,start,end);
        
        return  new String(chs);
    }
    public static String reverseString(String s)
    {
        
        return   reverseString(s,0,s.length());
    }
    
    private static void reverse(char [] arr ,int x,int y)
    {
        for(int start=x,end=y-1;start<end;start++,end--)
            swap(arr,start,end);
    }    
    
    private static void swap(char[] arr,int x,int y )
    
    {
            char temp =arr[x];
            arr[x] =arr[y];
            arr[y] =temp;
    }
    
    
    
    
    
    public static String myTrim(String str)
    {
        int start= 0 ,end = str.length()-1;
        
        while(start<=end && str.charAt(start)==' ')
        {
            start++;
        }
        
        while(start<=end &&str.charAt(end) == ' ')
            end--;
        
        return str.substring(start,end+1);
    }
    
    */
}

 
 
 StringBuff是字符串缓冲区
 
 是一个容器。
 特点：
 1，长度时刻变化的。
 2，可以操作多个数据类型
 3，最终会通过toString方法变成字符串。
 1，存储
    StringBuffer append();将制定数据作为参数添加到已有数据结尾处
    StringBuffer insert(index,data);可以将数据插入到指定index位置
    
 2，删除
    StringBuffer delete(start,end);删除缓冲区中的数据，包含开始，不包含end、
    StringBuffer deleteCharAt(index);删除指定位置的字符
 
 3，获取
    char charAt(int index)
    int indexOf(String str)
    int lastIndexOf(String str)
    int length()
    String substring(start,end)
        
    
 4，修改
    void setCharAt(int index,char ch)
    StringBuffer replace(start,end,String)
    
 5,反转
    StringBuffer reverse()
    

6,void getChars(int srcBegin,int srcEnd,char[] dex,int destBegin)//将缓冲区中指定数据存储到指定字符数组中。
    



class StringBuffDemo
{
    public static void main(String[] args)
    {
        method_update();
    }
    
    
    public static void method_update()
    {
        StringBuffer sb = new StringBuffer("abcde");
        
        //sb.replace(1,4,"java");
        //sb.setCharAt(2,'k');
        
        char[] chs = new char[4];
        
        sb.getChars(1,4,chs,1);
        //sop(sb.toString());
        for(int x = 0;x<chs.length;x++)
        {
            sop("chs["+x+"]="+chs[x]+";");
        }
    }
    
    
    /*
    public static void method_del()
    {
        StringBuffer sb = new StringBuffer("abcde");
        
        //sb.delete(1,3);
        
        sb.delete(2,2);
        sop(sb.toString());
    }
    
    public static void method_add()
    {
        StringBuffer sb = new StringBuffer();
        
        StringBuffer sb1 = sb.append(34);
        
        sop(sb.toString());
        sop(sb1.toString());
    }
    
    */
    public static void sop(String str)
    {
        System.out.println(str);
    }
}

 
JDK1.5版本之后出现了StringBulider

StringBuffer 是线程同步
StringBuilder是线程不同步

以后开发建议使用StringBulider

升级三个因素；
1，提高效率
2，简化书写
3，调高安全性、

基本数据类型对象包装类

byte     Byte
short     Short
int     Interger
long     Long
boolean    Boolean
float    Float
double     Double    
char     Character

基本数据类型对象包装类的最常见作用，
就是用于基本数据类型和字符串类型之间做转换

基本数据类型转成字符串
    
    基本数据类型+""
    
    基本数据类型.toString(基本数据类型值)
    
    如：Integer.toString(34);//将34整数变成"34";
    

字符串转成基本数据类型

    xxx a = Xxx.parseXxx(String);
    
    int a = Interger.parseInterger("123");//a=123
    
    boolean b = Boolean.parseBoolean("true");
    
    
    
    
十进制转成其他进制

    toBinaryString()
    toHexString()
    toOctalString()
    
其他进制转成十进制。
    int x = Integer.parseInt("110",2) //  使用第二个参数指定的基数，将字符串参数解析为有符号的整数。

class IntegerDemo
{
    public static void main(String[] args)
    {
        //sop("int max :"+Integer .MAX_VALUE);
        //sop("num="+(Integer .parseInt("123")+4));
        //sop("b="+Boolean.parseBoolean("-true"));
        //sop(Integer.(6));
        //int x = Integer.parseInt("110",2)；
        //sop("x="+x);
        //Integer x = new Integer(4);
        
        Integer x = 4;
        x = x/* x.intValue()*/ + 2;//x+2;x 进行自动拆箱。变成了int类型。和2进行加法运算。在将和进行装箱赋值给x
        
        Integer  m = 128;
        Integer  n = 128;
        
        sop("m==n:"+(m==n));
        
        Integer  a = 127;
        Integer  b = 127;
        
        sop("a==b:"+(m==n));//结果为true 。因为a和b指向了同一个Integer对象。
        //因为都拿过牵制在byte范围内容，对于因特性，如果该数值已经存在，则不会在开辟新的空间。
    
    }
    
    public static void method()
    {
        Integer x = new Integer("123");
        Integer y = new Integer(123);
        
        sop("x==y:"+(x==y));
        sop("x.equals(y):"+x.equals(y));
    }
    
    
    public static void sop(String str)
    {
        System.out.println(str);
    }
}