黑马程序员_java_String类

  ------- android培训、java培训、期待与您交流！ ----------




一、字符串String的应用


字符串的特点：
1.String s1 = "abc";
s1是一个类类型变量，"abc"是一个对象。


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


String s2 = new String("abc");
3.s1和s2有什么区别？
s1在内存中有一个对象。
s2在内存中有两个对象。(一个是new对象，一个是构造函数中的对象)


4.String类复写了Object类中的equals方法。
该方法用于判断字符串是否相同


示例代码

class StringDemo
{
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
}
}

/*
String适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。


常见的操作有哪些呢？


1、获取
1.1 字符串中的包含的字符数，也就是字符串的长度。
int leneth(); 用返回值为int类型的无参数的函数length();来获取长度
1.2 根据位置获取位置上某个字符。
char charAt(int index); 用返回值为char类型的参数为int的函数charAt()来获取某个位置上的字符。
1.3 根据字符获取该字符在字符串中位置
int indexOf(int ch); 返回值类型为int，参数为int类型的函数来获取字符在字符串中第一次出现的位置
int indexOf(int ch, int fromIndex); 获取从某个位置(fromIndex)开始，往后某个字符(ch)所在的位置


int indexOf(String str); 返回的是某个子字符串在字符串中第一次出现的位置
int indexOf(String str, int fromIndex); 获取子字符串从某个位置开始。往后的字符串中第一次出现的位置


int lastIndexOf(int ch);  反向索引。


2、判断
2.1 字符串中是否包含某一个子串。
boolean contains(str); 
特殊之处：indexOf(str);可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含某个字符串
示例代码：
if(str.indexOf("aa") != -1)  假如aa不等于-1就说明存在于字符串中，如果要查包含字符串出现的位置
最好用indexOf


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


2.2 字符串是否有内容。
boolean isEmpty(); 原理就是判断一下字符串的长度是否为0。为0则表示没有内容
2.3 字符串是否以指定的内容开头
boolean startsWith(str); 通过该方法判断是否一此内容开头。是的话就true。反之为false
2.4 字符串是否是以指定内容结尾
boolean endsWith(str); 通过该方法判断是否一此内容结尾。是的话就true。反之为false
2.5 判断字符串内容是否相同，复写了Object类中的equals方法。
boolean equals(str); 
2.6 判断内容是否相同。并忽略大小写
boolean equalsIgnoreCase();


3.转换
3.1 将字符数组转成字符串。
构造函数：String(char[]) 把一个字符数组当成实参传递给构造函数String即可
String(char[], offset,count);将字符数组中的一部分转成字符串。offset(数组的角标起始位);count(把几个字符转换成字符串)
静态方法：
static String copyValueOf(char[]);
static String copuValueOf(char[],offest,count);和构造函数相似
3.2 将字符串转成字符数组
char[] toCharArray();
3.3 将字节数组转成字符串。
Sting(byte[]);
String(byte[],offset,count);将自己饿数组的一部分转成字符串，原理和字符数组转成字符串相似
3.4 将字符串转成字节数组
byte[] getBytes();
3.5 将基本数据类型转换成字符串
static String valueOf(int); //将int类型的数值转换成字符串
static String valueOf(double); //将double类型的数转换成字符串


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


4、替换
String replace(oldChar, newChar); //oldChar要被替换内容，newChar替换旧内容的新内容


5、切割
String[] split(regex); //把字符串切割后，返回类型是字符串数组，regex是要被切割的标记。可以是任意的字符串


6、子串，获取字符串中的一部分
String substring(begin); //这个的意思是获取从begin角标开始到字符串结束的所有字符
String substring(begin, end); //这个是获取从begin到end的字符.注：并不包括end本身所代表的角标位上的字符


7、转换，去除空格，比较。
7.1 将字符串转成大写活小写。
String toUpperCase(); //把字符串转换成大写
String toLowerCase(); //把字符串转换成小写
7.2 将字符串两端的多个空格去除。
String trim(); //调用方法就可以去除空格。
7.3 对两个字符串进行自然顺序的比较
int compareTo(String);
如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；
如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。


*/

