黑马程序员—JAVA基础—String类 javaAPI学习

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
1、概念：String是java中字符串封装类。
2、String str = "abc";和String str = new String("abc");这两句代码都可以初始化String对象，当前者只有一个对象，而后者存在两个对象，"abc"是一个String对象，一旦初始化就不能改变。
示例：

class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
System.out.println(s1==s2);
//运行结果为true，因为"abc"这个对象已经存在，实际上
//s1和s2是指向同一个对象
System.out.println(s1==s3);
//运行结果为false，s3中是使用了new，实际上是两个对象，
//所以s1和s3指向不同对象
System.out.println(s1.equals(s3));
//运行结果为true，因为String复写了Object中的equals方法，
//可以用来比较内容是否相同
}
}

3、常用方法：
获取：
int length()：获取字符串的长度
char charAt(int index)：获取某个位置上的字符
int indexOf(int ch)：获取ch在字符串中第一次出现的位置
int indexOf(int ch, int fromIndex)：从fromIndex处开始索引，获取ch在字符串中的位置
int indexOf(String str)：获取str在字符串中第一次出现的位置
int indexOf(Stirng str,int fromIndex)：从fromIndex开始索引，获取str出现的位置



这四个方法是从字符串反向索引。
示例：

class StringMethodDemo
{
public static void main(String[] args)
{
String s = "abcdeafg";

System.out.println("字符串的长度为："+s.length());
System.out.println(s.indexOf('a'));
System.out.println(s.indexOf('a',4));
System.out.println(s.indexOf("de"));
System.out.println(s.indexOf("de",2));
}
}

判断：

boolean contains(CharSequence s)：判断字符串是否包含某个字符
boolean startsWith(String suffix)：判断字符串是否以某字符串开头
boolean startsWith(String suffix,int toffset)：从指定索引位置开始，判断字符串是否以某字符串开头

boolean endsWith(String suffix)：判断字符串是否以某字符串结尾
boolean equals(Object anObject)：将字符串与其他对象比较
boolean equalsIgnoreCase(String anotherString)：将字符串与其他字符比较，并忽略大小写
示例

class StringMethodDemo
{
public static void main(String[] args)
{
String s = "StringMethodDemo.java";
String s2 = "STRINGMETHODDEMO.JAVA";

System.out.println(s.startsWith("String"));//true
System.out.println(s.startsWith("Method",6));//true
System.out.println(s.endsWith(".java"));//true
System.out.println(s.equalsIgnoreCase(s2));//true
}
}

转换：
将字符数组转为字符串
通过构造函数
String(char[] value)：将字符数组转为字符串
String(char[] value, int offset, int count)：将字符数组的一部分转为字符串
通过静态方法：
static String copyValueOf(char[] data)：将字符数组转为字符串

static String copyValueOf(char[] data, int offset, int count) ：将字符数组的一部分转为字符串
static String valueOf(char[] data, int offset, int count)：将字符数组的一部分转为字符串
将字符串转换为字符数组
char[] toCharArray()
将字节数组转成字符串
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串
将字符串转成字节数组
byte[] getBytes()
将基本数据类型转成字符串

static String valueOf(基本数据类型)

示例：

class StringMethodDemo
{
public static void main(String[] args)
{
char[] ch = new char[]{'a','b','c','d','e'};
String s1 = new String(ch);
String s2 = new String(ch,1,4);
System.out.println(s1);//abcde
System.out.println(s2);//bcde

String s3 = String.valueOf(ch);
System.out.println(s3);//abcde
}
}

替换：
String replace(oldchar,newchar);

切割：
String[] split(regex);

获取子串
String substring(begin);从开始到字符串末尾
String substring(begin,end);从开始到自定义结尾，包含头不包含尾

转换，去除空格，比较

将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
将字符串两端的多个空格去除。
String trim();
对两个字符串进行自然顺序的比较。
int compareTo(string);
示例：

class StringMethodDemo
{
public static void main(String[] args)
{
String s = "   holle java   ";
String s2 = "String Method Demo";
System.out.println(s.replace('l','j'));//hojje java
System.out.println(s.substring(3));//holle java
System.out.println(s.substring(3,8));//holle
System.out.println(s.toUpperCase());//HOLLE JAVA
System.out.println(s.toLowerCase());//holle java
System.out.println(s.trim());//holle java
String[] arr = s2.split(" ");
for (int x=0; x<arr.length; x++)
{
System.out.println(arr[x]);
//String
//Method
//Demo
}
}
}

练习1：模拟String类中trim方法，去除字符串两端的空格

/*
去除字符串两端的空格
定义两个指针，一个从字符串头开始判断是否是空格，一个从尾开始
判断是否是空格，如果是空格就继续判断，知道两端都是不是空格，
就取两个指针之间的内容。
*/
public static String myTrim(String s)
{
int start = 0;//从头判断的指针
int end = s.length()-1;//从尾判断的指针
//while循环判断多次,并且保证start小于end
while (start<end && s.charAt(start)==' ')
{
start ++;
}
while (start<end && s.charAt(end)==' ')
{
<span style="white-space:pre">	</span>end --;
}
return s.substring(start,end+1);
//end+1的原因是substring方法中两个参数是包含头不包含尾
}

