黑马程序员----String类
2015-08-15 09:47
603 查看
——- android培训、java培训、期待与您交流！ ———-
初始化方式：
String str="abc";//str是一个类类型变量，“abc”是一个对象。
String str1=new String("abc");
字符串最大的特点是什么？
一旦被初始化就不可以被改变。
这两种初始化方式有什么区别？
String类复写了Object类中的equals方法，定义了自己独特内容，该方法用于判断字符串内容是否相同。
str和str1有什么区别？
str在内存中有一个对象，str1在内存中有两个对象。
方法区：方法，静态和常量池，常量池中有数组，存放a，b，c这样的字符。
如果字符串相同，当定义其他引用的时候，会指向用一个已经存在的对象，而不再单独开辟空间，节省内存。
String类是用于描述字符串事物，它提供可多个方法对字符串进行操作。
String类中的方法：
获取：
1.字符串中包含字符数，即：获取字符串的长度；
int length();
2.根据位置获取该位置上的某个字符。返回值类型为char；
char charAt(int index)
3.根据字符获取该字符在字符串中的位置。
int indexOf(int ch)：返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch，int fromIndex):从指定位置开始，获取ch在字符串中的位置。
int indexOf(String str) ：返回的是str在字符串中第一次出现的位置。
int indexOf(String str，int fromIndex)：从指定位置开始，获取str在字符串中的位置。
int lastIndexOf(int ch):反向索引。
判断:
1.字符串中是否包含某一个子串；
boolean contains(str);
特殊之处：indexOf(str):可以索引str第一次出现的位置（如果返回-1，则表示该str不在字符串中存在），也可以用于对指定字符串判断是否包含。如果字符串对象.indexOf("aa")!=-1,则包含，而且该方法既可以判断又可以获取出现的位置。
2.字符串中是否有内容；
boolean isEmpty();原理就是判断长度是否为0 ，//1.6版本以下不能用。
3.字符串是否是以指定内容开头
boolean startWith(str);
4.字符串是否是以指定内容结尾
boolean endWith(str);
5.字符串的内容是否相同：
boolean equals(str);复写了Object类中的equals方法。
6.内容是否相同并忽略大小写：
boolean equalsIgnoreCase(str);
转换：
1.将字符数组转换成字符串；
构造函数：String(char[] value);
构造函数：String(char[] value,int offset,int count);//将字符数组中的一部分转换长字符串；
静态方法：static String copyValueOf(char[]);
静态方法：static String copyVlaueOf(char[] data,int offset,int count);
静态方法：static String valueOF(char[]);
2.将字符串转换成字符数组；//重要：不需要参数，因为这个对象就是字符串，里面用的 是this。
char[] toCharArray();
3.将字节数组转换成字符串；
String(byte[] value);
String(byte[] value,int offset,int count);//将字节数组中的一部分转换成字符串；
4.将字符串转换成字节数组；
byte[] getBytes();//字符串和字符数组在转换过程中是可以指定编码表的。
5.将基本数据类型转换成字符串：
static String valueOf(int);
static String valueOf(double);
......
3+"":String.valueOf(3);//返回的也是字符串3.
替换：
1.替换字符串中的指定字符；
String replace(oldchar,newchar);
2.替换字符串；
String replace("oldstring","newstring");
3.将字符串按照指定的规则进行替换：（包含正则表达式）
String replaceAll(String regex,String replacement);
切割：
按指定分隔符将一个字符串分割成多个字符串，
String[] split(regex);
子串：
获取字符串中的一部分。
String substring(int beginIndex);
String substring(int beginIndex,int endIndex);
转换：将字符串转换成大写或者小写
String toUpperCase();//转换成大写；
String tolowerCase();//转换成小写；
不区分大小写比较的原理：全部转换成大写或者小写，再用equals去比较。
去除空格：将字符串两端的多余空格去除
String trim();
比较：对两个字符串进行自然顺序的比较
int compareTo(string);
如果参数字符串等于此字符串，则返回值是0
如果此字符串按字典顺序小于字符串参数，则返回一个小于0 的值；
如果如果此字符串按字典顺序大于字符串参数，则返回一个大于0 的值。
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
最常见的作用就是用于基本数据类型和字符串类型之间做转换。
1.基本数据类型转成字符串；
基本数据类型+"";
基本数据类型.toString(基本数据类型值)；
如：Integer.toString(34);//将34整数转换成字符串"34";
2.字符串转成基本数据类型。
静态方法：
基本数据类型xxx a=Xxx.parseXxx("字符串");
如： int num=Integer.parseInt("123");
boolean xx=Boolean.parseBoolean("true");
非静态方法：对象调用方式
Integer i=new Integer("34");
int num=i.intValue();
特殊的：character没有这种方法，它本身就是字符.
进制转换：
1.十进制转换成其他进制：
toBinaryString();//2
toHexString();//8
toOctalString();//16
2.其他进制转换成十进制;
parseInt(String,index);
JDK1.5版本出现的新特性：
1.拆箱、装箱。
int:只能是整数
Integer比int多了一个值：null;
要对Integer进行判断，不为空则运算；为空时要小心空指针异常；
2.当数值在byte范围内时，对于新特性，如果数值已经存在，不会再开辟新的空间；
特点：
1.StringBuffer是一个容器；很多方法和String相同。
2.StringBuffer是可变长度的，可以操作多个数据类型。
3.最终会通过toString方法变成字符串。
StrinBuffer可以对字符串进行增删改查：C:create;U:update;R:read;D:delete.
StringBuffer中方法：
1.存储：
StringBuffer append();//将指定的数据作为参数，添加到已有数据的结尾处；
StringBuffer insert(index,数据);//可以将数据插入到指定index位置；
2.删除：
StringBuffer delete(int start,int 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 );
四、StringBuilder类:
在JDK1.5版本之后出现了StringBuilder.
一个可变的字符序列，此类提供一个与StringBuilder兼容的API，但不保证同步。该类被设计用作StringBuffer的简易替换，用在字符串缓冲区被单个线程使用的时候。
如果可能，简易优先采用该类，因为大多数实现中它比StringBuffer要快。
与StringBuilder的不同之处在于：
StringBuffer是线程同步的，安全。
StringBuilder线程不同步。
将StringBuilder的实例用于多线程是安全的，如果需要同步，则建议使用StringBuffer。单线程用StringBuilder.
java的升级围绕3个部分：
1.提高效率；
2.简化书写；
3.提高安全性。
StringBuilder是提高了StringBuffer的效率，以后开发，建议使用StringBuilder.
修改程序将StringBuffer改成StringBuilder即可。方法不变，只涉及到有没有锁的问题。
思路：
1.判断字符串的第一个位置是否是空格，如果是继续向下判断，直到不是空格为止；结尾处判断也是如此。
2.当开始和结尾都判断不是空格时，获取字符串。
2.将一个字符串进行反转。将字符串中指定的部分进行反转，“abcdefg”--"abfedcg".
思路：
1.曾经学习过对数组的元素进行反转；
2.将字符串变成数组，对数组进行反转；
3.将反转后的数组变成字符串；
4.只要将反转的部分的开始和结束位置作为参数传递即可。
3.获取一个字符串在另一个字符串中出现的次数，“abkkcdkkekfkkskk”
思路：
1.定义一个计数器；
2.获取kk第一次出现的位置；
3.从第一次出现的位置后剩余的字符串中继续获取kk出席那的位置，每获取一次就计数一次；
4.当获取不到时，计数完成。
4.获取两个字符串中最大相同子串，第一个动作：将短的那个串进行长度依次递减的子串打印，“abcwerthelloyuiodef”，“cvhellobnm”.
思路:
1.将短的那个子串按照长度依次递减的方式获取到；
2.将每个获取到的子串去长的那个字符串中判断是否包含，如果包含就找到。
一、String类:
字符串是一个特殊的对象，字符串是常量，一旦初始化就不可以被改变（被final关键字修饰）。初始化方式：
String str="abc";//str是一个类类型变量，“abc”是一个对象。
String str1=new String("abc");
字符串最大的特点是什么？
一旦被初始化就不可以被改变。
这两种初始化方式有什么区别？
String类复写了Object类中的equals方法，定义了自己独特内容，该方法用于判断字符串内容是否相同。
str和str1有什么区别？
str在内存中有一个对象，str1在内存中有两个对象。
方法区：方法，静态和常量池，常量池中有数组，存放a，b，c这样的字符。
如果字符串相同，当定义其他引用的时候，会指向用一个已经存在的对象，而不再单独开辟空间，节省内存。
String类是用于描述字符串事物，它提供可多个方法对字符串进行操作。
String类中的方法：
获取：
1.字符串中包含字符数，即：获取字符串的长度；
int length();
2.根据位置获取该位置上的某个字符。返回值类型为char；
char charAt(int index)
3.根据字符获取该字符在字符串中的位置。
int indexOf(int ch)：返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch，int fromIndex):从指定位置开始，获取ch在字符串中的位置。
int indexOf(String str) ：返回的是str在字符串中第一次出现的位置。
int indexOf(String str，int fromIndex)：从指定位置开始，获取str在字符串中的位置。
int lastIndexOf(int ch):反向索引。
判断:
1.字符串中是否包含某一个子串；
boolean contains(str);
特殊之处：indexOf(str):可以索引str第一次出现的位置（如果返回-1，则表示该str不在字符串中存在），也可以用于对指定字符串判断是否包含。如果字符串对象.indexOf("aa")!=-1,则包含，而且该方法既可以判断又可以获取出现的位置。
2.字符串中是否有内容；
boolean isEmpty();原理就是判断长度是否为0 ，//1.6版本以下不能用。
3.字符串是否是以指定内容开头
boolean startWith(str);
4.字符串是否是以指定内容结尾
boolean endWith(str);
5.字符串的内容是否相同：
boolean equals(str);复写了Object类中的equals方法。
6.内容是否相同并忽略大小写：
boolean equalsIgnoreCase(str);
转换：
1.将字符数组转换成字符串；
构造函数：String(char[] value);
构造函数：String(char[] value,int offset,int count);//将字符数组中的一部分转换长字符串；
静态方法：static String copyValueOf(char[]);
静态方法：static String copyVlaueOf(char[] data,int offset,int count);
静态方法：static String valueOF(char[]);
2.将字符串转换成字符数组；//重要：不需要参数，因为这个对象就是字符串，里面用的 是this。
char[] toCharArray();
3.将字节数组转换成字符串；
String(byte[] value);
String(byte[] value,int offset,int count);//将字节数组中的一部分转换成字符串；
4.将字符串转换成字节数组；
byte[] getBytes();//字符串和字符数组在转换过程中是可以指定编码表的。
5.将基本数据类型转换成字符串：
static String valueOf(int);
static String valueOf(double);
......
3+"":String.valueOf(3);//返回的也是字符串3.
替换：
1.替换字符串中的指定字符；
String replace(oldchar,newchar);
2.替换字符串；
String replace("oldstring","newstring");
3.将字符串按照指定的规则进行替换：（包含正则表达式）
String replaceAll(String regex,String replacement);
切割：
按指定分隔符将一个字符串分割成多个字符串，
String[] split(regex);
子串：
获取字符串中的一部分。
String substring(int beginIndex);
String substring(int beginIndex,int endIndex);
转换：将字符串转换成大写或者小写
String toUpperCase();//转换成大写；
String tolowerCase();//转换成小写；
不区分大小写比较的原理：全部转换成大写或者小写，再用equals去比较。
去除空格：将字符串两端的多余空格去除
String trim();
比较：对两个字符串进行自然顺序的比较
int compareTo(string);
如果参数字符串等于此字符串，则返回值是0
如果此字符串按字典顺序小于字符串参数，则返回一个小于0 的值；
如果如果此字符串按字典顺序大于字符串参数，则返回一个大于0 的值。
public class StringDemo_0
{
public static void sop(Object obj)
{
System.out.println(obj);
}
//方法演示：
//获取：
public static void method_get()
{
String str="abcdeamnjkuf";
//获取长度：
sop(str.length());
//根据索引获取字符：
sop(str.charAt(4));
//sop(str.charAt(40));//当访问到字符串中不存在的角标时，会发生角标越界异常。
//根据字符获取索引：
sop(str.indexOf('a',3));
//sop(str.indexOf('m',3));//如果没有找到，没有角标返回-1；
//反向索引一个字符出现的位置：
sop(str.lastIndexOf("n"));
}
//判断：
public static void method_is()
{
String str="ArrayDemo.java";
//判断文件名称是否是以Array开头：
sop(str.startsWith("Array"));
//判断文件名称是不是.java的文件：
sop(str.endsWith(".java"));
//判断文件名称是否包含Demo：
sop(str.contains("Demo"));
}
//转换：
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);//3是个数，从角标为1的位置开始的三个字符；
//打印数组：
sop("s="+s);
sop("s1="+s1);
String s0="qwertyuiop";
char[] chs=s0.toCharArray();
for(int x=0;x<chs.length;x++)
{
sop("chs="+chs[x]);
}
}
//替换：
public static void method_replace()
{
String s="Hello java";
//替换字符：
String s1=s.replace('a', 'n');
//String s1=s.replace('q', 'n');//如果要替换的字符不存在，则返回的是原来的字符串。
sop("s="+s);
sop("s1="+s1);
//替换字符串：
String s2=s.replace("java","world");
sop("s2="+s2);
}
//切割：
public static void method_split()
{
String s="qwertyuiop,asdfghjkl,zxcvbnm";
String[] s1=s.split(",");
for(int x=0;x<s1.length;x++)
{
sop(x+":"+s1[x]);
}
}
//获取子串：
public static void method_substring()
{
String s="asdfghjklzxcvbnm";
sop(s.substring(2));//获取从角标为2的字符开始到结尾的子串；s.substring(2,s.length);
sop(s.substring(2,4));//获取从角标2到角标4之间的子串；（包括角标2不包括角标4的字符）.
//如果角标不存在，会出现角标越界的异常；
}
//转换、去除空格、比较：
public static void method_caseTrimCompare()
{
String s=" Hello Java ";
String s1="Hello World";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());
sop(s.compareTo(s1));//-40?比较的是该位上的ASCII码值得大小，返回ASCII码值之差；
}
//主函数：
public static void main(String[] args)
{
String str0="abc";//常用方式;
String str1=new String("abc");
System.out.println(str0==str1);//false;
System.out.println(str0.equals(str1));//true;
str0="kk";//abc对象并没有变，只是str指向了kk这个对象。
String str2="abc";
System.out.println(str0==str1);//false;
System.out.println(str0==str2);//false;//abc对象已经在内存中存在了.
//--------------------------------------------------------------------------
method_get();
method_is();
method_trans();
method_replace();
method_split();
method_substring();
method_caseTrimCompare();
}
}二、基本数据类型包装类
数据类型 对应的对象(引用数据类型)byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
最常见的作用就是用于基本数据类型和字符串类型之间做转换。
1.基本数据类型转成字符串；
基本数据类型+"";
基本数据类型.toString(基本数据类型值)；
如：Integer.toString(34);//将34整数转换成字符串"34";
2.字符串转成基本数据类型。
静态方法：
基本数据类型xxx a=Xxx.parseXxx("字符串");
如： int num=Integer.parseInt("123");
boolean xx=Boolean.parseBoolean("true");
非静态方法：对象调用方式
Integer i=new Integer("34");
int num=i.intValue();
特殊的：character没有这种方法，它本身就是字符.
进制转换：
1.十进制转换成其他进制：
toBinaryString();//2
toHexString();//8
toOctalString();//16
2.其他进制转换成十进制;
parseInt(String,index);
JDK1.5版本出现的新特性：
1.拆箱、装箱。
int:只能是整数
Integer比int多了一个值：null;
要对Integer进行判断，不为空则运算；为空时要小心空指针异常；
2.当数值在byte范围内时，对于新特性，如果数值已经存在，不会再开辟新的空间；
public class StringDemo_1
{
public static void sop(String str)
{
System.out.println(str);
}
//主函数：
public static void main(String[] args)
{
//整数类型的最大值：
sop("int max="+Integer.MAX_VALUE);
//将一个字符串转成整数：
int num=Integer.parseInt("123");
//long num1=Long.parseLong("a123456");//数字格式异常，必须传入数字格式的字符串；
sop("num="+(num+4));
//sop("num1="+(num1+4));
//十进制转换成其他进制：
sop(Integer.toBinaryString(6));
sop(Integer.toBinaryString(-6));
sop(Integer.toHexString(60));
//其他进制转十进制：
int x=Integer.parseInt("110", 2);
sop("x="+x);
int x1=Integer.parseInt("3c", 16);
sop("x="+x1);
//--------------------------------------------------------------------------
//新特性：
Integer m=new Integer(4);
Integer n=4;//自动装箱，封装为对象：相当于new Integer(4);
n=n/*操作是：n.intValue();*/+2;//n+2:n进行自动拆箱，变成int类型与2相加，再把相加的值装箱赋给n;
//Integer n=null;
//n=n+2;//做运算时会出现空指针异常；n不能调用intValue();
Integer s=128;
Integer t=128;
sop("s==t:"+(s==t));//false;s和t指向两个不同的对象；
Integer a=127;
Integer b=127;
sop("a==b:"+(a==b));//true;因为a和b指向了同一个对象;
//当数值在byte范围内时，对于新特性，如果数值已经存在，不会再开辟新的空间；
}
public static void method_Integer()
{
Integer m=new Integer("346");
Integer n=new Integer(346);
//问题：
sop("m==n:"+(m==n));//两个对象；
sop("m.equals(n):"+(m.equals(n)));//equals复写了Object类中的equals方法，比较的是数值是否相同。
}
}三、StringBuffer类:
字符串缓冲区特点：
1.StringBuffer是一个容器；很多方法和String相同。
2.StringBuffer是可变长度的，可以操作多个数据类型。
3.最终会通过toString方法变成字符串。
StrinBuffer可以对字符串进行增删改查：C:create;U:update;R:read;D:delete.
StringBuffer中方法：
1.存储：
StringBuffer append();//将指定的数据作为参数，添加到已有数据的结尾处；
StringBuffer insert(index,数据);//可以将数据插入到指定index位置；
2.删除：
StringBuffer delete(int start,int 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 );
public class StringBuffer_0
{
public static void sop(String str)
{
System.out.println(str);
}
//添加：
public static void method_add()
{
StringBuffer sb=new StringBuffer();//空字符
StringBuffer sb1=sb.append(34);
sb.append("abc").append(true).append(34);//方法调用链；
sop(sb1.toString());//34;
sop("sb==sb1:"+(sb==sb1));//true;
sb.insert(2, "b");
sop(sb.toString());//34;
}
//删除：
public static void method_delete()
{
StringBuffer sb=new StringBuffer("abcdefghigklmn");
sb.delete(2, 5);
sb.deleteCharAt(8);//sb.delete(2, 3);
sop(sb.toString());
//清空缓冲区：
//sb=new StringBuffer();
sb.delete(0, sb.length());
}
//修改：
public static void method_Update()
{
StringBuffer sb=new StringBuffer("abcdefghigklmn");
sb.replace(1, 3, "java");
sop(sb.toString());
sb.setCharAt(0, 'y');//替换一个字符；
sop(sb.toString());
}
//6.将缓冲区中的指定数据存储到指定字符的数组中；（包含头不包含尾）
public static void method_GetChars()
{
StringBuffer sb=new StringBuffer("abcdefghigklmn");
char[] chs=new char[4];
sb.getChars(1, 4, chs, 1);
for(int x=0;x<chs.length;x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
}
//主函数：
public static void main(String[] args)
{
method_add();
method_delete();
method_Update();
method_GetChars();
}
}四、StringBuilder类:
在JDK1.5版本之后出现了StringBuilder.一个可变的字符序列，此类提供一个与StringBuilder兼容的API，但不保证同步。该类被设计用作StringBuffer的简易替换，用在字符串缓冲区被单个线程使用的时候。
如果可能，简易优先采用该类，因为大多数实现中它比StringBuffer要快。
与StringBuilder的不同之处在于：
StringBuffer是线程同步的，安全。
StringBuilder线程不同步。
将StringBuilder的实例用于多线程是安全的，如果需要同步，则建议使用StringBuffer。单线程用StringBuilder.
java的升级围绕3个部分：
1.提高效率；
2.简化书写；
3.提高安全性。
StringBuilder是提高了StringBuffer的效率，以后开发，建议使用StringBuilder.
修改程序将StringBuffer改成StringBuilder即可。方法不变，只涉及到有没有锁的问题。
public class StringBuilder_0
{
public static void sop(String str)
{
System.out.println(str);
}
//添加：
public static void method_add()
{
StringBuilder sb=new StringBuilder();//空字符
StringBuilder sb1=sb.append(34);
sb.append("abc").append(true).append(34);//方法调用链；
sop(sb1.toString());//34;
sop("sb==sb1:"+(sb==sb1));//true;
sb.insert(2, "b");
sop(sb.toString());//34;
}
//删除：
public static void method_delete()
{
StringBuilder sb=new StringBuilder("abcdefghigklmn");
sb.delete(2, 5);
sb.deleteCharAt(8);//sb.delete(2, 3);
sop(sb.toString());
//清空缓冲区：
//sb=new StringBuilder();
sb.delete(0, sb.length());
}
//修改：
public static void method_Update()
{
StringBuilder sb=new StringBuilder("abcdefghigklmn");
sb.replace(1, 3, "java");
sop(sb.toString());
sb.setCharAt(0, 'y');//替换一个字符；
sop(sb.toString());
}
//将缓冲区中的指定数据存储到指定字符的数组中；（包含头不包含尾）
public static void method_GetChars()
{
StringBuilder sb=new StringBuilder("abcdefghigklmn");
char[] chs=new char[4];
sb.getChars(1, 4, chs, 1);
for(int x=0;x<chs.length;x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
}
//主函数：
public static void main(String[] args)
{
method_add();
method_delete();
method_Update();
method_GetChars();
}
}五、练习
1.模拟一个trim方法，去除字符串来两端的空格思路：
1.判断字符串的第一个位置是否是空格，如果是继续向下判断，直到不是空格为止；结尾处判断也是如此。
2.当开始和结尾都判断不是空格时，获取字符串。
2.将一个字符串进行反转。将字符串中指定的部分进行反转，“abcdefg”--"abfedcg".
思路：
1.曾经学习过对数组的元素进行反转；
2.将字符串变成数组，对数组进行反转；
3.将反转后的数组变成字符串；
4.只要将反转的部分的开始和结束位置作为参数传递即可。
3.获取一个字符串在另一个字符串中出现的次数，“abkkcdkkekfkkskk”
思路：
1.定义一个计数器；
2.获取kk第一次出现的位置；
3.从第一次出现的位置后剩余的字符串中继续获取kk出席那的位置，每获取一次就计数一次；
4.当获取不到时，计数完成。
4.获取两个字符串中最大相同子串，第一个动作：将短的那个串进行长度依次递减的子串打印，“abcwerthelloyuiodef”，“cvhellobnm”.
思路:
1.将短的那个子串按照长度依次递减的方式获取到；
2.将每个获取到的子串去长的那个字符串中判断是否包含，如果包含就找到。
public class StringPractece_0
{
//打印：
public static void sop(String str)
{
System.out.println(str);
}
public static void print()
{
System.out.println();
}
//反转换位：
private static void reverse(char[] chs)
{
for(int start=0,end=chs.length-1;start<end;start++,end--)//从头到尾；
{
swap(chs,start,end);
}
}
private static void reverse(char[] chs,int x,int y)
{
for(int start=x,end=y-1;start<end;start++,end--)//定义一个区间；
{
swap(chs,start,end);
}
}
private static void swap(char[] chs,int x,int y)
{
char temp=chs[x];
chs[x]=chs[y];
chs[y]=temp;
}
//练习1：去除字符串两端的空格：
public static String method_Trim(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);//包含头不包含尾，end要加1；
}
//练习2：字符串中指定的部分进行反转：
public static String method_ReverseString(String str)
{
//第一步：字符串变数组：
char[] chs=str.toCharArray();
//第二步：反转数组：
reverse(chs);
//第三步：将数组变成字符串：
return new String(chs);
}
public static String method_ReverseString(String str,int start,int end)
{
char[] chs=str.toCharArray();
reverse(chs,start,end);
return new String(chs,0,str.length()); //返回从头至尾的字符串；
}
//练习3：获取一个字符串在另一个字符串中出现的次数
public static int method_GetTimes(String str,String key)
{
/*
//方式一：
int count=0;
int index=0;
while((index=str.indexOf(key))!=-1)
{
System.out.println("str="+str);
str=str.substring(index+key.length());//原来的串发生改变了；
count++;
}
return count;
*/
//方式二：不打印子串;
int count=0;
int index=0;
while((index=str.indexOf(key,index))!=-1)//从指定位置index开始查；
{
sop("index="+index);
index=index+key.length();
count++;
}
return count;
}
//练习4：获取两个字符串中最大相同子串
public static String method_GetMaxString(String str1,String str2)
{
String max="",min="";
max=(str1.length()>str2.length())?str1:str2;
min=(max==str1)?str2:str1;
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);
if(max.contains(temp))//if(str1.indexOf(temp)!=-1)
{
return temp;
}
}
}
return "";
}
//主函数：
public static void main(String[] args)
{
//练习1：去除字符串两端的空格：
String s0=" ab cd efg ";
sop("原字符串：s0="+s0);
sop("去除字符串两端的空格：s="+method_Trim(s0));
print();
//练习2：
//1.将整个字符串进行反转：
String s1=" abc defg ";
sop("原字符串：s1="+s1);
sop("反转后的字符串：s="+method_ReverseString(s1));
//2.字符串中指定的部分进行反转：
sop("部分反转后的字符串：s="+method_ReverseString(s1,3,9));//函数重载；
print();
//练习3：获取一个字符串在另一个字符串中出现的次数：
String s2="abkkcdkkekfkkskk";
sop("原字符串：s2="+s2);
sop("kk出现的次数：count="+method_GetTimes(s2,"kk"));
sop("count="+s2.split("kk").length);//这个方法也可以。但是如果字符串开头有kk，用这种方法就少一个，不建议使用。
print();
//练习4：获取两个字符串中最大相同子串
String s3="abcwerthelloyuiodef";
String s4="cvhellobnm";
sop("原字符串：s3="+s3);
sop("最大相同子串：s="+method_GetMaxString(s3,s4));
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Android之获取手机上的图片和视频缩略图thumbnails
- android string.xml文件中的整型和string型代替
- Android java 与 javascript互访(相互调用)的方法例子
- android上改变listView的选中颜色
- String.intern
- Prototype源码浅析 String部分(二)
- Ruby中的String对象学习笔记
- insert语句太长用StringBuilder优化一下
- PostgreSQL ERROR: invalid escape string 解决办法
- 浅谈C++中的string 类型占几个字节
- 标准C++类string的Copy-On-Write技术
- C++实现string存取二进制数据的方法
- C#中string和StingBuilder内存中的区别实例分析
- PHP STRING 陷阱原理说明
- c#中 String和string的区别介绍
- C#实现的图片、string相互转换类分享
- asp.net String.IsNullOrEmpty 方法
- JavaScript中字符串(string)转json的2种方法
- C#中string用法实例详解
- C#中StringBuilder类的使用总结