class StringDemo1
{
public static void main(String[] args) 
{
//huoQu();
//panDuan();
//zhuanHuan();
//tiHuan();
//qieGe();
//ziChuan();
xue_7();
}


//写一个转换，去除空格，比较
public static void xue_7()
{
String s = "   Java Exception   ";
p(s.toUpperCase()); //转换成大写
p(s.toLowerCase()); //转换成小写
p(s.trim()); //去除空格
String s1 = "abc";
String s2 = "aaa";
p(s1.compareTo(s2));
}


//写一个子串的类。也就是子字符串的一部分
public static void ziChuan()
{
String s = "abcdefghij";
String s1 = s.substring(3);
String s2 = s.substring(3, 5); //包含头，不包含尾
p(s1);
p(s2);
}


//写一个切割的类。把一个字符串中的名字切割出来
public static void qieGe()
{
String s = "zhang,li,hong";
String[] s1 = s.split(",");
for(int i = 0; i < s1.length; i++)
{
p(s1[i]);
}
}


//写一个替换的函数
public static void tiHuan()
{
String s = "abcdef";
String s1 = s.replace("ab", "dd");
p(s);
p(s1);
}


//写一个字符串之间转换的函数
public static void zhuanHuan()
{
char[] arr = {'a','b','c','d','e','f','g','h','i','j','k'};
//字符数组转换成字符串
String s1 = new String(arr);
p(s1); //运用构造函数转换
p(String.copyValueOf(arr, 3, 3)); //运用静态函数转换
//字符串转换成字符数组
char[] chs = s1.toCharArray();
for(int i = 0; i < chs.length; i++)
{
p("chs = " + chs[i]);
}
}

//写一个判断字符串的函数
public static void panDuan()
{
String s = "abcdefghijabcd"; //定义字符串
String s1 = "abCdefghijabcd"; //定义字符串
p(s.contains("abc")); //查看字符串s中是否包含子字符串abc
p(s.isEmpty()); //判断字符串中是否有内容.而且没有内容返回true。有内容则返回false
p(s.startsWith("abc")); //判断字符串是否以abc开头
p(s.endsWith("bcd")); //判断字符串是否已bcd结尾
p(s.equals(s1)); //判断两个字符串是否相同
p(s.equalsIgnoreCase(s1)); //判断两个字符串中的内容是否相同
}


//写一个获取的函数
public static void huoQu()
{
String s = "abcdefghijabcd"; //定义字符串
p(s.length()); //获取字符串的长度
p(s.charAt(4)); //获取某个位置上的字符
p(s.indexOf('a')); //如果有返回位置，没有则返回-1；
p(s.indexOf('a', 3)); //获取从角标位置为3的位置起。往后的字符串中字母a所在的角标位置
p(s.indexOf("abc")); //获取字符串abc在字符串s中第一次出现的角标位置
p(s.indexOf("abc", 3)); //获取从角标3往后的字符串中子字符串第一次出现的角标位置
p(s.lastIndexOf('a')); //从后往前面查。查看字符a第一次出现的角标位置。
}


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


}








//字符串示例代码
1.去除空格示例




需求：模拟一个trim方法，去除字符串两端的空格。


思路：
1，判断字符串第一个位置是否是空格，如果继续向下判断，知道不是空格为止。
结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串


class MyTrim 
{
public static void main(String[] args) 
{
String s = "   aaa   ddd   ";
String s1 = MyTrim.myTrim(s);
System.out.println(s); //去掉空格前
System.out.println(s1); //去掉空格后
}


//写一个属于我的去掉空格的函数myTrim
public static String myTrim(String str)
{
int start = 0, end = str.length() - 1; //定义前后角标的值
while(start <= end && str.charAt(start) == ' ') //charAt就是获取字符串一个start位置上的字符
start++;
while(start <= end && str.charAt(end) == ' ')
end--;
//调用substring函数获取角标值start到end+1的字符。因为这个获取方式包含头不包含尾。所以让end+1
return str.substring(start, end + 1); 
}


}






