黑马程序员————String类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！-------

一、String类

1.基本的知识

字符串是一个特殊的兑现

字符串一但被初始化就不会被改变

String s1 = "abc";
String s2 = "abc";
System.out.println(s1==s2);//true
因为"abc"存储在字符串常量池中，常量池里面有"abc"，就不会被创建了

String s1 = "abc";
String s2 = new String("abc");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true

因为String s2 = new String("abc");堆内创建两个对象；String s1 = "abc";在常量池中创建一个对象，所以地址不同。
而String中的equals方法复写了Object中equals的方法，它比较是字符串的内容而不是地址。

2.构造函数

String s = new String();等效于String s = "";而不等效于String s = null;

将字节数组变字符串

byte[] arr = {98,67,68,69};
String s = new String(arr);
System.out.println(s);	//bCDE

char[] arr1 = {'w','a','b','d'};
String s2= new String(arr1,1,3);
System.out.println(s2);	//bcd

3.常见的方法

1.获取：

1.1 获取字符串中字符的个数(长度).

int length();

1.2 根据位置获取字符。

char charAt(int index);

1.3 根据字符获取在字符串中的第一次出现的位置.

int indexOf(int ch)
int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
int indexOf(String str);
int indexOf(String str,int fromIndex);根据字符串获取在字符串中的第一次出现的位置.
int lastIndexOf(int ch)
int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
int lastIndexOf(String str);
int lastIndexOf(String str,int fromIndex);

1.4 获取字符串中一部分字符串。也叫子串.

String substring(int beginIndex, int endIndex)//包含begin 不包含end 。
String substring(int beginIndex);

2.转换。

2.1 将字符串变成字符串数组(字符串的切割)

String[]  split(String regex):涉及到正则表达式.

2.2 将字符串变成字符数组。

char[] toCharArray();

2.3 将字符串变成字节数组。

byte[] getBytes();

2.4 将字符串中的字母转成大小写。

String toUpperCase():大写
String toLowerCase():小写

2.5 将字符串中的内容进行替换

String replace(char oldch,char newch);
String replace(String s1,String s2);

2.6 将字符串两端的空格去除。

String trim();

2.7 将字符串进行连接 。

String concat(string);

3.判断

3.1 两个字符串内容是否相同啊？

boolean equals(Object obj);
boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。

3.2 字符串中是否包含指定字符串？

boolean contains(string str);

3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。

boolean startsWith(string);
boolean endsWith(string);

4.比较。

代码的体现：

package string;

public class StringDemo {

/**
* @param args
*/
public static void main(String[] args) {
// demo_1();
// demo_2();
// demo_3();

System.out.println(String.valueOf(3) + 1);// 41

}

// 获取
private static void demo_1() {
String s = "abcd";
// 获取字符串字符的个数(长度)
System.out.println(s.length());// 4
// 根据位置获取字符
System.out.println(s.charAt(2));// c
// 根据字符获取在字符串中第一次出现的位置
System.out.println(s.indexOf('a'));// 0
System.out.println(s.indexOf('d', 1));// 3
System.out.println(s.indexOf("cd"));// 2,返回的是子串第一个字符出现的位置
System.out.println(s.indexOf("bc", 0));// 1
System.out.println(s.lastIndexOf('c'));// 2
}

// 转换
private static void demo_2() {
String s = "小明，小红，小南";
// 将字符串变成字符串数组
String[] arr = s.split(",");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);// 小明，小红，小南
}
// 将字符串变成字符数组
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);// 小  明 ， 小 红 ， 小  南
}
// 将字符串变成字节数组
s = "ab你";
byte[] bytes = s.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);// 97 98 -60 -29
}
// 将字符串中的字母变成大小写

System.out.println("abcDEF".toLowerCase());// 变小写
System.out.println("abcDEF".toUpperCase());// 变大写

// 将字符串中的内容进行替换
String s1 = "hool";
String s3 = s1.replace('o', 'd');// 将s1中的所有的o被d替换
System.out.println(s3);
// 清除两端的空格
System.out.println("-" + "    b  hj  a    ".trim() + "-");// -b hj a-
// 将字符串进行连接
System.out.println(s.concat(s1));// ab你hool

System.out.println("kk" + "cc");

}

// 判断
private static void demo_3() {
// 判断两个字符串内容是否相同
String s = "abc";
System.out.println(s.equals("bca"));// false
System.out.println(s.equalsIgnoreCase("ABC"));// true忽略大小写判断

// 字符串是否包含指定字符串
System.out.println(s.contains("bb"));// false

// 字符串是否以指定字符串开头，是否以指定的字符串结尾
String str = "ExceptionDemp.java";
System.out.println(str.startsWith("ExceptionDemp"));// true
System.out.println(str.endsWith(".jave"));// false

}

4.例子

例子1：

给定一个字符串数组。按照字典顺序进行从小到大的排序。

{"nba","abc","cba","zz","qq","haha"}

思路：

1.对数组排序。可以用选择，冒泡都行。

2.for嵌套和比较以及换位

3.而字符串比较用到compareTo方法

package string;

