Java基础_字符串

字符串

一、字符串

    1.1、String类

    字符串是一种很常见的数据类型，在很多的编程语言中都对字符串进行了封装；在java中，用String类封装字符串。

    字符串最大的特点是一旦被初始化就不可以改变。

    String类用于描述字符串，那么它一定提供了多个方法对字符串进行操作，下面介绍常用的操作方法：

    1、获取：

        int  length():获取长度；

        char  charAt(int index)：根据位置获取字符；

        int  indexOf（int ch）：根据字符获取位置，返回的是第一次出现的位置；

        int  indexOf(int ch,int fromIndex):根据字符获取位置，从fromIndex开始；

        int  indexOf（String str ）：获取字符串出现的位置，返回的是第一出现的位置；

        int  lastIndexOf(int ch):反向查找，获取的查找字符时第一次出现的位置。

    2、判断：

        boolean  contains(String str):判断是否包含子串；

        boolean  startsWith(String str)：判断是否以指定字符串开头；

        boolean  endsWith(String str):判断是否以指定字符串结尾；

        boolean  equalsIgnoreCase(String str);判断是否相同，并忽略大小写。

    3、转换：

        String(char[]value):将字符数组转换成字符串；

        static  String  valueOf(char[])：将字符数组转换成字符串；

        char[]  toCharArray():将字符串转成字符数组；

        byte[]  getBytes()：将字符串转成字节数组；

        static  String valueOf(int )//double float：将基本数据类型转成字符串。

    4、替换：String replace(char oldChar，char newChar）；

    5、切割：String[] split(String regex)；

    6、获取子串：String subString(int begin,int end)；

    7、转换，去除空格，比较：

        String  toUpperCase()；String  toLowerCase()；大小写转换；

        String  trim()；去除两端的空格；

        int  compareTo(String str):比较两个字符串的大小。

下面代码演示String类的功能：

1、简单演示：

package itheima.day13;

public class StringDemo {

	public static void method_get(){
		
		String str ="asdffaghha";
		//长度
		sop(str.length());
		//获取
		sop(str.lastIndexOf('s'));
		sop(str.charAt(4));
		sop(str.lastIndexOf('a'));
	}
//	切割
	public static void method_split(){
		String s = "zhangsan,lisi,wangwu";
		String[] arr = s.split(",");
		for(int i=0;i<arr.length;i++)
			sop(arr[i]);
	}
	
	public static void main(String[] args) {
		
		String s1 = "abc";
		String s2 = new String("abc");
		
//		System.out.println(s1 == s2);//false
//		System.out.println(s1.equals(s2));//true
//		method_get();
		method_split();
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

2、练习：

package itheima.day13;

public class StringTest {
	public static void main(String[] args) {
//		1、
		String str1 = "    fgfh fghfdb    ";
		String newStr = myTrim(str1);
		sop(newStr);
//		2、
		String reveStr =reverseString(newStr);
		sop(reveStr);
//		3、
		String str2 ="KKJJHHNNBBVVHHUIUOOKKJJHH";
		int count = getSubCount(str2,"JJ");
		sop(count);
//		4、
		String MaxStr = getMaxSubString("1254568956","4525");
		sop(MaxStr);
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
	
// 	需求：模拟一个trim方法，去除字符串两端的空格。
//	 思路：1、判断字符串第一个位置是否是空格，直到不是空格为止
//         2、当开始和结尾都不是空格时，获取该子串
	public static String myTrim(String str){
		int start = 0,end = str.length()-1;
		while(start<=end && str.charAt(start)==' ')
			start++;
		while(end>=start && str.charAt(end)==' ')
			end--;
		return str.substring(start,end+1);
	}
	
//	练习2：将一个字符串进行反转
//	 思路：1将字符串转成字符数组，反转字符数组
//	 		2将反转后的字符数组变成字符串。
	public static String reverseString(String str){
		char[] arr = str.toCharArray();
		reverse(arr);
		return new String(arr);
	}
	private static void reverse(char[] arr){
		for(int start=0,end=arr.length-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;
	}
	
//	练习3：获取一个字符串在另一个字符串中出现的次数
//	   思路：1、定义一个计数器。2，获取位置，计数器自增
	public static int getSubCount(String str,String key){
		int count = 0;
		int index = 0;
		while((index = str.indexOf(key,index))!=-1){
			index = index +key.length();
			count++;
		}
		return count;
	}
	
//	练习4、获取两个字符串中最大相同子串。
//	  思路：1、将短的那个子串按照长度递减的方法获取
//	 	 2、将每次获取到的子串，判断长串是否包含，如果包含，找到！
	public static String getMaxSubString(String str1,String str2){
		
		String max ="",min ="";
		max = (str1.length()>str2.length())?str1:str2;//长串
		min = (max == str1)?str2:str1;//短串
//		查找
		for(int x =0;x<min.length();x++){
			for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++){
//				y:字符串的头，z:字符串的尾；包含头，不包含尾
				String temp = min.substring(y,z);
				if(max.contains(temp))
					return temp;
			}
		}
		return "";
	}
}

    1.2、StringBuffer类与StringBuilder类

    StringBuffer是字符串缓冲区，是一个容器；长度可变并且可以操作多种数据类型。最后通过toString()方法变成字符串。下面介绍StringBuffer类的基本方法：

    1、存储：

        StringBuffer  append(data)：将数据插入结尾处；

        StringBuffer  insert(int index,data)：插入数据到指定位置。

    2、删除：

        StringBuffer  delete(int start,int end):删除缓冲区中的指定数据；

        Stringbuffer   deleteCharAt(int index):删除指定位置的字符。

    3、修改：StringBuffer replace(int start,int end,String str)：替代

    4、反转：StringBuffer reverse()。

    StringBuilder是JDK1.5以后才出现的，用法基本与StringBuffer相同，但它不不同步，StingBuffer同步。

    版本升级三个因素：提高效率；简化书写；提高安全性。

简单代码演示：

package itheima.day13;

public class StringBufferDemo {

	public static void main(String[] args) {
		method_add();
		method_del();
	}
	public static void method_add(){
//		容器
		StringBuffer sb = new StringBuffer();
//		追加
		sb.append(true).append("sdggh").append(563.0);
		System.out.println(sb);
	}
	public static void method_del(){
		StringBuffer sb = new StringBuffer("abxcd");
		sb.delete(1, 3);
//		sb.delete(0, sb.length());
		System.out.println(sb.toString());
	}
}

二、包装类

    根据面向对象的思想，数据类型该怎么操作，只有数据本身最清楚。为了操作的方便，因此把基本数据类型封装成了包装类，并向外提供了很多操作基本数据的方法。

    基本数据包装类有八个：Byte、Short、Integer、Long、Boolean、Float、Double和Character，分别对应具体的八个基本数据类型。

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

    基本数据类型转成字符串：基本数据类型+“”；基本数据类型包装类.toString(基本数据类型)，例如：Integer.toString(34)。

    字符串转成基本数据类型：xxx a = Xxx.parseXxx(string)。

    十进制转成其他进制：Integer.toXxxString(int)。

    其他进制转换成十进制：Integer.parseInt(String s,int radix)//radix表示进制数

    自动装箱与自动拆箱：这是JDK5.0之后出现的新特性，例如：Integer x = new  Integer(4);可以直接写成Integer  x = 4;//自动装箱；x  = x + 5;//自动拆箱。通过intValue()方法。

简单代码演示：

package itheima.day13;

//基本数据类型包装类最常用的操作：
//用于基本数据类型与字符串之间的转换
public class IntegerDemo {

	public static void main(String[] args) {
		
//		整数类型的最大值、最小值
		sop("int max = "+Integer.MAX_VALUE);
		sop("int min = "+Integer.MIN_VALUE);
		
//		自动装箱//new Integer(4)
		Integer x = 4;
//		自动拆箱//x.intValue()
		x =x+2;
	}
	
	private  static void sop(Object obj){
		System.out.println(obj);
	}
}