2.字符串反转示例




需求：把一个字符串进行反转


思路：
1.把字符串变成字符数组
2.把字符数组反转
3.把字符数组变成字符串




class FanZhuanTest 
{
public static void main(String[] args) 
{
String s = "abcdefghijklmn";
String s1 = FanZhuanTest.reverseString(s);
System.out.println(s);
System.out.println(s1);
}

//定义一个函数对字符串进行反转
public static String reverseString(String str, int start, int end)
{
char[] chs = str.toCharArray(); //将字符串变成字符数组
reverse(chs, start, end); //调用将字符串数组反转的函数。并规定反转字符串的头和尾
return new String(chs); //用String类的构造函数。将字符数组变成字符串
}


//定义一个只有一个参数的字符串反转函数
public static String reverseString(String str)
{
return reverseString(str, 0, str.length());
}


//定义字符串反转的函数
private static void reverse(char[] arr, int start, int end)
{
for(int i = start, j = end - 1; i < j; i++, j--)
{
swap(arr, i, j); //运用swap函数将字符数组中的指定位置的字符反转
}
}


//定义一个将字符调换的函数
private static void swap(char[] chs, int start, int end)
{
char temp = chs[start];
chs[start] = chs[end];
chs[end] = temp;
}


}






3.获取子串出现次数的示例




需求：获取一个字符串在另一个字符串中出现的次数。
"abkkedfkkskka"


思路：
1，定义一个计数器
2，获取kk第一次出现的位置。
3，从第一次出现位置偶剩余的字符串中继续获取kk出现的位置。
每获取一次就计数一次。
4，当获取不到时，技术完成




class ChaZhaoTest
{
public static void main(String[] args) 
{
String s = "abkkedfkkskkakk";
System.out.println(getSubString(s, "kk"));
}


//获取一个子字符串在字符串中出现的次数   方法一
public static int getSubString(String str, String key) //str要传入的参数字符串 key要被查找的字符串
{
int count = 0; //计数器
int index = 0; //记录角标位
while((index = str.indexOf(key))!= -1) //str.indexOf(key)是查找要被查找的字符串的起始位，只要不等于-1就代表里面还有字符
{
count++; //记录出现的次数
//substing获取一个从index+key.length()角标位开始的子字符串
str = str.substring(index + key.length());
}
return count;
}



//获取一个子字符串在字符串中出现的次数   方法二
public static int getSubString_1(String str, String key)
{
int count = 0; //计数器
int index = 0; //记录角标位
while((index = str.indexOf(key, index)) != -1) //indexOf(key, index)key代表要被查找的字符串。index代表下一个角标位的开始角标位
{
index = index + key.length(); //index是要查找字符串的起始位。计算key字符串的长度。并加上查找字符串的起始位
count++;
}
return count;
}


}






4.获取最大相同子串示例




需求：获取两个字符串中最大相同子串，第一个动作，将短的那个串进行长度依次递减的子串打印
"abcwertherlloyuiodef"
"vhelloobn"
思路:
1，将短的的那个子串按照长度依次递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含。
如果包含，已经找到




class XTZiChuanTest 
{
public static void main(String[] args) 
{
String s1 = "abcwerthelloyuiodef";
String s2 = "vhelloobn";
String s3 = "zq";
System.out.println(getMaxSubString(s1, s3));
}

//写一个判断两个字符串中最大子串的函数
public static String getMaxSubString(String str, String key) 
{
String max, min;
max = (str.length() > key.length()) ? str : key;
min = (max == str) ? key : str;
for(int i = 0; i < min.length(); i++) //依次遍历短的的字符串
{
//j代表短字符串的开头角标，z代表结尾角标，因为取子串包含头不包含尾，所以z的长度不需要减1，
//判断条件为只要j不大于短字符串的长度就可以 继续往下运算
//z = min.lenth() - i;代表短字符串的长度在依次递减
//因为字符串是随着循环的次数而依次递减。所以z要自增，直到等于短字符串的长度就结束循环
for(int j = 0, z = min.length() - i; z != min.length() + 1; j++, z++) 
{
String temp = min.substring(j, z); //取出起始角标为j,结束角标为z的子串并赋值给变量temp；
if(max.contains(temp)) //判断取出来的子串是否属于长的字符串
return temp; //属于长的字符串就把该子串反出去
}
}
return "两个字符串没有相同子串";
}


}

