黑马程序员--------java String、StringBuffer、StringBuilder

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

String类

String

一、概述
1、初始化：String s = “abc” s是一个类类型变量，并指向”abc”对象
2、特点：一旦被初始化就不可以改变。例如：String s = new String("abc"); s=”ab”;如果打印s会发现s的值是ab，这并不是字符串”abc”变化了，而是s又指向了”ab”
3、String s1 =”abc”;String s2=new String(“abc”)，问s1和s2有什么区别？
s1在内存中有一个对象—“abc”; s2在内存中有两个对象— new 和”abc”
4字符串的比较有自己独特的方式——equals 判断内容是否相同。它是复写了Object的equals方法

二、方法
获取
1、字符串的长度：
   *int length();获取长度
2、根据位置获取位置上的某个字符：
   *char charAt(int index)获取角标为index的字符。访问到不存在的角标时会发生角标越界异常
3、根据字符获取该字符在字符串中位置：
   *int indexOf(int ch) 返回ch在字符串出现的第一次出现的位置。如果没找到返回 -1
   *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) ：从字符串最后一位向前索引 字符出现的位置。
判断
1、字符串中是否包含某一个子串
   *boolean contains(str)
   **特殊之处：indexOf(str) :可以索引str第一次出现的位置，如果返回-1，表示str在字符中。所以，也可以用于对指定字符串判断是否包含   if(str.indexOf(“aa”)!=-1) 而且该方法既可以判断也可以获取出现的位置索引
2、字符串中是否有内容
   *boolean isEmpty() 原理就是判断长度是否为0
3、字符串是否以指定内容开头
   *boolean startsWith(str)
4、字符串是否以自动内容结尾
   *boolean endsWith(str)
5、判断字符串内容是否相同。复写了Object的equals方法
   *boolean equals(str)
6、判断内容是否相同，并忽略大小写
   *boolean equalsIgnoreCase();
转换
1、将字符数组转成字符串
   *构造函数：String(char[]); 例： char[] arr={‘a’,’b’,’c’} String s=new String( arr)、

    new String(arr ,offset,count): 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()
   特殊：字符串和字节数组在转换过程中，是可以指定编码表的
5、将基本类型转换为字符串
   *static String valueOf(int)、static String valueOf(double)
   例：3+””==String.valueOf(3);
替换：
1、String replace(oldchar,newchar);字符或字符串替换： 如果要替换的字符不存在，返回原串
   例：String s=”hello”;String s1=s.replace(‘l’,’e’);如果打印s值为hello ，s1为heeeo
切割：
1、String[] split(regex);例：String s=”zhangsan,lisi,wangwu”;String[] arr= s.split(“,”),对逗号处切割
   regex-分隔符 结果：String[] arr=[zhangsan,lisi,wanwu];

子串：
1、获取字符串的子串
   *String substring(begin); 从指定位置到结尾
   *String substring(begin,end);包含头，不包含尾。获取整个字符串s.substring(0,s.length())
转换、去除空格、比较
1、将字符串转成大写或者小写
   *String toUpperCase()
   *String toLowerCase()
2、将字符串两端多个空格去除
   *String trim();
3、对两个字符串进行自然顺序比较
   *string compareTo(String)

StringBuffer

一、StringBuffer是字符串缓冲区、是一个容器，
特点：
1、长度是可以变化的
2、可以直接操作多个数据类型
3、最终会通过toString方法变成字符串
二、操作
C create U updata R read D delete
1、存储 .toString可以将容器的数据变成字符串
   *StringBuffer append():将指定数据作为参数添加到已有数据的结尾处
   *StringBuffer insert(index ,数据)：可以将数据插入到指定的index位置
2、删除
   *StringBuffer delete(start,end)：删除缓冲区中的数据，包含start不包含end
   *StringBufer 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);将start-end的字符替换，不包含end
   *void setCharAt(int index,char ch); 将index角标的字符替换
5、反转
   *StringBuffer reverse();
6、将缓冲区中指定数据存储到指定字符数组中
   *void getChars(int srcBegin, int srcEnd ,char[] dst, int dstBegin)
   srcBegin：缓冲区起始位 srcEnd：缓冲区结束位（不包含尾）
   char[] dst:接收缓冲区数据的数组 dst：从数组的dst位开始存储

JDK1.5版本出现StringBuilder
1特点：
   StringBuffer是线程同步，
   StringBuilder是线程不同步，功能与StringBuffer一致
   以后开发建议使用StringBuilder
2、升级三个因素：提高效率、简化书写、提高安全性

基本数据类型对象包装类

 基本数据类型          引用数据类型

     byte                  Byte

    short                 Short

     int                  Integer

     long                  Long

    boolean               Boolean

     float                 Float

    double                Double

     char                Character

 

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

1、基本数据类型转字符串

     基本数据类型+””

   *基本数据引用类型.toString(基本数据类型值)：如 Integer.toString(34); 将34变成”34”

 

2、字符串转基本数据类型

  * xxx a = Xxx.parseXxx(String);

   int a = Integer.parseInteger(“123”);或者 double a = Double.parseDouble(“123”;)

   boolean b = Boolean.parseBoolean(“true”);

   非静态转换方法：
   *Integer i = new Integer(“123”);

    int num = i.intValue();

 

3、十进制转其他进制

   * Integer.toBinaryString();

   * Integer.toHexString()

   * Integer.toOctalString()

