程序员_Java基础之<六>-String

/*Java API-String*/

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

常见操作：

“abcd”

1.获取。

1.1字符串中的包含的字符数，也就是字符串的长度。

int length（）:获取长度，注意数组中获取长度时，length是属性，没有括号。

1.2根据位置获取某个位置上字符。

char charAt（int index）：

1.3根据字符获取该字符在字符串中的位置。

int indexOf（int ch）：返回的是ch在字符串中第一次出现的位置。

int indexOf（int ch，int fromIndex）：从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf（String str）：返回的是str在字符串中第一次出现的位置。

int indexOf（String str，int fromIndex）：从fromIndex指定位置开始，获取在str字符串中出现的位置。

2.判断。

2.1字符串是否包含某一个子串。

boolean contains（str）；

特殊之处：indexOf（str）：可以索引str第一次出现位置，如果返回-1，表示str不在字符串中存在。

所以，也可以用于指定判断是否包含。

if（str.indexOf（"aa"）！=-1）

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

2.2字符串是否有内容

boolean isEmpty（）：原理就是判断长度是否为0

2.3字符串是否是以指定内容开头。

boolean startsWith（str）；

2.4字符串是否是以指定内容结尾。

boolean endsWith（str）；

2.5判断字符串内容是否相同，复写了Object类中的equals方法。

boolean equals（str）；

2.6判断内容是否相同，并忽略大小写。

boolean equalsIgnoreCase（）；

3.转换。

3.1将字符数组转换为字符串。

a.构造函数：String(char[])

String(char[],offset.count):将字符数组中的一部分转成字符串。

b.静态方法：

static String copyValueOf(char[]);

static String copyValueOf(char[]data,int offset,int count)

static String valueOf(char[])

3.2将字符串转化成字符数组。

char[] toCharArray();

3.3将字节数组转成字符串。

String(byte[])

String(byte[],offset.count):将字节数组中的一部分转成字符串。

3.4将字符串转成字节数组。

byte[] getBytes();

3.5将基本数据类型转换成字符串。

static String valueOf(int)

static String valueOf(double)

例如:3+""即String.valueOf(3);

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

4.替换

String replace（oldchar，newchar）；

5.切割。

String[] split(regex);

6.子串。获取字符串中的一部分。

String substring(begin);从指定位置开始到结尾，如果角标不存在，会出现字符串角标越界异常

String substring(begin,end);包含头，不包含尾。s.substring(0,s.length());

7.转换，去除空格，比较。

7.1将字符串转成大写或者小写。

String toUpperCase();

String toLowerCase();

7.2将字符串两端的多个空格去除。

String trim();

7.3将两个字符串进行自然顺序的比较。

int compareTo(string);从第一个字符开始比较ASC码值，大于返回正数，等于返回0，小于负数

示例：

<span style="font-size:18px;color:#666666;">class StringDemo
{
public static void method_7()
{
String s="  Hello Java  ";
sop(s.toLowerCase());
sop(s.toUpperCase());
sop(s.trim());
String s1="abc";
String s2="aaa";
sop(s1.compareTo(s2));
}
public static void method_sub()
{
String s="abcdef";
sop(s.substring(2));//从指定位置开始到结尾，如果角标不存在，会出现字符串角标越界异常
sop(s.substring(2));//包含头，不包含尾。s.substring(0,s.length());

}
public static void method_split()
{
String s="zhangsan,lisi.wangwu";
String[] arr=s.split(",");
fou(int x=0;x<arr.length;x++)
{
sop(arr[x]);
}

}
public static void method_replace()
{
String s="hello java";
//String s1=s.replace('a','n');
sop("s="+s);//hello java,字符串一旦被初始化，不会改变。
String s1=s.replace("java","word");
sop("s1="+s1);//hello jnvn
}

public static void methoe_trans()
{

char[] arr={'a','b','c','d','e','f'};
//String s=new  String(arr);
String s=new  String(arr,1,3);//从下表为1，打印3个，为bcd
sop("s="+s);
String s1="xfrggwrg";
char[] chs=s1.toCharArry();
for(int x=0;x<chs.length;x++)
{
sop("ch="+chs[x]);
}
}
public static void main(String[] args)

{
method_get();
/*String s1="abc";//s1是一个类类型变量，“abc”是一个对象。
//字符串最大特点：一旦被初始化就不可以被改变。
String s2=new String("abc");
String s3="abc";
//s1和s2有什么区别？？

//s1在内存中有一个对象。s2在内存中有两个对象。

System.out.println(s1==s2);//false,两个是不同的类类型变量
System.out.println(s1.equals(s2));//true，String类复写了Object类中equals方法，该方法用于判断字符串是否相同。

System.out.println(s1==s3);//true，因为相同的字符串已经在内存中存在了，为了节约内存，规定s1，s3，指向同一对象。
*/
}
public static void method_get()
{
String str="abcdeakpf";
sop(str.length());//长度
sop(str.charAt(4));//根据索引取字符
sop(str.indexOf('m',3));//如果没找到，得-1
sop(str.lastIndexOf("a"));//反向索引一个字符出现的位置
}
public static void sop(Object obj)
{
System.out.println(obj);

}
public static void method_is()
{
String str="ArrayDemo.java";
sop(str.startsWith("Array"));//判断文件名称是否是Array单词开头。
sop(str.endsWith(".java"));//判断文件名称是否是.java的文件
sop(str.contains("Demo"));//判断文件中是否包含Demo
}
}</span>

/*字符串练习1,
模拟trim方法，去除字符串两端的空格。
思路：
1.判断字符串第一个位置是否为空格，如果是继续向下判断，直到不是空格为止。结尾处判断空格也如此。
*/

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

