黑马程序员java学习笔记——String字符串及StringBubuffer容器

------- android培训、java培训、期待与您交流！ ----------

字符串

    String类

    概述

    API：java给我提供的应用程序接口，暴露出来的能让我们使用的部分。

    字符串：是一个特殊对象，它的最大特点就在于一旦被初始化，就不可以被改变。

    就比如说：String s1 = "abc"；然后我们在给s1赋其他值，s1 = "kk"；这其实是s1变了，它指向了"kk"，而"abc"并没有改变，"abc"在内存中还在，s1的地址变了，但是"abc"这个对象的内容没变化过。

    我们也可以这么写：String s2 = new String（"abc"）；因为String有一个可以传字符串的构造函数，和上边的s1使用起来，是一样的，但是我们对两个对象进行比较s1==s2和s1.equals(s2)；前者是flase,后者是true；s1和s2不想等，那么为什么equals是true呢？String类复写了Object类中的equals方法，定义了自己独特的内容，该方法用于判断字符串是否相同。

    s1和s2的区别：s1是一个对象，s2是两个对象。

    String s3 = "abc"；我们来比较s1和s3，发现是相等的，因为"abc"这个字符串在内存中已经存在了，s3发现这个对象已经存在，就不会再在内存中独立开辟空间了，直接指向了它，s1和s3指向了同一个对象。

    

    String的常见功能

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

    获取

        1.1 字符串中包含的字符数，也就是字符串的长度

            int length（）：获取长度。

        1.2 根据位置获取位置上的某个字符

            char charAt（int  index）：当访问到字符串中不存在的角标时，会发生

            字符串角标越界的错误。

        1.3 根据字符获取该字符存在字符串的位置

            int indexOf（int ch）：返回的是ch在字符串中第一次出现的位置，传入

            的是字符对应的ASCII码，如果没有找到，返回-1。

            int indexOf（int ch，int fromIndex）：从fromIndex指定位置开始，获

            取ch在字符串中出现的位置。

            int indexOf（String str）：返回的是str在字符串中第一次出现的位置。

            int indexOf（String str，int fromIndex）：从fromIndex指定位置开

            始，

            获取str在字符串中出现的位置。

            int lastIndexOf（）：反向索引 

    判断

        2.1 字符串中是否包含某一个子串

            boolean contains（str）；

            特殊之处：indexOf（str）可以索引str第一次出现的位置，如果返回-1表

            示该str不在字符串中存在，所以，也可以用于对指定判断是否包含。该方

            法既可以判断，又可以获取出现的位置。如果只为判断，用contains。

        2.2 字符串中是否有内容

            boolean isEmpty(): 原理就是判断长度是否为0； 
        2.3 字符串是否是以指定内容开头。
            boolean startsWith(str)；
        2.4 字符串是否是以指定内容结尾。
            boolean endsWith(str)；
        2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
            boolean equals(str)；
        2.6 判断内容是否相同，并忽略大小写。
            boolean equalsIgnoreCase()；

    转换
        3.1 将字符数组转成字符串。
            构造函数：String(char[])
            String(char[],offset,count):将字符数组中的一部分转成字符串。
            静态方法：
            static String copyValueOf(char[])；
            static String copyValueOf(char[] data, int offset, int count)；
            static String valueOf(char[])；
        3.2 将字符串转成字符数组。
            char[] toCharArray()；
        3.3 将字节数组转成字符串。
            String(byte[])；
            String(byte[],offset,count):将字节数组中的一部分转成字符串。
        3.4 将字符串转成字节数组。
            byte[]  getBytes()；
        3.5 将基本数据类型转成字符串。
            static String valueOf(int)；
            static String valueOf(double)；
            //3+"";//String.valueOf(3)；
        特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
    替换
          String replace(oldchar,newchar)；
    切割
          String[] split(regex)；
    子串：获取字符串中的一部分。
          String substring(begin)；
          String substring(begin,end)；
    转换，去除空格，比较。
        7.1 将字符串转成大写或则小写。
           String toUpperCase()；
           String toLowerCase()；
        7.2 将字符串两端的多个空格去除。
           String trim()；
        7.3 对两个字符串进行自然顺序的比较。
           int compareTo(string)；

    

    练习：

    

    练习一：模拟一个trim方法，去除字符串两端的空格；

/*
思路：
(1)：定义一个指针，从字符串开头和结尾的位置开始进行判断，如果判断到有空格，就继续往下判断，直到不是空格为止；
(2)：获取从头和从结尾判断到的指针，然后获取其间的字串。
*/
class MyTrim
{
	public static void main(String[] args)
	{
		String s = "    ab  cde    ";
		String s1 = myTrim(s);
		System.out.println("s1 = "+s1);
	}
	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);
	}
}

运行后的结果：

    

    练习二：对字符串进行反转，然后对字符串中的一部分进行反转；

/*
思路：
(1)：把字符串变成字符数组；
(2)：对字符串进行反转
(3)：把字符数组变成字符串。
*/
class SubReverse
{
	public static void main(String[] args)
	{
		String s1 = "dsgdfhdghgert";
		String s2 = reverseString(s1,3,10);
		String s3 = reverseString(s1);
		System.out.println("s1:"+s1);
		System.out.println("s2:"+s2);
		System.out.println("s3:"+s3);
	}
	//把字符串中的一部分变成字符数组
	public static String reverseString(String s,int x,int y)
	{
		//把字符串变成字符数组
		char[] chs = s.toCharArray();
		//对字符数组进行反转
		reverse(chs,x,y);
		//把字符数组变成字符串
		return new String(chs);
	}
	//把一整串进行反转
	public static String reverseString(String s)
	{
		return reverseString(s,0,s.length());
	}
	public static void reverse(char[] chs,int x,int y)
	{
		for(int start=x,end=y-1;start<end;start++,end--)
		{
			swap(chs,start,end);
		}
	}
	public static void swap(char[] chs,int x,int y)
	{
		char temp = chs[x];
		chs[x] = chs[y];
		chs[y] = temp;
	}
}

