黑马程序员——String类、基本数据类型包装类

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

String类

基本概念：

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

public class StringDemo {
public static void main(String[] args) {
String s1 = "abc";//s1是一个类类型变量， "abc"是一个对象。
s1 = "kkk";
System.out.println(s1);
//虽然此处会输出kkk,但是并不是abc字符串变了，而是s1变了，指向了新的字符串常量kkk。abc这个对象的内容并未改变

String s2 = new String("kkk");//String构造函数中有一个可以传字符串的构造函数
/*s1和s2有什么区别:虽然使用起来一样，但：
s1在内存中有一个对象。
s2在内存中有两个对象。
*/
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));//true
//String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。
//Object类中原来的equals方法是用来比较内存中的地址值的。
}
}

常用操作方法：

获取

1，字符串长度

      int length()

2，位置->字符
char charAt(int index):

3，字符->位置

int indexOf(int ch)：返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch, int fromIndex) ：从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int lastIndexOf(int ch) ：返回ch在字符串中最后一次出现的位置。

4，子串->位置
int indexOf(String str)：返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex) ：从fromIndex指定位置开始，获取str在字符串中出现的位置。

4，位置->子串

String substring(begin)  
String substring(begin,end) 

<pre name="code" class="java">package String;
class  StringMethodDemo
{
public static void method_get()
{
String str = "abcdeatpf";

//长度
sop(str.length());//输出：9

//位置->字符。
sop(str.charAt(4));//输出：e，说明从0开始
//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。

//字符->位置
sop(str.indexOf('m',3));//输出：-1
//如果没有找到，返回-1.

//反向字符->索引
sop(str.lastIndexOf("a"));//输出：5

//子串->位置。
sop(str.indexOf("eat",2));//输出：4
//从该字符串的第3位开始找eat这个子串，返回的是eat子串的第一个字符的位置

//位置->子串
sop(str.substring(3, 4));//输出：d（包含头，不包含尾）str.substring(0,str.length())可获得整个字符串
sop(str.substring(3,8));//输出:deatp
}
public static void main(String[] args)
{
method_get();
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

判断

1，有无子串？

boolean contains(str):（既要判断又要拿位置用str.indexof("str")）

2，有无内容？

boolean isEmpty(): 原理就是判断长度是否为0. 

3，是否以指定内容开头或结尾？

boolean startsWith(str);

boolean endsWith(str);

4，内容是否相同？

boolean equals(str);（复写了Object类中的equals方法。）

boolean equalsIgnoreCase();（忽略大小写的判断）

package String;

class  StringMethodDemo
{

public static void method_is()
{
String str = "ArrayDemo.java";
String str2 = "ARRAYDEMO.JAVA";

//有无内容？
sop(str.isEmpty());//false

//有无子串？
sop(str.contains("java"));//true//如果有一个文件Demo.java.txt，contains返回true,而endsWith返回false

//判断文件名称是否是Array单词开头。
sop(str.startsWith("Array"));//true

//判断文件名称是否是.java的文件。
sop(str.endsWith(".java"));//true

//内容是否相同？
sop(str.equals(str2));//false
sop(str.equalsIgnoreCase(str2));//true
}

public static void main(String[] args)
{
method_is();
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

转换

1，字符数组->字符串


构造函数：String(char[]) 字符串初始化时就可以使用String的构造函数将字符数组转成字符串

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

5，基本数据类型->字符串。


static String valueOf(int)

static String valueOf(double)

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

package String;

class  StringMethodDemo
{

public static void method_trans()
{
//字符数组->字符串
char[] arr = {'a','b','c','d','e','f'};
//直接全部转
String c2a_1 = new String(arr);
sop("s = " + c2a_1);//输出：s = abcdef

//转指定位置的一部分
String c2a_2 = new String(arr,1,3);
sop("s = " + c2a_2);//输出：s = bcd

//使用静态方法copyValueOf
String sta_c2a = String.copyValueOf(arr);//此处使用valueOf(arr)效果一致，但valueOf还能将基本数据类型转成字符串
sop("s = " + sta_c2a);

//字符串->字符数组
String s1 = "zxcvbnm";
//转换
char[] chs = s1.toCharArray();
//打印
for(int x = 0; x < chs.length; x++)
{
sop("ch="+chs[x]);
}
/*
ch=z
ch=x
ch=c
ch=v
ch=b
ch=n
ch=m
*/

//字符串->字节数组
String s2 = "zdf32432";
//转换
byte[] bytes = s2.getBytes();//byte[]不能写成Byte[]
//打印
for(int x = 0; x < bytes.length; x++){
sop("byte = " + bytes[x]);
}
/*
byte = 122
byte = 100
byte = 102
byte = 51
byte = 50
byte = 52
byte = 51
byte = 50
*/
}

public static void main(String[] args)
{
method_trans();
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

替换

String replace(oldchar,newchar)  

String replace(CharSequence target, CharSequence replacement) 

packa
dca9
ge String;

class  StringMethodDemo
{

public static void method_replace()
{
String s = "hello java";

String s2 = s.replace('q','n');//如果要替换的字符不存在，返回的还是原串。
sop("s2 = " + s2);//输出：s2 = hello java

String s1 = s.replace("java","world");
sop("s = "+s);//字符串一旦初始化不会被改变。输出：s = hello java
sop("s1 = "+s1);//输出：s1 = hello world
}

public static void main(String[] args)
{
method_replace();
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

切割

String[] split(regex);

class  StringMethodDemo
{
public static void  method_split()
{
String s = "zhagnsa,lisi,wangwu";
String[] arr  = s.split(",");//定义了一个字符串数组，根据逗号切割s字符串，逗号作为切割符
//把切割完的字符串子串分别存到该字符串数组中

for(int x = 0; x < arr.length; x++)
{
sop(arr[x]);//打印该数组
/*
zhagnsa
lisi
wangwu
*/
}
}
public static void main(String[] args)
{
method_split();
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

处理与比较

1，大写<->小写。  

String toUpperCase()  

String toLowerCase()  

2，去除两端的多个空格  

String trim() 

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

int compareTo(string)  

package String;
class  StringMethodDemo
{
public static void method_others()
{
String s = "    Hello Java     ";
//大写 <-> 小写
sop(s.toLowerCase());//输出："    hello java     "
sop(s.toUpperCase());//输出："    HELLO JAVA     "

//去除空格
sop(s.trim());//输出："Hello Java"

//比较
String s1 = "a1c";
String s2 = "aaa";
String s3 = "abc";

/*
小于返回负数，大于返回正数
*/
sop(s1.compareTo(s2));//输出：-48（1是49，a是97，此处第一位一样，然后从第二位开始比较）
sop(s2.compareTo(s3));//输出：-1
sop(s3.compareTo(s2));//输出：1（a是97，b是98，b比a大1，所以abc比aaa大1）
}

public static void main(String[] args)
{
method_others();
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

字符串常用操作方法的应用

模拟trim方法

package String;

class StringTest
{

public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = "      ab cd      ";

sop("("+s+")");//输出：(      ab cd      )
s = myTrim(s);
sop("("+s+")");<span style="font-family: Arial, Helvetica, sans-serif;">//输出：(ab cd)</span>
}

public static String myTrim(String str)
{
int start = 0,end = str.length()-1;//因为脚标是从0开始的，最末尾的元素的脚标是"长度-1"

while(start <= end && str.charAt(start) == ' ')//当str的值为""时，start == end
start++;

while(start <= end && str.charAt(end) == ' ')
end--;

return str.substring(start,end+1);//取的时候包含头，不包含尾，如果要把end处的元素也取入，需要end加1
}
}

将字符串进行反转

思路：

1，将字符串变成数组。

2，对数组反转。

3，将数组变成字符串。

class StringTest
{

public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = "012345";

sop("("+s+")");//输出：(012345)
sop("("+reverseString(s)+")");//输出：(543210)
sop("("+reverseString(s,0,2)+")");//输出：(102345) 012->102,说明转的范围不包含尾，因为一般尾代表是整个长度，比最后脚标大1
sop("("+reverseString(s,1,4)+")");//输出：(032145) 1234 -> 3214
}

public static String reverseString(String s,int start,int end)//倒转指定部分
{
//1，字符串变数组
char[] chs = s.toCharArray();//存在名为chs的字符数组中

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

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

public static String reverseString(String s)//重载的函数
{
return reverseString(s,0,s.length());
}

//反转数组的方法
private static void reverse(char[] arr,int x,int y)
{
for(int start = x,end = y-1; start < end ; start++,end--)//整个倒转时的写法：start = 0, end = arr.length -1
{
swap(arr,start,end);//end代表最后一个脚标
}
}

获取一个字符串在另一个字符串中出现的次数

思路：

1，定义个计数器。

2，获取子串第一次出现的位置。

3，从第一次出现位置后剩余的字符串中继续获取子串出现的位置。每获取一次就计数一次。

4，当获取不到时，计数完成。

package String;

class  StringTest2
{
//练习三， 方法一："kk"所截子串的脚标
public static int getSubCount(String str,String key)
{
int count = 0;//初始化一个计数器
int index = 0;//记录索引的值

while((index = str.indexOf(key))!=-1)//index[0] = 0;
{
sop("str="+str);
str = str.substring(index+key.length());
//根据子串的起始位置返回子串。第一次是str.substring(0 + 2),从脚标2开始返回，包含头

count++;	//计数器加1，记录获得到的子串个数
}
return count;
}

//练习三，方法二：仅跳"kk"的脚标

public static int getSubCount_2(String str,String key)
{
int count = 0;
int index = 0;

while((index = str.indexOf(key,index))!=-1)//对比：while((index = str.indexOf(key))!=-1)
{
sop("index = " + index);//对比：sop("str="+str);
index = index + key.length();//对比：str = str.substring(index+key.length());
//System.out.println(str.indexOf("kk", 2)),结果是4，含义是第二次出现kk时的脚标的值是4

count++;
}
return count;
}

public static void main(String[] args)
{
String str = "kkabkkcdkkefkks";
///sop("count====="+str.split("kk").length);不建议使用。

sop("count = " + getSubCount(str,"kk"));
/*
str=kkabkkcdkkefkks
str=abkkcdkkefkks
str=cdkkefkks
str=efkks
count = 4
*/

sop("count="+getSubCount_2(str,"kk"));
/*
index=0
index=4
index=8
index=12
count=4
*/
}

public static void sop(String str)
{
System.out.println(str);
}
}

求两个字符串最大相同的子串

思路：

1，将短的那个子串按照长度递减的方式获取到。

2，将每获取到的子串去长串中判断是否包含，如果包含，已经找到。

package String;

class  StringTest3
{
/*
练习四。
*/
public static String getMaxSubString(String s1,String s2)
{

String max = "",min = "";//初始化了两个变量max和min

//以下语句是为了让max是s1,min是s2
max = (s1.length()>s2.length())?s1: s2;
min = (max==s1)?s2: s1;

//		sop("max="+max+"...min="+min);

/*
0到length-0:1
0到length-1:11
0到length-2:111
0到length-3:1111
*/
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);

//sop(temp);
/*
sop(temp)的输出结果：
cvhellobnm
cvhellobn
vhellobnm
cvhellob
vhellobn
hellobnm
cvhello
vhellob
hellobn
ellobnm
cvhell
vhello
hellob
ellobn
llobnm
cvhel
vhell
hello
*/
//这句语句的意思是，如果长的字符串中含有短的字符串中截取出的最大的子串，则返回该子串
if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
return temp;
}
}
return "";//从debug情况看，此处的return并没有执行到，在内循环时，已经return了temp，这里写null也没事
}

public static void main(String[] args)
{
String s1 = "abcwerthelloyuiodef";
String s2 = "cvhellobnm";
sop(getMaxSubString(s2,s1));
}

public static void sop(String str)
{
System.out.println(str);
}
}

StringBuffer

基本概念

StringBuffer是字符串缓冲区，是一个容器。

特点：

1，长度是可变化的。

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

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

C create 增 U update 改 R read 查D delete删

常用操作方法

增加：

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

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

尝试1：在StringBuffer中添加元素
因为sb和sb1都是指向同一个对象，没有必要通过这种方式来添加元素

class StringBufferDemo
{
public static void main(String[] args)
{

StringBuffer sb = new StringBuffer();
StringBuffer sb1 = sb.append(34);
sop(sb.toString());//34
sop(sb1.toString());//34
sop("sb == sb1: " + (sb == sb1));//sb == sb1: true
//sb 和 sb1 指向同一个对象，盆还是那个盆

}

public static void sop(String str)
{
System.out.println(str);
}

}

改进：

package String;

class StringBufferDemo
{
public static void main(String[] args)
{

StringBuffer sb = new StringBuffer();
//append方法
sb.append("abc").append(34).append(true);//方法调用链，因为sb.append("abc")方法执行之后，返回的还是本类的对象
sop(sb.toString());//输出：abc34true,将指定数据作为参数添加到已有数据结尾处。

//StringBuffer sb1 = sb.append(34);
//insert方法
sb.insert(1, "bac");
sop(sb.toString());//输出：abacbc34true，插入在1脚标位置,其后顺延
}

public static void sop(String str)
{
System.out.println(str);
}

}

删除：

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

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

package String;

class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb  = new StringBuffer("abcde");
sop(sb.toString());//输出：abcde

//delete(start,end)
sb.delete(1,3);
sop(sb.toString());//输出：ade
//脚标从1开始，1、2的元素被删除。包含头，不包含尾。
//清空缓冲区：sb.delete(0,sb.length());
//sb.delete(2,3);//StringIndexOutOfBoundsException

//deleteCharAt(index)
sb.deleteCharAt(2);
sop(sb.toString());//输出：ad
//脚标为2的字符被删除

}

public static void sop(String str)
{
System.out.println(str);
}

}

获取：

char charAt(int index) 

int indexOf(String str) 

int lastIndexOf(String str) 

int length() 

String substring(int start, int end) ：该方法返回的是String，而不是StringBuffer

该部分内容与String中获取的用法一致

修改：

StringBuffer replace(start,end,string);

void setCharAt(int index, char ch) ;

class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb  = new StringBuffer("abcde");
//replace(start,end,string);
sb.replace(1,4,"java");//不包含尾，则脚标从1-3的三个元素bcd被替换成了java
sop(sb.toString());//输出：ajavae

//setCharAt(int index, char ch) ;
sb.setCharAt(2,'k');//脚标为2的元素替换为k,该方法不返回StringBuffer，替换完就结束
sop(sb.toString());//输出：ajkvae

}

public static void sop(String str)
{
System.out.println(str);
}

}

反转：

StringBuffer reverse();

class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb  = new StringBuffer("abcde");
//StringBuffer reverse();
sb.reverse();
sop(sb.toString());//输出：edcba
}

public static void sop(String str)
{
System.out.println(str);
}
}

特殊增加：

将缓冲区中指定数据存储到指定字符数组中

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 

class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb  = new StringBuffer("abcde");
char[] chs = new char[6];
sb.getChars(1,4,chs,1);//把abcde中1-3脚标对应的字符，在chs字符数组中脚标为1的位置插入存储

for(int x = 0; x < chs.length; x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
/*
chs[0]=
chs[1]=b;
chs[2]=c;
chs[3]=d;
chs[4]=
chs[5]=
*/
}
public static void sop(String str)
{
System.out.println(str);
}
}

StringBuilder

JDK1.5 版本之后出现了StringBuilder.
StringBuffer和StringBuilder区别：


StringBuffer是线程同步。

StringBuilder是线程不同步。

以后开发，建议使用StringBuilder

基本数据类型包装类

基本概念

将基本数据类型封装成对象的好处，在于可以在对象中定义更多的功能方法操作该数据。

byte Byte

short short

int Integer

long Long

boolean Boolean

float Float

double Double

char Character

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

常用方法

基本数据类型转字符串

/*
基本数据类型 + ""

基本数据类型.toString(基本数据类型值);
*/
34 + "";
Integer.toString(34);//将34整数变成"34";

字符串转基本数据类型

//xxx a = Xxx.parseXxx(String);静态转换方式
int a = Integer.parseInt("123");
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
//先把字符串或者整数封装成Interger对象，然后用intValue返回该Interger的值
Integer i = new Integer("123");
int num = i.intValue();//intValue：以int类型，返回该Interger的值