s=myTrim(s);
sop("("+s+")");

}
//练习一，去除字符串两端空格
public static String myTrim(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);
}

}
//练习2：将字符串反转

public static String reverseString(String s,int start,int end)//将字符串部分反转
{
char chs=s.toCharArray();//字符串变数组
reverse(chs,satart,end);//反转数组
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)
{
fou(int start=x;,end=y-1;start<end;start++,end--)//注意：此处习惯性将end写成y-1，因为传值时，只要给其串s.length即可。
swap(arr,start,end);
}
}
private static void swap(char[] arr,int x,int y)
{
char temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
/*练习3.获取一个字符串在另一个字符串中出现的次数。
思路：  1，定义一个计数器。
2，获取kk第一次出现的位置。

*/
public static int getSubCount(String str,String key)//获取str的子串key出现的次数
{
int count=0;
int index=0;
while((index=str.indexOf(key))!=-1)//str能获取到key的位置，count就+1；
{

sop("str="+str);
str=str.substring(index+key.length());
count++;
}
return count;
}
/*练习三 方式二*/
public static int getSubCount_2(String str,String key)
{
int count=0;
int index=0;
while((index=str.indexOf(key,index))!=-1)
{
sop("index="+index);
index=index + key.length();
conut++;
}
return count;
}
/*练习四
获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度依次递减的子串打印。
思路：
1.将短的那个子串按照长度递减的方式获取到。
2.将每获取到的子串去长串中判断是否包含，如果包含，已经找到！
*/
class StringTest3
{
public static String getMaxSubString(String s1,String s2)
String max="",min="";
max=(s1.length()>s2.length())?s1:s2;
min=(max==s1)?s2:s1;//将小的赋给min
for(int x=0;x<min.length();x++)//控制每次选取的子串的长度，length，length-1，。。。1
for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)//y,z分别表示首尾，

{
String temp=min.substring(y,z);//求子串时，包含头不包含尾。
sop(temp);
if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
return temp;
}
}

/*StringBuffer:

1.StringBuffer是一个---容器,缓冲区--。

1.长度时可以变化的。

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

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

a.存储。

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

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

b.删除

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

StringBuffer delete(index)

c.获取

char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start,int end)

d.修改

StringBuffer replace(start,end,string);

void setCharAt(int index,char ch);

e.反转

StringBuffer reverse();

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

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

StringBuilder

作为StringBuffer的一个简易替换，但StringBuffer是同步的，StringBuilder保证不同步，不安全。

多线程用StringBuffer，单线程用StringBuilder（没锁），提高效率。

以后开发建议用StringBuilder。

JDK升级的三个因素：

1.提高效率。

2.简化书写。

3.提高安全性。

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

}
public static void method_add()
{
StringBuffer sb=new StringBuffer();
sb.append(34).sppend("abc").append(true);//添加。34abctrue
sb.insert(1,"qq")//在角标为1处添加qq,3qqabctrue

sb.delete(0,sb.length());//清空缓冲区
sb.deleteCharAt(2);

sop(sb.toString());

}
public static void method_del()
{
StringBuffer sb=new StringBuffer("abcde");
sb.delete(1,3);//结果为ade，角标1-3的没了，不包含尾。
sop(sb.toString());
}
public static void method_update()
{
StringBuffer sb=new StringBuffer("abcde");
sb.replace(1,4,"java");//ajavae
sb.setCharAt(2,'k');//abkde
sop(sb.toString());
}
public static void gerChars()
{
StringBuffer sb=new StringBuffer("abcdef");
char[] chs=new char[6];
sb.getChars(1,4,chs,1);
for(int x=0;x<chs.length;x++)
{
sop("chs["+x+"]="+chs[x]+";");
}

}

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

基本数据类型对象包装类

基本数据类型
引用数据类型（对象）

byte Byte

short Short

int Integer

long Longe

boolean
Boolean

float Float

double
Double

char Character

基本数据类型对象包装类的最常见作用：

就是用于基本数据类型 和字符串类型之间的转换。

1.基本数据类型转成字符串。

方法：a基本数据类型+“”

b基本数据类型.toString(基本数据类型值)

如：Integer.toString(34);//将34正数变成“34”。

2.字符串转成基本数据类型。

xxx a=Xxx.parseXxx(String);

int a=Integer.parseInt("123");

double b=Double.parseDouble("12.3");

boolean b=Boolean.parseBoolean("true");

十进制转成其他进制。

toaBinaryString();

toHexString();//16进制

toOctalString();

其他进制转成十进制。

parseInt(string,radix)

*/

class IntegerDemo
{
public static void main(String[] args)
{
//整数类型的最大值。
//sop("int max:"+Integer.MAX_VALUE);
//将一个字符串转成整数
int num=Integer.parseInt("123");//必须传入数字格式的字符串。
long x=Long.parseLong("123")
sop("num"+(num+4));
sop(Integer.toBinaryString(-6));//求-6的二进制
sop(Integer.toHexString(60));//求-6十六进制

int x=Integer.parseInt("3c",16)//将字符转换成指定进制的数
sop("x="+x);

}
}
/*JDk1.5以后的新特性*/
class IntegerDemo1
{
public static void main(String[] args)
{
Integer x=new Integer(4);
Integer x=4;//自动装箱，4相当于new Integer(4)，是上句的替换，新特性，注意Integer型的变量可为null
x=x/*x.intValue()*/+2;//x+2:x进行了自动拆箱，变成可int型。和2进行加法运算，然后将和进行装箱赋值给x

Integer m=128;
Integer n=128;
sop("m==n:"(m==n));

Integer a=127;
Integer b=127;
sop("a==b:"(a==b));
/*结果为true。因为a和b指向了同一个Integer对象.
因为当数值在byte范围内容，对于新特性，如果该数值已经存在则不会开辟新空间。*/
}
}