4、其他进制转十进制

   * parseInt(String,radix);

例：int x = Integer.parseInt(“110”,2);将二进制数的110转成十进制

    intx = Integer.parseInt(“3c”,16);将十六进制数3c转成十进制

JDK1.5版本以后出现的新特性
1、自动装箱
   Integer x = new Integer(4);
   可以直接写成 Integer x=4; 原因：自动装箱功能 相当于new Integer(4)
   x=x/* x.intValue()自动转换*/+2; x 自动拆箱变成int型，和2相加，再将和进行装箱赋给x
2、Integer a= 127;Integer b=127 (a==b)为true
原因：因为a和b指向了同一个Integer对象。因为当数值在byte范围内，对于新特性，如果该数值已经存在，则不会开辟新的空间

练习

/*
1、模拟一个trim方法

思路：1、trim方法是用来去除字符串两端的空格的
      2、定义两个引用标记index1和index2分别指向字符串的开头和结尾处
	  3、在循环中用charAt方法判断这两个标记位的字符是否为空‘ ’;如果是index1++,index2--且index1<=index2,
	  4、如果判断都不为空了，在调用substring方法截取这段字符串

*/
class StringTest1 
{
	public static void fuc(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		String s = "    abcd ef      ";
		int index1 = 0,index2=s.length()-1;//定义两个角标指向字符串的头和尾
		while(index1<=index2&&s.charAt(index1)==' ')//循环判断index1角标指向的字符是否为空
			index1++;//满足条件++
		while(index1<=index2&&s.charAt(index2)==' ')//循环判断index2角标指向的字符是否为空
			index2--;
		s = s.substring(index1,index2+1);//通过substring方法截取要保留的部分。这个方法是包含头
		fuc(s+"..."+s.length());                          //不包含尾，所以index2要加1

	}
}<strong>
</strong>

打印结果：

/*
将一个字符串进行反转。将字符串中指定部分进行反转，“abcdefg”;abfedcg
   思路：
   1，曾经学习过对数组元素进行反转。
   2，将字符串变成数组，对数组反转。
   3，将反转后的数组变成字符串
   4，只要将反转部分的开始和结束位置作为参数传递即可。
*/
class StringTest22 
{
	public static void fuc(String str)
	{
		System.out.println(str);
	}
	public static void main(String[] args) 
	{
		String s = "abcdefgh";
		fuc("("+s+")");

		fuc("("+reverseString(s)+")");
	}
	public static String reverseString(String s)
	{
		return reverseString(s,0,s.length());//在调用重载方法
		
	}
	public static String reverseString(String s,int start,int end)
	{
		//字符串变数组。
		char[] chs = s.toCharArray();

		//反转数组。
		reverse(chs,start,end);

		//将数组变成字符串。
		return new String(chs);
	}

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

}

打印结果：

/*
获取一个字符串在另一个字符串中出现的次数
s1="acdwwcbwwabdwwhwwoww"
s2="ww"

思路：1、用indexOf（srt）方法判断s1在s2中是否存在(不存在会返回-1)，存在的话就找出了s2在s1中的角标位置index，
         这时计数器就可以加1
      2、下一次寻找时就从index=index+s2.length()处开始寻找，
	  3、s1为一个新的字符串s1= s1.substring(index)
	  4、当出现indexOf(str)值为空时，寻找完毕，计数器里面存储的值就是s2在s1中出现的次数
*/       
class StringTest3 
{
	public static void fuc(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		String s1 = "acdwwcbwwabdwwhwwowwww";
		String s2 = "ww";
		int x = method(s1,s2);
		fuc("s2在s1中出现了 "+x+" 次");	
	}
	public static int method(String s1,String s2)//定义一个方法来判断次数
	{
		int count = 0;
		int index;
		while((index=s1.indexOf(s2))!=-1)//当index为-1时，说明s1里没有与s2相同的字符串了
		{
			index = index+s2.length();//如果s1里面包含有s2的字符串，下一次判断时应从获取的角标值加上s2
			                          //的长度处开始寻找
			s1 = s1.substring(index);//截取新的字符串
			count++;
		}
		return count;
	}
}

打印结果：

/*
获取两个字符串中最大相同子串
s1="ghichellosabcdyhhcde"
s2="abchelloyhhde"

思路：
	1，将短的那个子串按照长度递减的方法获取到
	2，将每获取到的子串去长串中判断是否包含。如果包含就找到
*/
class StringTest4 
{
	public static void fuc(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		 String s1 = "ghichellosabcdyhhcde";
		 String s2 = "abchelloyhhde";

		fuc(method(s1,s2));
	}
	public static String method(String s2,String s1)
	{
		String Max="",Min="";
		Max=(s1.length()>s2.length())?s1:s2;
		Min=(Max==s1)?s2:s1;
		System.out.println("max="+Max+"  Min="+Min);
		for(int x=0;x<Min.length();x++)//遍历短的字符串
		{
			for (int y=0,z=Min.length()-x-1;z<Min.length();y++,z++ )//每次角标减一，在循环右移找取
			{
				if(Max.contains(Min.substring(y,z+1)))//比较截取的子串在长串中是否存在
				{
					//fuc(s2.substring(y,z+1));
					return Min.substring(y,z+1);//存在就直接返回最先找到的，也就是最大的一个相同子串
				}
			}
		}
		return "";
	}
}

打印结果：

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------