练习2：将字符串进行反转

/*
将字符串进行反转
首先将字符串转化为字符数组，将字符数组进行反转后再转化为字符串
*/
//将整个字符串进行反转
public static String myReverse(String s)
{
return myReverse(s,0,s.length());
}
//指定开始和结束位置，将字符串进行反转
public static String myReverse(String s,int start,int end)
{
char[] ch = s.toCharArray();//将字符串转化为字符数组
reverse(ch,start,end);//反转字符数组的方法
return String.valueOf(ch,start,end);//将反转后的字符数组转化为字符串

}
//反转字符数组的方法
public static void reverse(char[] arr,int x,int y)
{
for (int start=x,end=y-1; start<end; start++,end--)
{
swap(arr,start,end);
}
}
//数组换位方法
public static void swap(char[] arr,int x,int y)
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}

联系3：获取一个字符串在另一个字符串中出现的次数

/*
获取一个字符串在另一个字符串中出现的次数
*/
//方法一：不断改变字符串的长度
public static int getShowCount(String s,String key)
{
int count = 0;//定义计数器记录出现的次数
int index = 0;//记录出现的位置，以便减少字符串的长度
while ((index = s.indexOf(key))!=-1)
{
//截取出现位置的后一位到末尾，再进行判断
s = s.substring(index+key.length());
count ++;
}
return count;
}
//不断改变开始索引的位置
public static int getShowCount_2(String s,String key)
{
int count = 0;
int index = 0;
while ((index = s.indexOf(key,index))!=-1)
{
//改变索引的位置
index = index + key.length();
count ++;
}
return count;
}

练习4：获取两个字符串中最大相同子串

/*
获取两个字符串中最大相同子串
将一个字符串从完整到不断缩小长度，与另外一个字符串比较，看另外一个字符串
是否包含这个字符串或者子串
*/
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;
}
<span style="white-space:pre">	</span>}
}
return "没有相同子串";
}

练习5：对字符串中字符进行自然顺序排序

/*
将字符串进行自然排序
将字符串转为字符数组，排序后在转换为字符串
*/
public static String mySort(String s)
{
char[] ch = s.toCharArray();
//Arrays.sort(ch); 可以直接使用java提供的工具类
for (int x=0; x<ch.length-1; x++)
{
for (int y=x+1; y<ch.length; y++)
{
if (ch[x]>ch[y])
{
swap(ch,x,y);
}
}
}
return String.valueOf(ch);
}
//数组换位方法
public static void swap(char[] arr,int x,int y)
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}

练习6：

/*
"12 0 99 -7 30 4 100 13"
要求对字符串中的数值进行排序。生成一个数值从小到大新字符串。
"-7 0 4 12 13 30 99 100"
*/
public static String mySort_2(String s)
{
String[] arr = s.split(" ");
for (int x=0; x<arr.length-1; x++)
{
for (int y=x+1; y<arr.length; y++)
{
if (Integer.parseInt(arr[x])>Integer.parseInt(arr[y]))
{
swap(arr,x,y);
}
}
}
StringBuilder sb  = new StringBuilder();
for (int x=0; x<arr.length; x++)
{
if (x!=arr.length-1)
<span style="white-space:pre">	</span>sb.append(arr[x]+" ");
else
<span style="white-space:pre">	</span>sb.append(arr[x]);

}
return sb.toString();
}
public static void swap(String[] arr,int a,int b)
{
String temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

4、StringBuffer和StringBuilder对象：
两者都是字符缓冲区对象，前者线程是同步的，后者线程是不同步的。开发时使用后者，如果是多线程，可以自己加同步。
特点：长度是可以变化的；可以操作多种数据类型；可以通过toString方法转换为字符串
常用方法：
存储操作：
append() 将数据添加到已有数据的末尾处
insert(index,数据) 在指定位置后添加数据
删除操作：
delete(start,end) 删除缓冲区的内容，包含头不包含尾
deleteCharAt(index) 删除指定位置的字符
获取操作：

char charAt(int index)  获取指定位置的某个字符
int indexOf(String str)  获取字符串在缓冲区的位置

int lastIndexOf(String str) 反向获取字符串的位置
int length() 获取缓冲区的长度

String substring(int start, int end) 截取缓冲区某一段字符串

修改操作：
replace(start,end,string) 将start和end之间的字符串替换成新的字符串
setCharAt(int index, char ch)  将指定位置的字符替换

反转：
reverse();
将缓冲区中指定数据存储到指定字符数组中
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 包含头不包含尾，指定位置开始存储到字符数组中
5、基本数据类型对象包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character

基本数据类型转成字符串
基本数据类型.toString(基本数据类型值);
例如：Byte.toString(2);

字符串转成基本数据类型：
例如：int i = Integer.parseInt("22");

注意：

Integer i1 = 128;

Integer i2 = 128;
i1 == i2//结果为true

Integer i3 = 127;
Integer i4= 127;
i3== i4;//结果为false

原因：当数值在byte范围内时，如果数值已经存在，就不再开辟空间，所以i3和i4是指向同一个对象。