API-String类、基本数据类型对象包装类

1、String类概述

    String类是用于描述字符串事物。

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

<span style="font-family:Microsoft YaHei;font-size:14px;">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类中equals方法
										  //该方法用于判断字符串是否相同。
	}
}</span>

2、String类常见操作

1,获取。

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

int length（）：获取长度

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

char charAt(int index):

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

int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch,int fromIndex):从fromIndex指定位置开始,获取ch在字符串中出现的位置。

int indexOf(Sting str):返回的是str在字符串中第一次出现的位置。

int indexOf(Sting str,int fromIndex):从fromIndex指定位置开始,获取str在字符串中出现的位置。

      

        int lastIndexOf(int ch)

 

2,判断。

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

boolean contains(str);

特殊之处：indexOf(str):可以索引str第一次出现的位置,如果返回-1,表示该str在字符串中不存在。                    所以,也可以用于判断是否包含指定字符串。

 

  if(str.indexOf("aa")!=-1)

 

  而且该方法既可以判断,又可以获取出现的位置。

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(str);

 

3,转换。

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

特殊：字符串和字节数组在转换过程中,是可以指定编码表的。

 

4,替换。

String replace(oldchar,newchar);

 

5,切割。

String[] split(regex);

 

6,子串。获取字符串的一部分。

String substring(begin);

String substring(begin,end);

 

7,转换、去除空格、比较。

7.1将字符串转成大写或小写。

String toUpperCase();

String toLowerCase();

7.2将字符串两端的多个空格去除。

String trim();

7.3对两个字符串进行自然顺序的比较。

比较的是第一个不同的字符：> 返回一个整数；<返回一个负数；=返回0  返回值是ASCII码的值。

int compareTo(string);

代码示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class StringMethodDemo 
{
 
	public static void method_7()
	{
		String s = "    Hello Java          " ;
 
		sop(s.toUpperCase());
		sop(s.toLowerCase());
		sop(s.trim());
 
		String s1 = "abC";
		String s2 = "abag";
		sop(s1.compareTo(s2));
	}
 
 
 
	public static void method_sub()
	{
		String s = "abcdef";
		sop(s.substring(2));//从指定位置到结尾。如果角标不存在,会出现字符串角标越界异常。
		sop(s.substring(2,4));//包含头,不包含尾。s.substring(0,s.lengthh);
	}
 
 
	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');//如果要替换的字符不存在,返回的还是原串。
        String s2 = s.replace("java","world");
 
		sop("s="+s);
		sop("s1="+s1);
		sop("s2="+s2);
	}
 
	public static void method_trans()
 
	{
		char[] arr = {'a','b','c','d','e','f'};
 
		String s = new String(arr);
		String s1 = new String(arr,1,3);

		sop("s="+s);
		sop("s1="+s1);
 
		String str = "fdzgjgfdg";
		char[] ch = str.toCharArray();
 
		for (int x=0; x<ch.length; x++)
 
		{
			sop("ch="+ch[x]);
		}
	}
 
	public static void method_get()
	{
		String str = "abcdeakpf";
		//长度
 
		sop(str.length());
 
		//根据索引获取字符
		sop(str.charAt(4));//当访问到字符串中不存在的角标时,会发生StringIndexOutOfBoundsException
 
		//根据字符获取索引
		sop(str.indexOf('a'));
		
		//根据字符从指定位置获取索引
		sop(str.indexOf('a',3));
		sop(str.indexOf('m',3));//如果没有找到,返回-1 
	}

	public static void method_is()
	{
		String str = "ArrayDemo.java";
 
		//判断文件是否为空。
		sop(str.isEmpty());
 
		//判断文件名称是否是Array单词开头。
		sop(str.startsWith("Array"));
 
		//判断文件名称是否是.java文件。
		sop(str.endsWith(".java"));
 
		//判断文件是否包含Demo.
		sop(str.contains("Demo"));
	}

	public static void main(String[] args) 
 
	{
		method_get();
		method_is();
		method_trans();
		method_replace();
		method_split();
		method_sub();
		method_7();
		
 
		/*
		String s1 = "abc";
		String s2 = new String ("abc");
 
	
		String s3 = "abc";
		System.out.println(s1==s2);
		System.out.println(s1.equals(s2));
		*/
	}

	public static void sop(Object obj)
 
	{
		System.out.println(obj);
	}
}</span>

