java基础整理十三（String）

java API:

String s1 = "abc";//s1是一个类类型变量，abc是一个对象。字符串最大的特点：一旦被初始化就不可以被改变。

String s2 = new String(abc);使用方法与上方一样但有区别。s1==s2不成立。s1.equals(s2);成立 因为String类复写了Object类中的equuals方法

该方法用于判断字符串是否相同。s1和s2的区别在于：s1在内存中有一个对象，s2在内存中有两个对象。

String类适用于描述字符串事物。那么它就提供了多个方法对字符串进行操作。常见的操作有哪些？

“abcd”

1，获取。
1.1，字符串中的包含的字符数，也就是字符串的长度。int 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 ifEmpty():原理就是判断长度是否为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 将字符数组转换成字符串.构造函数:String(char[]) String(char[],offset,count):将字符数组中的一部分转换成字符串.
静态方法: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 valeueof(int)  static String valueof(double)  3+"";//String.valueof(3);两种写法一样但是一般用前一种,更简单一些.

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

4,替换.
4.1 String replace(oldchar,newchar);新的替换老的.

5,切割.
5.1 String[]split(regex);

6,子串.
6.1 获取字符串中的一部分.String substring(begin); String substring(begin,end);

7,转换,去除空格,比较
7.1 将字符串转换成大写或小写.String toUpperCase(); String toLowerCase();

7.2 将字符串两端的多个空格去除.String trim();

7.3 对两个字符串进行自然顺序的比较.int compareTo(String);

class Test//事例

{
public static void method_7()
{
String  s = "   Hello Java   ";
sop(s.toLowerCase());//  hello java  
sop(s.toUpperCase());//  HELLO JAVA
sop(s.trim());//hello java
String s1="abc";
String s2="aaa";
sop(s1compareTo(s2));
}

public static void method_sub()//子串
{
String s = "abcdef";
sop(s.subsring(2));//从指定位置开始到结尾cdef.如果角标不存在会出现字符串角标越界.
sop(s.subsring(2,4));//包含头,不包含尾打印cd
}

public static void method_split()//切割
{
String s = "zhangsan,lisi,wangwu";
String[]arr = s.split(",");
for (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');//如果要替换的字符不存在,返回的还是原来的字符.
String s2= s.replace("java","world")
sop("s="+s);//打印hello java
sop("s1="+s1);//打印hello jnvn
}
public static void method_trans()//转换事例
{
char[]arr = {'a','b','c','d','e','f'};
String str = new String(arr,1,3);//打印bcd 1,表示从1角标位开始取三个
sop("str="+str);

String str1 = "afgeddvh";
char[] chs = str1.toCharArray();
for (int x =0;x<chs.length ;x++ )
{
sop("ch="+chs[x]);
}
}
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_get()//获取事例
{
String str = "abcdeakpf";
//长度
sop(str.length());

//根据索引获取字符
sop(str.charAt(4));//当访问到不存在的角标时会发生角标越界异常。

//根据字符获取索引
sop(str.indexOf('a',3));//如果没有找到返回-1。

//反向索引一个字符出现位置。
sop(str.lastIndexOf("a"));
}
public static void main(String[]args)
{
method_7();
method_sub();
method_split();
method_replace();
method_trans();
method_is();
method_get();
}
public static void sop(Object obj)
{
System.out.println(obj);
}

}

/*练习一去除字符串两端的空格

class Test 

{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args) 
{
String s = "    o dge tf v   ";
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);
}

}

练习二将指定范围内的字符反转位置。

class FanZhuan

{
public static void sop(String str)
{
System.out.println(str);
}
public static String arr(String s ,int start,int end)
{
char[]chs = s.toCharArray();
while (start<end)
{   
char temp = chs[start];
chs[start] = chs[end];
chs[end] = temp;
start++;
end--;
}
return new String(chs) ;//数组转回字符串型
}
public static void main(String[]args)
{
String s = "abcdefg";
sop(arr(s,2,5));
}

}

练习三查找字符串中出现指定字符串出现的次数。例如"ehfiehiehwiuhwefgewugehihfihfri"中"hi"出现的次数.

class Test

{
public static int menthod(String s,String s1)//*****这里有个疑问不太明白,能不能不加static如果不加static应该怎么将程序改变下,这个不太懂.
{   
int x=0;//建立一个计数器变量
if (s.contains(s1))//判断内部是否含有要查找的字符串
{

for (int start = 0; s.indexOf(s1,start)!=-1;)//[s.indexOf(s1,start)!=-1]确保字符串中不再含要有查找的字符串
{ 
int y = s.indexOf(s1,start);//记录要查找的字符串出现的位置
start = y + s1.length();//改变起始查找位置
x++;

} 
}
return x;//返回出现次数
}
public static void main(String[]args)
{
String s = "ehfiehiehwiuhwefgewugehihfihfri";//基字符串,即在此字符串中进行查找
String s1= "hi";//所需查找的字符串
int x = menthod(s,s1);
System.out.println("x="+x);
}

}

练习四找出两字符串中相同最多的字符串

class StringTest

{
public static String get(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;
}
}
return "";
}
public static void main(String[]args)
{
String s1 = "dfiuhferhfoirehuirhu4";
String s2 = "efjeoijffd";
sop(get(s1,s2));
}
public static void sop(String str)
{
System.out.println(str);
}

}

*/

StringBuffer是字符串缓冲区.特点:是一个容器.而且长度可变化,可以直接操作多个数据类型 最终通过toString方法变成字符串

C create U update R read D delete

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

2,删除.StringBuffer delete(start,end)删除缓冲区中的数据,包含start不包含end.  StringBuffer deleteCharAt();删除指定位置的字符

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);将缓冲中的指定数据,存储到指定的字符数组中