运行结果是：

     

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

/*
思路：
(1)：判断字符串是否含有这个子串
(2)：获取这个子串第一次出现的位置
(3)：以这个位置为起点，获取下一次子串出现的位置
(4)：建立循环，定义一个计数记录下获取到子串的次数
*/
class GetCount
{
	public static void main(String[] args)
	{
		String s1 = "kkadaskkadkkadsakkvfgkk";
		int num1 = getSubstring(s1,"kk");
		int num2 = getSubstring_1(s1,"kk");
		System.out.println("num1="+num1);
		System.out.println("num2="+num2);
	}
	//方法一：改变字符串并改变起始位置
	public static int getSubstring(String str,String key)
	{
		int count = 0;
		int index = 0;
		while((index=str.indexOf(key))!=-1)
		{
			str = str.substring(index+key.length());
			count++;
		}
		return count;
	}
	//方法二：只改变起始位置
	public static int getSubstring_1(String str,String key)
	{
		int count = 0;
		int index = 0;
		while((index = str.indexOf(key,index))!=-1)
		{
			index = index + key.length();
			count++;
		}
		return count;
	}
}

运行的结果是：

    

    

    练习四：获取两个字符串中最大相同子串"adasfsahelloadfasfa"，"assdhelloasd"；

/*
思路：
(1)：将短的那个子串按照长度递减的方式获取到
(2)：到长串中判断是否包含子串
*/
class GetMaxSub
{
	public static void main(String[] args)
	{
		String s1 = "adasfsahellodfasfa";
		String s2 = "assdhelloasd";
		System.out.println(getMaxSubstring(s1,s2));
	}
	//获取两个子串中的最大相同子串
	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!=min.length()+1;y++,z++)
			{
				String temp = min.substring(y,z);
				if(max.contains(temp))
					return temp;
			}
		}
		return "";//循环完如果没找到，也要返回；否则编译会失败；
	}
}

运行的结果是：

    

    StringBuffer容器

    概述

    StringBuffer是字符串缓冲区，它是一个容器，专门用于对字符串进行操作。

    String和StringBuffer他们都可以存储和操作字符串，即包含多个字符的字符串数据；String类是字符串常量，是不可更改的常量，而StringBuffer是字符串变量，它的对象是可以进行增删改查操作的。

    特点：1，长度是可变化的。
          2，可以字节操作多个数据类型，而数组一次只能操作一种类型。
          3，最终会通过toString方法变成字符串。

    

    StringBuffer的常见功能

    1，存储
           StringBuffer append():将指定数据作为参数添加到已有数据结尾处；
           StringBuffer insert(index,数据):可以将数据插入到指定index位置。

    2，删除
          StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含

          end；
          StringBuffer deleteCharAt(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(start,end,string)；
          void setCharAt(int index, char ch) 。

    5，反转
          StringBuffer reverse()；
 
    6，将缓冲区中指定数据存储到指定字符数组中；
          void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)。 

    JDK1.5 版本之后出现了StringBuilder.
    StringBuffer是线程同步；
    StringBuilder是线程不同步；
    以后开发，建议使用StringBuilder。
    升级三个因素：1，提高效率；2，简化书写；3，提高安全性。

    

    基本数据类型对象包装类

   按照java面向对象的原则，它将万事万物都视为对象，其中就包括基本数据类型byte、short、int、long、boolean、float、double和char这八种基本数据类型，他们分别有自己对应的类。

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

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

                          串"34"；

    字符串转成基本数据类型。

        xxx a = Xxx.parseXxx(String)，这里必须传入数字格式的字符串，这个String

        是xxx类型的字符串；

        int a = Integer.parseInt("123")，如果转的是"123a"，就会出现数字格式异

        常；
        double b = Double.parseDouble("12.23")；
        boolean b = Boolean.parseBoolean("true")，只能是boolean型字符串；

    十进制转其他进制：

        十进制转二进制：toBinaryString()；

        十进制转十六进制：toHexString()；

        十进制转八进制：toOctalString()。

    其他进制转十进制：

        parseInt(String s，int radix)，radix是String对应的数的进制。

        int x = Integer.parseInt("110",10)，把"110"，转成十进制。

        Integer i = new Integer("123")；
        int num = i.intValue()； 这个方法是非静态的，通过对象调用，parseInt是

        静态的，通过类名调用。

    基本数据类型包装类对象新特性

        Integer x = new Integer("123")；
        Integer y = new Integer(123)；
        sop("x==y:"+(x==y))；false
        sop("x.equals(y):"+x.equals(y))；true

    复写了Object的equals方法，有自己的比较方式，比较的是数值是否相同。

    Integer x = 4；这样在jdk1.5之后是可以的，自动装箱了，相当于new Integer(4)对象，x是引用数据类型，隐式帮你完成了，简化了书写，而且x可以直接进行运算：x = x + 2；对x进行了自动拆箱操作，变成了int类型，和2进行加法运算，再将值封装成Integer对象，赋给x，其实就是x = /*x.intValue()*/ + 2；

    int只能写整数，而Integer可以为null，x为null时就不能调用intValue()方法，会发生null指针异常

        Integer m = 128；
        Integer n = 128；

        sop("m==n:"+(m==n))；结果是false
        Integer a = 127；
        Integer b = 127；
        sop("a==b:"+(a==b))；结果为true，因为a和b指向了同一个对象。

    当数值在byte范围内时，对于新特性，如果该数值已经存在，不会在开辟新的空间。