1 字符串是一个特殊的对象,一旦初始化就不可以被改变
String s1="abc"; //s1是一个类类型变量,所以"abc"是一个对象,只要是用双引号括起来就是一个字符串对象
String s2="abc"; // abc对象在上面已经创建,不会重复创建,变的是s1引用
s3="abcde";
注意:
2 String s1="abc";
String s2=new String("abc");
s1和s2有什么区别?
s1代表一个对象 "abc"
s2有两个对象: "new String"和"abc"
System.out.println(s1==s2); false //s1和s2是两个不同的引用
System.out.println(s1.equals(s2)); true //因为字符串复写了object类中的equals方法,比较的是两个值的大小
3
String s1="abc";
String s2=new String("abc");
String s3="abc";
System.out.println(s1==s2); false
System.out.println(s1==s3); true //因为前面已经创建了一个abc,所以下面s3发现字符串常量 池里面有了这个对象,就不用再创建了,节约空间,所有s1和s3指向同一个对象,地址值一样
4字符串的操作
获取
1 ) int length() 获取长度
注意数组也有获取长度,但数组是length属性,不是方法没有()的
2)根据位置获取某一位置上某个字符
char charAt(int index)
3) 根据字符获取该字符在字符串中位置
int indexOf(int ch) 返回的是字符在字符串第一次出现的位置,返回ch在字符串中的位置 如果没有找到返回-1
int indexOf(int ch,int fromIndex) 从fromIndex指定位置开始索引,回ch在字符串中的位置 如果没有找到返回-1
int indexOf(String str) 返回的是字符在字符串第一次出现的位置,返回ch在字符串中的位置 如果没有找到返回-1
int indexOf(Sting str,int fromIndex) 从fromIndex指定位置开始索引,回str在字符串中的位置 如果没有找到返回-1
String s1="abc"; //s1是一个类类型变量,所以"abc"是一个对象,只要是用双引号括起来就是一个字符串对象
String s2="abc"; // abc对象在上面已经创建,不会重复创建,变的是s1引用
s3="abcde";
注意:
2 String s1="abc";
String s2=new String("abc");
s1和s2有什么区别?
s1代表一个对象 "abc"
s2有两个对象: "new String"和"abc"
System.out.println(s1==s2); false //s1和s2是两个不同的引用
System.out.println(s1.equals(s2)); true //因为字符串复写了object类中的equals方法,比较的是两个值的大小
3
String s1="abc";
String s2=new String("abc");
String s3="abc";
System.out.println(s1==s2); false
System.out.println(s1==s3); true //因为前面已经创建了一个abc,所以下面s3发现字符串常量 池里面有了这个对象,就不用再创建了,节约空间,所有s1和s3指向同一个对象,地址值一样
4字符串的操作
获取
1 ) int length() 获取长度
注意数组也有获取长度,但数组是length属性,不是方法没有()的
2)根据位置获取某一位置上某个字符
char charAt(int index)
3) 根据字符获取该字符在字符串中位置
int indexOf(int ch) 返回的是字符在字符串第一次出现的位置,返回ch在字符串中的位置 如果没有找到返回-1
int indexOf(int ch,int fromIndex) 从fromIndex指定位置开始索引,回ch在字符串中的位置 如果没有找到返回-1
int indexOf(String str) 返回的是字符在字符串第一次出现的位置,返回ch在字符串中的位置 如果没有找到返回-1
int indexOf(Sting str,int fromIndex) 从fromIndex指定位置开始索引,回str在字符串中的位置 如果没有找到返回-1
int lastIndexOf(int ch) 从右往左查找,返回的是字符在字符串第一次出现的位置,返回ch在字符串中的位置 如果没有找到返回-1
/*
获取一个字符在另个字符串出现的次数
*/
class SubCount
{
public static void main(String[] args)
{
String s1="abckkcckkaakkcckk";
String s2="kk";
getSubCount2(s1,s2);
}
public static void getSubCount(String s1,String s2)
{
int index=0,count=0;
while((index=s1.indexOf(s2))!=-1)//在s1中查找s2第一次出现的位置,没有找到返回-1
{
count++;
s1=s1.substring(index+s2.length());
}
System.out.println(count);
}
//方法2
public static void getSubCount2(String s1,String s2)
{
int index=0,count=0;
while((index=s1.indexOf(s2,index))!=-1)//从index开始在s1中查找s2在s1中第一次出现的位置,没有找到就返回-1
{
count++;
index=index+s2.length();
}
System.out.println(count);
}
}
4)判断:
4.1) 字符串中是否包含某一个子串
boolean contains(str)
也可以用indexOf(int str)来判断,返回-1,代表在字符串中不存在
/*
两个字符串,大的字符串中包含小的字符串的最大子串
*/
class SubTest
{
public static void main(String[] args)
{
String s1="abcdegkflldjja";
String s2="avcdegkfdd";
System.out.println(sub(s1,s2));
}
//定义一个功能,返回最大子串
public static String sub(String s1,String s2)
{
String max=(s1.length()>s2.length()?s1:s2);
String 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.indexOf(temp)!=-1)
return temp;
}
}
return "";
}
}
4.2 )字符串中是否有内容
boolean isEmpty():原理就是判断长度是否为0
4.3) 字符串是否是以指定内容开头
boolean startsWith(str);
4.4) 字符串是否是以指定内容结尾
boolean endsWith(str);
4.5 )判断字符串内容是否相同,复写了Object类中的equals方法,判断两个数的大小
boolean equals(str);
4.6 )判断内容是否相同,并忽略大小写
boolean equalsIgnoreCase();
5)转换:
5.1) 将字符数组转成字符串
构造函数:String(char[])
String(char[],int offset,int count) 字符数组一部分转为字符串count:个数 offset:起始位
5.2)静态方法:static String copyValueOf(char []);
static String copyValueOf(char[],int offset,int count)
static String valueOf(char[]);
5.3) 将字符串转成字符数组
char[] toCharArray();
5.4)将字节数组转成字符串
构造函数:String(byte[])
String(byte[],int offset,int count) 字符数组一部分转为字符串count:个数 offset:起始位
5.5) 将字符串转成字节数组
byte[] getBytes();
5.6)将基本数据类型转成字符串
static String valueOf(int x)
static String value(double d)
3+"";//String.valueOf(3);左右两边都能把3转为字符串
6)
替换:
String replace(oldchar,newchar);
boolean startsWith(str);
4.4) 字符串是否是以指定内容结尾
boolean endsWith(str);
4.5 )判断字符串内容是否相同,复写了Object类中的equals方法,判断两个数的大小
boolean equals(str);
4.6 )判断内容是否相同,并忽略大小写
boolean equalsIgnoreCase();
5)转换:
5.1) 将字符数组转成字符串
构造函数:String(char[])
String(char[],int offset,int count) 字符数组一部分转为字符串count:个数 offset:起始位
5.2)静态方法:static String copyValueOf(char []);
static String copyValueOf(char[],int offset,int count)
static String valueOf(char[]);
5.3) 将字符串转成字符数组
char[] toCharArray();
5.4)将字节数组转成字符串
构造函数:String(byte[])
String(byte[],int offset,int count) 字符数组一部分转为字符串count:个数 offset:起始位
5.5) 将字符串转成字节数组
byte[] getBytes();
5.6)将基本数据类型转成字符串
static String valueOf(int x)
static String value(double d)
3+"";//String.valueOf(3);左右两边都能把3转为字符串
6)
替换:
String replace(oldchar,newchar);
7)
切割:
Sting[] split(regex);
子串 获取字符串中的一部分
String substring(begin);
String substring(begin,end); 包含头不包含尾
8)转换 ,去除空格,比较
8.1) 将字符串转换成大写或小写
String toUpperCase();
Sting toLowerCase();
8.2) 讲字符串的两端空格去除
String trim()
/*
删除字符串两端空格的原理
分别从字符串两端判断,角标对应的元素是否是空格,然后依据判断让角标++或者--
*/
class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static String myTrim(String str)
{
int start=0;
int end=str.length()-1;
while(str.charAt(start)==' '&&start<=end)
start++;
while(str.charAt(end)==' '&&start<=end)
end--;
return str.substring(start,end+1);
}
public static void main(String[] args)
{
String s1=" text.java ";
sop(s1); //去除空格前打印
myTrim(s1); //去除空格
sop(myTrim(s1)); //去除空格后打印
}
}
8.3) 将两个字符串进行自然顺序的比较
int s1.compareTo(s2)
如果s1=s2 返回0
s1=abc s2=acb
s1.compareTo(s2); 结果是-1 按顺序比下去,a=a b<c 而且相差1 b-c
9) StringBuffer是字符串缓冲区,是一个容器,当数据类型,个数,不确定的时候用方便
1而且长度是可变化的
2可以直接操作多个数据类型
3最终会通过toString方法变成字符串
9.1)存储
StringBuffer append():将指定数据添加到已有数据结尾处
StringBuffer insert(index,数据):可以将数据插入指定index位置
9.2)删除
StringBuffer delete(int start,int end):包含头不包含尾
StringBuffer deletteCharAt(int index):删除指定位置的元素
9.3)获取charAt()
9.4)修改StringBuffer replace(start,end,string);
9.5)反转StringBuffer reverse();
/*
将字符串反转的原理
*/
class ResverseTest
{
public static void main(String[] args)
{
String s="abcde";
resverse(s,1,3);
}
public static void resverse(String str,int x,int y)
{
char[] ch=str.toCharArray(); //把字符串转为字符数组
int start,end;
for(start=x,end=y-1;y>x;x++,y--) //定义for循环
{
swap(ch,start,end); //调用函数把位置调换
}
System.out.println(new String(ch)); //输出调转后的字符串
}
public static void swap(char[] ch,int x,int y) //定义互换位置函数
{
char temp=ch[x];
ch[x]=ch[y];
ch[y]=temp;
}
}
9.6)将缓冲区中指定数据存储到指定的数组中void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);
9.7).jdk1.5版本之后出现了StringBuilder
StringBuffer是线程同步 需要判断锁
StringBuilder是线程不同步 不需要判断锁,如果多线程用StringBuffer
以后开发,建议用StringBulider
升级三个因素:
提高效率
简化书写
提高安全性
StringBuffer是线程同步 需要判断锁
StringBuilder是线程不同步 不需要判断锁,如果多线程用StringBuffer
以后开发,建议用StringBulider
升级三个因素:
提高效率
简化书写
提高安全性
/*
StringBuffer的使用
*/
class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb=new StringBuffer();
StringBuffer s=sb.append("abtwdc");
sop(sb.delete(1,3));//删除角标为1,2的元素
sop(sb.deleteCharAt(1));//删除指定角标的元素
sb.append("mdcae");//向缓冲区添加元素
sop(sb.replace(1,2,"java"));//包含头不包含尾把1角标的元素替换为"java"
char[] chs=new char[5];
sb.getChars(2,4,chs,2);//在容器中截取角标2和3的元素,从数组的角标2开始依次放进数组
for(int x=0;x<chs.length;x++)
{
System.out.println(chs[x]+"x");
}
}
public static void sop(Object str)
{
System.out.println(str);
}
11)基本数据类型对象包装类
基本数据类型对象包装类的最常见作用
就是用于基本数据类型和字符串类型之间做转换
byte Byte
short short
int Integer
long Long
boonean Boolean
float Float
double Double
char Character
11.1) 基本数据类型转成字符串:
基本数据类型+""
基本数据类型.toString(基本数据类型值)
如:Integer.toString(34);
11.2)字符串转成基本数据类型
就是用于基本数据类型和字符串类型之间做转换
byte Byte
short short
int Integer
long Long
boonean Boolean
float Float
double Double
char Character
11.1) 基本数据类型转成字符串:
基本数据类型+""
基本数据类型.toString(基本数据类型值)
如:Integer.toString(34);
11.2)字符串转成基本数据类型
xxx a=Xxx.parseXxx(String);
int a=Integer.parseInt("123");
double b=Double.parseDouble("123");
boolean b=Boolean.parseBoolean("true");
Integer i=new Integer("123");
int num=i.intValue();
11.3)十进制转为其他进制
toBinaryString();转为二进制
toHexString();转为16进制
toOctalString();转为8进制
11.4)其他进制转为十进制
Integer.parseInt(string str,int radix);
11.5) jdk1.5出来以后
Integer in=new Integer(3);和
Integer in=3;是一样的 //自动装箱 new Integer(3);
注意1:
Integer m=128,n=128; 判断m==n 这是false
Integer a=127,b=127; 判断a==b 这是true
这是因为a和b指向了同一个Ingeger对象,因为当数值在byte范围内,对于新特性,如果该数值已经存在,则不会再开辟空间
注意2:
Integer x=new Integer("123"); //自动把字符串转为基本数据类型
Integer y=new Integer(123);
判断x==y 这是false,因为指向的是不同的对象
判断x.equals(y); 这是true,因为复写了Object函数,只判断值是否相同
int a=Integer.parseInt("123");
double b=Double.parseDouble("123");
boolean b=Boolean.parseBoolean("true");
Integer i=new Integer("123");
int num=i.intValue();
11.3)十进制转为其他进制
toBinaryString();转为二进制
toHexString();转为16进制
toOctalString();转为8进制
11.4)其他进制转为十进制
Integer.parseInt(string str,int radix);
/*
其它进制转为十进制
*/
class IntegerDemo
{
public static void main(String[] args)
{
String s="123";
sop(Integer.parseInt("3")+1);//基本数据类型转为提升为对象包装类
sop(Integer.parseInt("3c",16));//十六进制转为十进制
sop(Integer.parseInt("110",2));//二进制转为十进制
sop(Integer.parseInt("Ox3",8));//八进制转为十进制
sop(Integer.toBinaryString(8));//十进制转为二进制
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
11.5) jdk1.5出来以后
Integer in=new Integer(3);和
Integer in=3;是一样的 //自动装箱 new Integer(3);
注意1:
Integer m=128,n=128; 判断m==n 这是false
Integer a=127,b=127; 判断a==b 这是true
这是因为a和b指向了同一个Ingeger对象,因为当数值在byte范围内,对于新特性,如果该数值已经存在,则不会再开辟空间
注意2:
Integer x=new Integer("123"); //自动把字符串转为基本数据类型
Integer y=new Integer(123);
判断x==y 这是false,因为指向的是不同的对象
判断x.equals(y); 这是true,因为复写了Object函数,只判断值是否相同