例：

<span style="font-family:Microsoft YaHei;font-size:14px;">/*
1、模拟一个trim方法,去除字符串两端的空格。
	思路：
	1,判断字符串第一个位置是否是空格,如果是继续向下判断,直到不是空格为止。
		结尾处判断空格也是如此。
	2,当开始和结尾都判断不是空格时,就是要获取的字符串。
 
2、将一个字符串进行反转。将字符串中指定部分进行反转,“abcdefg”;abfedcg
	思路：
	1,曾经学习过对数组的元素进行反转。
	2,将字符串变成数组,对数组进行反转。
	3,将反转后的数组变成字符串。
	4,只要将要反转的部分的开始和结束位置作为参数传递即可。
 
3、获取一个字符串在另一个字符串中出现的次数。
	“abkkcdkkefkkskk”
	思路：
	1,定义个计数器。
	2,获取kk第一次出现的位置。
	3,从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
		每获取一次就计数一次。
	4,当获取不到时,计数完成。
 
4、获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度依次递减的子串打印。
	“abcwerthelloyuiodef”
	"cvhellobnm"
	思路：
	1,将短的那个子串按照长度递减的方式获取到。
	2,将每获取到的子串去长度中判断是否包含。如果包含,已经找到！
*/
 
class  StringTest
{
	public static void main(String[] args) 
	{
		String s = "   ab  cd   ";
        sop(myTrim(s));
		String s1 = "abcdef";
		sop(myReverse(s1));
		String s2 = "abkkcdkkefkkskk";
		sop(getSubCount(s2,"kk"));
		String s3 ="abcwerthelloyuiodef",s4="cvhellobnm";
		sop(getMaxString(s3,s4));
	}
 
 
//1、模拟一个trim方法,去除字符串两端的空格。
	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);
 
	}

