Java.String(学习笔记)

/*
String类
字符串是一个特殊的对象
字符串一旦初始化就不可以被改变
String str = "abc";
String str1 = new String("abc");
有什么区别？
*/
class StringMainDemo1
{
    public static void main(String[] args)
    {
        String s = new String(); //这种方式不多见
        String s1 = ""; //这里和上面是一回事
        String s2 = "abc";//s2是一个类类型变量，"abc"是一个对象
        String s3 = new String("abc"); //和上面一回事
        /*
        S1和S2有什么区别
        S1在内存中有一个对象
        S2在内存中有两个对象
        */
        System.out.println(s2==s3);
        System.out.println(s2.equals(s3));
    }
}
//==================================================================
class StringMainDemo2
{
    public static void main(String[] args)
    {
        String s1 = "abc";
        String s2 = new String("abc");
        String s3 = "abc"; //发现abc已经存在了，它就不会在开辟空间了，而是直接引用，它们指向同一个对象
        System.out.println(s1==s2);
        System.out.println(s1==s3);
    }
}
/*
String常见功能-获取和判断
String类适用于描述字符串事物
那么它就提供了多个方法对字符串进行操作
常见的操作有哪些？
1.获取
    1.1 字符串中包含的字符数，也就是字符串的长度
            int length() //返回此字符串的长度
    1.2 根据位置获取位置上的某个字符
            char charAt(int index)
    1.3 根据字符获取该字符在字符串中的位置
        它接受的是Acsii码，所以是int类型，它有重载形式
            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在字符串中出现的位置
2.判断
    2.1 字符串中是否包含某一个子串
        boolean contains(str);
        特殊之处:indexOf(str) //可以索引str第一次出现的位置，如果返回-1,表示该str不在字符串中存在
                      //所以，也可以用于对指定str判断是否包含
                example:
                    if(str.indexOf("aa")!=-1) //那么包含
                    而且该方法既可以判断又可以获取出现的位置
                    那么判断时到底用哪个方法呢？
                     答:如果你只为判断，就用contains，如果你又想判断，又想获取出现的位置
                        那么就用indexOf
    2.2 字符串中是否有内容
        boolean isEmpty(); //原理就是判断，length是否为0
    2.3 字符串是否是以指定内容开头
        boolean startsWith(str);
    2.4 字符串是否是以指定内容结尾
        boolean endsWith(str);
    2.5 判断字符串的内容是否相同
        boolean equals(str); //重写了Object类中的equals方法
    2.6 判断内容是否相同，并忽略大小写
        boolean equalsIgnoreCase();
*/
class StringMainDemo3
{
    public static void main(String[] args)
    {
        method_get();
        method_is();
    }
    //获取
    public static void method_get()
    {
        String str = "abcdeakpf";
        //长度
        sop(str.length());
        //根据索引获取字符
        sop(str.charAt(4));
        //根据字符获取索引
        sop(str.indexOf('a',3)); //如果没有找到，返回-1
        //反向索引一个字符出现的位置
        sop(str.lastIndexOf("a")); //角标不会发生改变
         
    }
    //判断
    public static void method_is()
    {
        String str = "ArrayDemo.java";
        //判断文件名称是否是Array单词开头
        sop(str.startsWith("Array"));
        //判断是否是.java的文件
        sop(str.endsWith(".java"));
        //判断文件名中是否包含Demo
        sop(str.contains("Demo"));
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
/*
String-常见功能-转换
1.将字符数组转换成字符串
    构造函数:String(char[])
         String(char[],offset,count) //将字符数组中的一部分转换成字符串
    静态方法:static String copyValueOf(char[]);
         static String copyValueOf(char[] data,int offset,int count)
         static String valueOf(char[]); //将基本数据类型转换成字符串
2.将字符串转换成字符数组
    方法:char[] toCharArray()
3.将字节数组转换成字符串
    构造函数:String(byte[])
         String(byte[],offset,count) //将字节数组中的一部分转换成字符串
4.将字符串转换成字节数组
    方法:byte[] getBytes()
*/
class StringMainDemo4
{
    public static void method_trans()
    {
        char[] arr = {'a','b','c','d','e','f'};
        String s = new String(arr);
        System.out.println("s="+s);
         
        //String s = new String(arr,1,3); //1表示从1下标开始，3表示取几个
        //System.out.println("s="+s);       
    }
}
/*
String-常见功能-切割和替换
    切割:
        String[] split(regex); //regex表示分隔符
    替换:
        String replace(char oldChar,char newChar);
        //如果要替换的字符不存在，返回的还是原串
    子串:
        String substring(int beginIndex) //获取一个字符串中的子串
        String substring(int beginIndex, int endIndex)
*/
class StringMainDemo5
{
    public static void main(String[] args)
    {
        method_replace();
        method_split();
        method_substring();
    }
    //切割
    public static void method_split()
    {
        String s = "zhangsan,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('a','n'); //把a替换成n
        String s2 = s.replace("java","world"); //替换字符串
        sop("s="+s);
        sop("s1="+s1);
        sop("s2="+s2);
    }
    //子串
    public static void method_substring()
    {
        String s = "abcdef";
        sop(s.substring(2));//从下标为2的开始到结尾处
        sop(s.substring(2,4));//从下标为2的开始到以下标为0的开始到下标为4的位置
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
/*
String-常见功能-转换、比较和去除空格
    转换:将字符串转换成大写或者小写
         String toUpperCase();
         String toLowerCase();
    去除:将字符串两端的多个空格去除
         String trim();
    比较:对两个字符串进行自如顺序的比较
         int compareTo(str);
*/
class StringMainDemo6
{
    public static void main(String[] args)
    {
        method_zhtrim();
    }
    //转换-去空格
    public static void method_zhtrim()
    {
        String s = "   Hello Java    ";
        sop(s.toUpperCase()); //转大写
        sop(s.toLowerCase()); //转小写
        sop(s.trim());//去除两端的空格
          
    }
    //比较
    public static void method_compareTo()
    {
        String s1 = "abc"; 
        String s2 = "aaa";
        sop(s1.compareTo(s2)); //比较ascii值s1>s2返回正数，小于s2返回负数，等于s2返回0
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }   
}
/*
字符串练习1:
模拟一个trim方法,去除字符串两端的空格
思路:
    1.判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止
      结尾处判断空格也是如此.
    2.当开始和结尾都判断到不是空格时，就是要获取的字符串
*/
class StringTestMainDemo1
{
    public static void main(String[] args)
    {
        String s = "     ab cd      ";
        sop("("+s+")");
        s = myTrim(s);
        sop("("+s+")");
    }
    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);
    }
     
    public static void sop(String str)
    {
        System.out.println(str);
    }
}
/*
StringBuffer
字符串的组成原理就是通过该类实现的
StringBuffer可以对字符串内容进程增删
StringBuffer是一个容器
特点:
StringBuffer是可变长的
StringBuffer可以操作多个数据类型
StringBuffer最终会通过toString方法变成字符串
StringBuffer的功能:
1.存储
    StringBuffer append(data) //将指定的数据作为参数添加到已有数据的结尾处
    StringBUffer insert(index,data) //将指定的数据作为参数插入到已有数据的指定处
2.删除
    StringBuffer delete(start,end) //删除缓冲区中的数据，包含start,不包含end
    StringBuffer deleteCharAt(int index) //删除指定位置的字符
3.获取
    char charAt(int index); //通过下标获取字符
    int indexOf(String str); //根据字符获取下标
    int lastIndexOf(String str); //从最后开始根据字符获取下标
    int length();  //获取长度
    String substring(int start,int end); //获取子串
4.修改
    StringBuffer replace(int start,int end,String str); 
    void setCharAt(int index,char ch)
5.反转
    StringBuffer reverse();
6.将缓冲区中指定数据存储到指定字符数组中
    void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
*/
class StringBufferMainDemo1
{
    public static void main(String[] args)
    {
        method_add();
        method_delete();
        method_update();
        method_getChars();
         
    }
    //添加
    public static void method_add()
    {
        StringBuffer sb = new StringBuffer();
        sb.append("abc").append(true).append(35).insert(1,"qq");
        sop(sb.toString()); //abctrue35
        /*
        StringBuffer sb1 = sb.append(34);
        sop(sb.toString());
        sop(sb1.toString());
        sop("sb==sb1:"+(sb==sb1)); //两个对象相等
        */ 
    }
    //删除
    public static void method_delete()
    {
        StringBuffer sb = new StringBuffer("abcdef");
        sb.delete(1,3);//adef 1是b d是3 不包含end所以，不包含d 那么只删除bc
        sb.delete(0,sb.length()); //清空缓冲区
        sb.deleteCharAt(2); //删除指定位置的字符
        sop(sb.toString()); 
    }
    //修改
    public static void method_update()
    {
        StringBuffer sb = new StringBuffer("abcdef");
        sb.replace(1,4,"java"); //从1到4替换成Java
        sb.setCharAt(2,'k'); //将2角标替换成k
    }
    //将缓冲区中指定数据存储到指定字符数组中
    public static void method_getChars()
    {
        StringBuffer sb = new StringBuffer("abcdef");
        char[] chs = new char[4];
        sb.getChars(1,4,chs,1); //在sb对象中从1下标开始，到4下标结束，把数据插入到chs数组中，1下标开始的地方
        for(int x =0; x<chs.length; x++)
        {
            sop("chs["+x+"]="+chs[x]+";");
        }
    }
    public static void sop(String str)
    {
        System.out.println(str);
    }
 
}
/*
在jdk1.5版本之后，出现了StringBuilder，不同处在于
StringBuffer是线程同步的
    缺点，如果是单线程，会每次判断锁，所以效率不高
StringBuilder是线程不同步的
    因此，单线程用StringBuilder，多线程用StringBuffer
    以后开发建议使用StringBuilder
升级三个因素
1.提高效率
2.简化书写
3.提高安全性
*/
/*
基本数据类型对象包装类
byte//基本数据类型      Byte//引用数据类型
short//基本数据类型       Short//引用数据类型
int//基本数据类型        Integer//引用数据类型
long//基本数据类型      Long//引用数据类型
boolean//基本数据类型   Boolean//引用数据类型
double//基本数据类型    Double//引用数据类型
char//基本数据类型      Char//引用数据类型    
基本数据类型对象包装类最常见的作用，就是用于
基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
    基本数据类型+""
    基本数据类型.toString(基本数据类型值);
    如: Integer.toString(34); //将34整数变成"34"
字符串转成基本数据类型
    Integer.parseInt("123") //将字符串类型转换成int型
十进制转换成其他进制
    toBinaryString();
    toHexString();
    toOctalString();
其他进制转换成十进制
parseInt(string,radix) //将指定的字符串转换成指定的进制表现形式，此方法是静态的
对象调用方式
Integer另一种表现形式
Integer i = new Integer("123");
int x = i.intValue(); //这个方法是静态的
*/
class IntegerMainDemo1
{
    public static void main(String[] args)
    {
        //取整数类型的最大值
        sop("int max :" + Integer.MAX_VALUE);
        int num = Integer.parseInt("123");
        sop("num+"(num+4)); //127
        int x = Integer.parseInt("110",10); //将110转换成10进制
        int x1 = Integer.parseInt("110",2); //将110转换成2进制
    }
 
    public static void sop(String str)
    {
        System.out.println(str);
    }
}
class IntegerMainDemo2
{
    public static void main(String[] args)
    {
        method();
        //新特性
        Integer x = 4; //自动装箱,帮你省略了new Integer(4)，简化了书写
        x = x + 2;//x+2:x进行了自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x
        //那么它如何拆箱的呢？
        x.intValue(); //拆箱原理
        Integer m = 128;
        Integer n = 128;
        sop("m==n:"+(m==n)); //false
 
        Integer a = 127;
        Integer b = 127;
        sop("m==n:"+(a==b)); //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)); //这里equals比较的是数值是否相同
    }
 
    public static void sop(String str)
    {
        System.out.println(str);
    }
}