public class TestDemo {
/**
* @param args
*/
public static void main(String[] args) {
String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };
printArray(arr);
sortString(arr);
printArray(arr);

}
public static void sortString(String[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {

if(arr[i].compareTo(arr[j])>0)
swap(arr,i,j);
}
}
}
private static void swap(String[] arr, int i, int j) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArray(String[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
System.out.print(arr[i] + ", ");
else
System.out.println(arr[i] + "]");
}
}
}

例子2：一个子串在整串中出现的次数。 "nbaernbatynbauinbaopnba"

思路：

1.要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。

2.如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，而剩余字符串的起始位是出现位置+子串的长度.

3.以此类推，通过循环完成查找，如果找不到就是-1，并对 每次找到用计数器记录。

package string;
public class TestDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
String str = "nbaernbatnbaynbauinbaopnba";
String key = "nba";
int count = getKeyStringCount_2(str,key);
System.out.println("count="+count);
}
public static int getKeyStringCount_2(String str, String key) {
int count = 0;
int index = 0;
while((index = str.indexOf(key,index))!=-1){
index = index + key.length();
count++;
}
return count;
}
// 获取子串在整串中出现的次数。
public static int getKeyStringCount(String str, String key) {
//1.定义计数器。
int count = 0;
//2.定义变量记录key出现的位置。
int index = 0;
while((index = str.indexOf(key))!=-1){
str = str.substring(index+key.length());
count++;
}
return count;
}}

例子3：两个字符串中最大相同的子串。

"qwerabcdtyuiop"

"xcabcdvbn"

思路：

1.既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。如果存在，短的那个字符串就是最大子串。

2.如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。如果存在就已找到，就不用在找了。

package string;
public class TsetDemo3 {
/**
* @param args
*/
public static void main(String[] args) {
String s1 = "qwerabcdtyuiop";
String s2 = "xcabcdvbn";
String s = getMaxSubstring(s2, s1);
System.out.println("s=" + s);
}
public static String getMaxSubstring(String s1, String s2) {
String max = null,min = null;
max = (s1.length()>s2.length())?s1:s2;
min = max.equals(s1)?s2:s1;
System.out.println("max="+max);
System.out.println("min="+min);
for (int i = 0; i < min.length(); i++) {
for(int a = 0,b = min.length()-i; b != min.length()+1; a++,b++){
String sub = min.substring(a, b);
if(max.contains(sub))
return sub;
}
}
return null;
}

}

二、字符串缓冲区

StringBuffer

用于存储数据的容器

特点：

（1）长度可变

（2）可以存储不同类型数据

（3）最终转成字符串进行处理

（4）可以对字符串进行修改

功能：

1.添加

StringBuffer append(data);

StringBuffer insert(index,data);

2.删除

StringBuffer delete(start,end):包含头，不包含尾。

StringBuffer deleteCharAt(int index):删除指定位置的元素

3.查找

char charAt(index);

int indexOf(string);

int lastIndexOf(string);

4.修改

StringBuffer replace(start,end,string);

void setCharAt(index,char);

代码体现：

package string;
public class StringBufferDemo {

/**
* @param args
*/
public static void main(String[] args) {
//demo_1();
//demo_2();
//demo_3();
demo_4();
}
//修改,方法的结果在之前操作的基础上
private static void demo_4() {
StringBuffer sb = new StringBuffer("abcdgr");
System.out.println(sb.replace(0, 2, "nba"));//nbacdgr
sb.setCharAt(0, 'q');//qbacdgr
System.out.println(sb);
sb.setLength(3);
System.out.println("sb:"+sb);//sb:qba
System.out.println("length:"+sb.length());//length:3
System.out.println(sb.reverse());//abq
}
//查找，其他方法参考String类
private static void demo_3() {
StringBuffer sb = new StringBuffer("abcdef");
System.out.println(sb.charAt(3));
}
//删除
private static void demo_2() {
StringBuffer sb = new StringBuffer("abcd");
sb.delete(0, 2);//cd
sb.delete(0, sb.length());//清空缓冲区
System.out.println(sb);
}
//添加
private static void demo_1() {
StringBuffer sb = new StringBuffer();
sb.append("ab");
sb.append("cd").append(4);
sb.append("ef");
sb.insert(3, "哈哈");
sb.append(true);
System.out.println(sb);//abc哈哈d4eftrue
}
}

StringBuilder

和StringBuffer的区别

功能时一模一样，用法也是一模一样

StringBuffer：线程同步的。通常用于多线程

StringBuilder：线程是不同步的。通常用于单线程，提高了效率

例子：

将一个int数组变成字符串。

package string;
public class StringBuilderDemo {
/**
* @param args
*/
public static void main(String[] args) {
int[] arr = { 7, 9, 2, 7, 6 ,3};
String s = arrayToString_2(arr);
System.out.println(s);
}
//用缓冲区
public static String arrayToString_2(int[] arr) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
sb.append(arr[i] + ", ");
else
sb.append(arr[i] + "]");
}
return sb.toString();
}
//以前不同缓冲区
public static String arrayToString(int[] arr) {
String str = "[";
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
str += arr[i] + ", ";//连接一个“，”就产生一个字符串常量池成员
else
str += arr[i] + "]";
}
return str;
}
}

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！-------