//2、将一个字符串进行反转。将字符串中指定部分进行反转,“abcdefg”;abfedcg
 
 
	public static String myReverse(String s)
	{
		return myReverse(s,0,s.length()-1);
	}
 
	public static String myReverse(String s,int start,int end)
	{
		char[] ch = s.toCharArray();
		reverse(ch,start,end);
		return new String(ch);
	}
	private static void reverse(char[] arr,int x,int y)
	{
		for (int start=x,end=y; 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、获取一个字符串在另一个字符串中出现的次数。“abkkcdkkefkkskk”
	public static int getSubCount(String s,String key)
	{
		int count = 0;
		int index = 0;
		while((index=s.indexOf(key,index))!=-1)
		{
			count++;
			index+=key.length();
		}
		return count;
	}
 
	//  4、获取两个字符串中最大相同子串。
 
	public static String getMaxString(String s1,String s2)
	{
		String max = (s1.length()>s2.length())?s1:s2;
		String 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 "";
	}
 
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}</span>

运行结果：

转存失败重新上传取消

3、StringBuffer及StringBuilder类

StringBuffer是字符串缓冲区。

是一个容器。

1,长度是可变化的。

2,可以直接操作多个数据类型。

3,最终会通过toString方法变成字符串。

 

C  create  U  update  R  read  D delete

1,存储。

StringBuffer append()：将指定数据作为参数添加到已有数据结尾处。

        StringBuffer insert(offset,数据)：可以将数据插入到指定offset位置。

 

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。

 

升级的三个因素：提高效率、简化书写、提高安全性。

 

代码示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class  StringBufferDemo
{
	public static void method_add() 
	{
		StringBuffer sb = new StringBuffer();
		
		sb.append("abc").append(true).append(255);
		sb.insert(1,"qq");
 
		sop(sb.toString());
	}
 
	public static void method_del() 
	{
		StringBuffer sb = new StringBuffer("abcde");
 
		//sb.delete(1,3);
 
		//清空缓冲区
		//sb.delete(0,sb.length());
 
		sb.deleteCharAt(2);
 
		sop(sb.toString());
	}
 
 
	public static void method_update() 
	{
		StringBuffer sb = new StringBuffer("abcde");
 
		//sb.replace(1,4,"java");
		sb.setCharAt(2,'k');
		sb.reverse();//5
		sop(sb.toString());
	}
 

	public static void method_6() 
	{
		StringBuffer sb = new StringBuffer("abcdef");
 
		char[] ch = new char[6];
 
		sb.getChars(1,4,ch,1);
 
		for (int x=0; x<ch.length; x++)
		{
			sop("ch["+x+"]="+ch[x]+";");
		}
	}

	public static void main(String[] args) 
	{
		method_add();
		method_del();
		method_update();
		method_6();
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}</span>

运行结果：

转存失败重新上传取消

4、基本数据类型对象包装类

基本数据类型对象包装类。

byte         Byte

short        Short 

int            Integer

long         Long

boolean   Boolean

float         Float

double     Double

char         Character

 

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

 

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

基本数据类型+""

基本数据类型.tostring(基本数据类型值)；

如：Integer.toString(34);//将34整数变成"34";

 

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

xxx a = Xxx.parseXxx(String);

 

int a = Integer.parseInt("123");

double b = Double.parseDouble("123");

boolean b = Boolean.parseBoolean("true");

 

Integer i = new Integer("123");

int num = i.intValue;

 

十进制转成其他进制。

Integer.toBinaryString(int);

Integer.toHexString(int);

Integer.toOctalString(int);

 

其他进制转成十进制。

Integer.parseInt(String,radix);

 

代码示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class IntegerDemo 
{
	public static void main(String[] args) 
	{
		//整数类型的最大值。
		sop("int max:"+Integer.MAX_VALUE);
		//将一个字符串转成整数。
		int num = Integer.parseInt("123");
		sop("num="+(num+1));
		
		//十进制转成其他进制。
		sop(Integer.toBinaryString(6));
		sop(Integer.toHexString(60));
 
		//其他进制转成十进制。
		sop(Integer.parseInt("3c",16));
 
	} 
 
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}</span>

运行结果：

转存失败重新上传取消

基本数据类型对象包装类。

JDK1.5版本以后出现的新特性。

<span style="font-family:Microsoft YaHei;font-size:14px;">class IntegerDemo1 
{
	public static void main(String[] args) 
	{
		//Integer x = new Integer(4);
		Integer x = 4;//自动装箱。等同于new Integer(4)
		x = x + 2;//x+2:x 进行自动拆箱x.intValue()。变成了int类型，和2进行加法运算。
				  //再将和进行装箱赋给x。			
		
		Integer m = 128;
		Integer n = 128;
		sop(m==n);//false
 
		Integer a = 128;
		Integer b = 128;
		sop(a==b);//true 因为a和b指向了同一个Integer对象。
				  //对于新特性，当数值在byte范围内时，如果该数值已经存在，则不会再开辟新的空间。

	} 
	public static void method()
	{
		Integer x = new Integer("123");
		Integer y = new Integer(123);
 
		sop(x==y);//false
		sop(x.equals(y));//true
	}
 
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}</span>

例：对一个字符串中的数值进行从小到大的排序。

<span style="font-family:Microsoft YaHei;font-size:14px;">import java.util.*;
import java.util.Scanner;
/*
对一个字符串中的数值进行从小到大的排序。
“20 78 9 -7 88 36 29”
*/
class StringSort   
{
	public static void main(String[] args) 
	{
		String s = "20 78 9 -7 88 36 29";
		sop(s);
		s = sortString(s);
		sop(s);
	}
 
	public static String sortString(String s)
	{
		//将字符串变成字符串数组。
		String[] str_arr = stringToArray(s);
 
		//将字符串数组变成int数组。
		int[] int_arr = toIntArray(str_arr);
 
		//对int数组排序。
		mySortArray(int_arr);
 
		//将排序后的数组变成字符串。
		String temp = arrayToString(int_arr);
 
		return temp;
	}
 
	public static String[] stringToArray(String s)
	{
		String[] arr = s.split(" ");
		return arr;
	}
 
	public static int[] toIntArray(String[] str_arr)
	{
		int[] arr = new int[str_arr.length];
		for (int i=0; i<arr.length; i++)
		{
			arr[i] = Integer.parseInt(str_arr[i]);
		}
		return arr;
	}
 
	public static void mySortArray(int[] int_arr)
	{
		Arrays.sort(int_arr);
	}
 
	public static String arrayToString(int[] int_arr)
	{
		StringBuilder sb = new StringBuilder();
		for (int x=0; x<int_arr.length; x++)
		{
			if (x!=int_arr.length-1)
				sb.append(int_arr[x]+" ");
			else
				sb.append(int_arr[x]);
		}
		return sb.toString();
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}</span>

运行结果：

转存失败重新上传取消