class Stringbuffer

{
public static void main(String[]args)
{
method_del();
method_update();

StringBuffer sb = new StringBuffer("abcde");
char[] chs = new char[4];
sb.getChars(1,4,chs,1);对字符串从1位置取,取到4位置,存在chs中,从chs 1号位开始存.
for (int x= 0 ;x<chs.length;x++)
{
sop(chs[x]);
}

}
public static void method_update()//修改
{
StringBuffer sb = new StringBuffer("abcde");
sb.replace(1,4,"java");//a-d换成java 含头不含尾
sb.setCharAt(2,'k');//二角标替换为k
sop(sb.toString());//转换成字符串
}

public static void method_del()//删除
{
StringBuffer sb = new StringBuffer("abcde");
sb.delate(1,3);//打印出ade 删头不删尾
sb.delete(0,sb.length());//清空缓冲区
sb.deleteCharAt(2);//删除指定位置
sop(sb.toString());
}

public static void method_add()//存储
{
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(34);//打印出abctrue34
sb.insert(1,"qq");//在指定位置添加字符串.
sop(sb.toString());
}
public static void sop(String str)
{
System.out.println(str);
}

}

JDK1.5之后出现StringBuilder 与StringBuffer不同. StringBuilder是线程不同步 StringBuffer是线程同步 一般选用StringBuilder虽然不安全但更高效

多线程一般选用StringBuffer  运用StringBuilder将上诉练习中的StringBuffer改掉即可 以后用StringBuilder开发

升级三个因素:1,提高效率 2,简化书写 3,提高安全性

1.5以后基本数据类型对象包装类:

基本数据类型    引用数据类型(类)

byte Byte

short Short

int Integer

char Character

long Long

boolean Boolean

float Float

double Double

基本数据类型对象包装类的最常见作用:就是用基本数据类型和字符串类型之间做转换.

基本数据类型转成字符串
基本数据类型 +""即转换完成

基本数据类型.toString(基本数据类型值);
例:Integer.toString(34);//将34整数变成"34";

字符串转成基本数据类型
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");//将"123"转换成整数
boolean b = Boolean.parseBoolean("true");
Integer i = new Integer("123");
int num = i.intValue();

十进制转成其他进制
toBinaryString();
toHexString();
toOctaltring();

a651
其他进制转成十进制
parseInt(String,radix);
例 int x = Integer.parseInt("3c",16);//16表示转成16进制

Integer x = new Integer("123");

Integer y = new Integer(123);

x==y;不成立 x.equals()y;成立

JDK1.5版本以后出现的新特性:

Integer x = new Integer(4);可简写为 Integer x = 4;//自动装箱 即new Integer(4);

上方的x =x+2  x=/* x.intValue() x进行的隐藏操作*/ x + 2;//可以直接运行.因为 x+2:x进行自动拆箱,变成了int类型,然后和2进行加法运算.再将和进行装箱赋给x.

Integer m = 128;  

Integer n = 128;

m==n;false

Integer a = 127;

Integer b = 127;

m==n;true//因为a和b指向了同一个Integer对象, 因为当数值在byte范围内时,对于新特性,如果该值已经存在,则不会再开辟新的空间