二、容器StringBuffer的使用

StringBuffer是一个字符串缓冲区。

也可以说成是一个容器
特点：
1。它的长度是可变化的
2.可以直接操作多个数据类型。
3，最终会通过toString方法变成字符串


1,存储。
StringBuffer append(); //将指定的数据作为参数添加到已有数据结尾处。
StringBuffer insert(index, 数据); //可以将数据插入到指定的index位置


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) 获取缓冲区中从start开始到end结束的字符串(但是字符串并不包括end角标上的)
4,修改。
StringBuffer replace(start, end, string)  start替换内容的开始角标位，end替换内容的结束角标位(但并不包括end),string(要替换进去的内容)
5,反转
StringBuffer reverse(); //调用此函数就可以把字符串反转过来
6，将缓冲区中指定数据存储到指定字符数组中
void getChars(int sreBegin, int srcEnd, char[] dst, int dstBegin)
sreBegin 要被提取出来的字符的角标位开始角标
srcEnd   要被提取出来的字符的角标位结束角标
dst      要把字符存进的字符数组
dstBegin 提取出来的字符从数组的那个位置开始存储

class StringBufferDemo 
{
public static void main(String[] args) 
{
//add(); //调用添加函数
//delete();
//update();
//xiuGai();
//fanZhuan();
charAdd();
}


//写一个把缓冲区中的数据存储到指定位置的字符数组
public static void charAdd()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定义一个容器
char[] a = new char[5];
s.getChars(1, 4, a, 1); //将字符串中角标位1到角标为4(但是不包括4)的数据存储到字符数组中从1角标开始往后存储
for(int i = 0; i < a.length; i++)
{
p("a[" + i + "]" + a[i]);
}
}


//写一个反转缓冲区的函数
public static void fanZhuan()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定义一个容器
p(s); //打印字符串反转前
StringBuffer ss = s.reverse(); //把字符串反转
p(ss); //打印反转后
}


//写一个修改缓冲区内容的函数
public static void xiuGai()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定义一个容器
StringBuffer ss = s.replace(3, 4, "aa");
p(ss);
}


//写一个获取的函数
public static void update()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定义一个容器
char s1 = s.charAt(3); //获取指定位置的字符
int i = s.indexOf("ag"); //返回一个字符串在字符串中第一次出现的角标位
int ii = s.lastIndexOf("ff"); //返回最右边出现的指定子字符串在此字符串中的位置
String ss = s.substring(3,6); //获取缓冲区中从start开始到end结束的字符串(但是字符串并不包括end角标上的)
p(ss);
}


//写一个删除函数
public static void delete()
{
StringBuffer s = new StringBuffer("abdedagdffd"); //定义一个容器
//StringBuffer s1 = s.delete(1, 3);
StringBuffer s2 = s.deleteCharAt(4);
//p(s1.toString());
p(s2.toString());
}


//写一个添加函数
public static void add()
{
StringBuffer s = new StringBuffer(); //定义一个容器
StringBuffer s1 = s.append("a");
StringBuffer s2 = s.append("bbbb");
p("s = " + s.toString()); //加上toString把s变成字符串
p("s1 = " + s1.toString());
p("s2 = " + s2.toString()); //其实所有的StringBuffer对象指向的都是同一个对象
}


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


}

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------


详细请查看：http://edu.csdn.net