Java基础——String类、StringBuffer、Integer
2015-07-12 11:36
579 查看
String概述
凡是带”“的都是String的实例对象。
String s1 = "abc";
s1是一个类类型变量,“abc”是一个对象。
字符串的最大特点就是,一旦被初始化就不可以被改变。
那么:
String s1 = "abc"; s1 = "kk";
这时候打印s1的值是kk;
这是为什么呢?不是说字符串一初始化就不能改变的吗?
对,不能改变,abc没有变,被赋值为kk之后abc还在内存中,变了的是s1,s1的引用由abc变为了kk。
定义字符串有两种方法:
String s1 = new String("abc"); String s2 = "abc"; System.out.println(s1==s2);//false System.out.println(s1.equals(s2));//true
实验结果为false 和true 这是为什么呢?
因为“==”符号判断的是hash值,也就是说比较的是数据在内存中的存放地址。
在Object类中定义的equals方法里边调用的也是“==”(比较地址值)
但是String类复写了Object的equals方法,所以String类中调用的equals方法比较的是字符串的值。所以出现结果为真的现象。
那么在以上的s1和s2有什么区别呢?
s1在内存中有两个对象。(abc,s1)
s2在内存中有一个对象。(abc)
(字符串在内存中有一个常量池,里边是一个数组,当要新建一个abc字符串的时候,在数组中存入[a][c],如果要新建一个def字符串的时候,在数组中存入[d][e][f],如果这时候要创建一个新的字符串abf,就不会再数组中重新存储数据,而是将之前存入的[a][b][f]重新组成一个字符串作为引用。)
String s = “abc”;
这句话会在常量池中寻找有没有abc这样的字符串,有的话,直接引用过来,没有的话在常量池中新建一个abc,再建立引用。
String s = new String (“abc”);
这句话指明了,我要新(new)的,我不要旧的,所以就不会在常量池中寻找,直接新建了一个字符串。
实例:
public class StringMethodDemo { public static void main(String[] args) { String s1 = "abc"; String s2 = new String("abc"); String s3 = "abc"; System.out.println(s1==s2); System.out.println(s1==s3); } }
运行结果:
String类中的常见功能
[b]String类是用于描述字符串事物的,那么他就提供了多个方法对字符串进行操作常见的操作有:
1,获取。
字符串中的包含的字符数,也就是字符串的长度。
int length();获取长度
根据位置获取位置上的某个字符:
char charAt(int index)
根据字符获取该字符在字符串中的位置。
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在字符串中出现的位置。
public class StringMethodDemo { public static void sop(Object obj) { System.out.println(obj); } public static void method_get() { String s = "abcdefabc"; //获取长度: sop(s.length()); //获取指定角标下的字符 sop(s.charAt(4)); //获取指定元素第一次出现的位置 sop(s.indexOf('a')); //获取指定元素从指定位置开始在字符串中第一次出现的位置。 sop(s.indexOf('a',4)); //获取指定字符串在字符串中第一次出现的位置 sop(s.indexOf("a")); //获取指定字符串从指定位置开始在字符串中第一次出现的位置。 sop(s.indexOf("a",4)); //从后往前找指定字符在字符串中第一次出现的位置 sop(s.lastIndexOf("a")); } public static void main(String[] args) { method_get(); } }
运行结果是:
2,判断:
字符串中是否包含某一个子串
boolean contains(str)
特殊之处:indexOf(str)可以索引str第一次出现的位置,如果返回-1,表示该str不在字符串中存在。所以,也可以用于对指定判断是否包含。
if(str.indexOf("aa")!=-1)
而且该方法既可以判断,又可以获取出现的位置。
字符串中是否有内容
boolean isEmpty();原理就是判断长度是否为0
字符串是否是以指定内容开头
boolean startsWith(str);
字符串是否是以指定内容结尾
boolean endsWith(str);
判断字符串内容是否相同,复写了Object类中的equals方法。
boolean equals(str);
判断内容是否相同,并忽略大小写。
boolean equalsIgnoreCase();
public class StringMethodDemo { public static void sop(Object obj) { System.out.println(obj); } public static void method_is() { String str = "ArrayDemo.java"; //判断是否是以“Array”开头的 sop(str.startsWith("Array")); //判断中间是否包含“Demo” sop(str.contains("Demo")); //判断是否是以“.java”结尾的 sop(str.endsWith(".java")); //判断字符串是否相同 sop(str.equals("arraydemo.java")); //忽略大小写判断字符串是否相同 sop(str.equalsIgnoreCase("arraydemo.java")); } public static void main(String[] args) { method_is(); } }
运行结果为:
3,转换;
将字符数组转换成字符串
构造函数:
String(char[]):将字符数组转换成字符串
String(char[],offset,count);将字符数组的一部分转换成字符串,参数依次为:字符数组,起始位置的角标,一共要转换成字符串的个数。
静态方法:
static String copyValueOf(char[]);
static String copyValueOf(char[] data,int offset,int count);
static String valueOf(char[]);
将字符串转成字符数组
char[] toCharArray();
将字节数组转换成为字符串
String(byte[])
String(byte[],offset,count);将字节数组中的一部分转成字符串
将字符串转成字节数组:
byte[] getBytes();
将基本数据类型转换成字符串
static String valueOf(int);
static String valueOf(double);
//3+”“和String.valueOf(3);没什么区别
特殊:字符串和字节数组在转换过程中,是可以指定编码表的。
示例:
public class StringMethodDemo { public static void sop(Object obj) { System.out.println(obj); } public static void method_trans() { //字符数组转换成字符串 char[] chs ={'a','b','c','d','e','f','g'}; String str = new String(chs); String str1 = new String(chs,1,4); sop("str="+str); sop("str1="+str1); //将字符串转成字符数组: char[] arr = str.toCharArray(); for (int x =0;x<arr.length ;x++ ) { sop("char["+x+"]="+arr[x]); } //将字符串转换成字节数组 byte[] bts = str.getBytes(); for (int x = 0;x<bts.length ;x++ ) { sop("bts["+x+"]="+bts[x]); } } public static void main(String[] args) { method_trans(); } }
运行结果:
4,替换
String replace(oldchar,newchar);将字符串中的匀速进行替换
示例:
public class StringMethodDemo { public static void sop(Object obj) { System.out.println(obj); } //替换方法 String replace(oldchar,newchar); public static void method_replace() { String s1 = "hello java"; String s2 = s1.replace("a","n");//可以单个字符进行调换 String s3 = s1.replace("java","world");//也可以将指定的字符串进行调换 System.out.println(s1); System.out.println(s2); System.out.println(s3); } public static void main(String[] args) { method_replace(); } }
运行结果:
需要注意的是,替换之后的字符串在内存中还存在,因为字符串只要一被创建就不会被改变。
5,切割
String [] split(regex);
将给定字符串用指定的符号切割出来,显然返回来的是一个字符串数组
示例:
public class StringMethodDemo { public static void sop(Object obj) { System.out.println(obj); } //切割方法 String[] split(regex); public static void method_split() { String s1 = "zhangsan,lisi,wangwu"; String[] arr=s1.split(","); //里边指定切割的参照符号,用“”括起来 for (int x =0;x<arr.length ;x++ )//用循环遍历打印出切割出来的字符串 { System.out.println("String["+x+"]=="+arr[x]); } } public static void main(String[] args) { method_split(); } }
运行结果:
6,子串,获取字符串中的一部分
String substring(begin);从指定位置开始到结尾
String substring(begin,end);包含头不包含尾
public class StringMethodDemo { public static void sop(Object obj) { System.out.println(obj); } //获取子串,substring(start,end)//substring(start) public static void method_substring() { String s1 = "nihaowojiaoheshuaishuai"; String s2 = s1.substring(5); //获取从5角标开始到字符串结束中间的字符串 String s3 = s1.substring(0,s1.length()); //获取从0角标开始,到字符串结束中间的字符串。(包含头不包含尾) sop(s1); sop(s2); sop(s3); } public static void main(String[] args) { method_substring(); } }
运行结果:
7,转换,去除空格,比较
将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
将字符串两端的多个空格去除
String trim();
对两个字符串进行自然顺序的比较
int compareTo(String);
public class StringMethodDemo { public static void sop(Object obj) { System.out.println(obj); } //转换,去空格,比较 public static void method() { //转换。转换字符串的大小写 String s1 = " Hello Java "; String s2 = s1.toUpperCase();//将所有字符转换为大写形式 String s3 = s1.toLowerCase();//将所有字符抓换成小写形式 sop(s1); sop(s2); sop(s3); //去除字符串两端的空格: String s4 = s1.trim(); sop(s4); //比较(按照字典顺序比较两个字符串的大小,实际上就是按照ASCII值比较的) String s5 = "abc"; String s6 = "acd"; int x = s5.compareTo(s6); //如果s5比s6小,则会返回一个<0的值,如果s5比s6大,则会返回一个>0的数, //至于返回的是多少:在以上字符串中,先比较a相同,再比较第二位,s5第二位是b,s6第二位是c,所以b-c=-1(比较ASCII码值) sop(x); } public static void main(String[] args) { method(); } }
运行结果:
练习:模拟trim方法的代码
//需求:写一个模拟trim方法的代码。将字符串两端的空格去除 /* 思路,取字符串开始的角标为指针,判断是不是空格,如果是空格,指针++ 从后往前数也一样的道理 然后把指针中间的字符串取出来就行了 需要注意的是,两个指针一个往后走,一个往前走,不能跑的错开了。 */ public class MyTrim { public static void main(String[] args) { String s = " ni hao "; String s1 = mytrim(s); sop(s); sop(s1); } public static void sop(Object obj) { System.out.println(obj); } public static String mytrim(String s)//定义自己的去空格方法 { int pos_start = 0,pos_end = s.length()-1;//定义连个指针 ,分别在开头和结尾处 while (s.charAt(pos_start)==' ' && pos_start<pos_end)//判断指针所在的位置的字符是不是空格,是则指针再往前走 { pos_start++; } while (s.charAt(pos_end)==' ' && pos_start<pos_end) { pos_end--; } return s.substring(pos_start,pos_end+1);//返回两个指针中间的字符串,记住获取子串包含头不包含尾。 } }
运行结果:
练习二:定义方法将字符串进行反转。
//需求:将一个字符串进行反转 /* 思路: 先把字符串转换成字符数组, 将字符数组进行反转 再把字符数组变成字符串 */ public class ReverseStringDemo { public static void sop(Object obj)//为了方便定义的打印方法 { System.out.println(obj); } public static String reverseString(String s)//反转字符串的方法 { return reverseString(s,0,s.length());//返回反转后的整个字符串。(包含头不包含尾) } 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[] arr,int x,int y)//调换位置的方法 { char temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } //为了提高方法的扩展性,这里给定不同的参数进行函数的重载。 //将字符串中的指定位置的字符串进行反转。 public static String reverseString(String s,int start,int end) { char[] chs = s.toCharArray();//先将字符串变成字符数组 reverse(chs,start,end);//反转数组 return new String(chs);//将字符数组变成字符串并返回 } public static void main(String[] args) { String s = " ab cd "; //给定一个字符串 sop("("+s+")");//打印原字符串 sop("("+reverseString(s)+")");//将整个字符串反转 sop("("+reverseString(s,4,9)+")");//将字符串中的指定序列的字符串反转 } }
运行结果为:
练习三:获取一段字符串在另一段字符串中出现的次数
//获取一个字符串在另一个字符串中出现的次数 /* 思路:先要有一个计数器 需要用到indexOf,所以就需要有每次开始数的角标 然后每见到一次key的值,计数器加1 */ public class KeyStringCount { public static void sop(Object obj) { System.out.println(obj); } public static int function(String str,String key)//给两个参数,一个是字符串,一个是要寻找的子串 { int count = 0;//计数器 int index = 0;//开始查找的位置(角标) while ((index = str.indexOf(key,index))!=-1)//当找到第一个匹配的时候,将找到的角标值加key的长度,作为下次开始找的角标值 { index = index+key.length(); count++; } return count; } public static void main(String[] args) { String s = "abqqcdqqefqqghqqijqqk";//5个qq sop("count===="+function(s,"qq")); } }
运行结果:
练习四:获取两个字符串中的最大相同子串
//需求:获取两个字符串中的最大相同子串 /* 思路:按短的那个字符串先找,找到了,就中了 找不到,就字符串长度减1,找一次,然后两边角标自增,再找一次, 找不到,就字符串长度减2,角标自增,一共找三次。 如果找到了,就把找到的那个切出来 */ public class GetMaxSubString { public static void sop(Object obj) { System.out.println(obj); } public static String getMaxSubString(String s1,String s2) { //因为不确定传进来的字符串参数哪个更长,所以先将长短区分出来,分别引用给Max和min String max,min; max = (s1.length()>s2.length())?s1:s2;//三目运算符,s1的长度大于s2吗,如果大于,将s1的值引用给max min = (max == s1)?s2:s1; //经过分析,判断最大相同子串要把短字符串每次去一位然后角标自增的方式, /* 长度 判断次数 第一次判断:0-min.length()-0 1 第二次判断:0-min.length()-1 2 第三次判断:0-min.length()-2 3 第四次判断:0-min.length()-3 4 */ for (int x = 0;x<min.length() ;x++ )//第一个for控制外层循环(判断)次数的 { for (int y = 0,z = min.length()-x;z!=min.length()+1 ;y++,z++ )//第二个for用来控制内层循环判断次数的 { String temp = min.substring(y,z);//每次循环都把判断过的子串取出来 if (max.contains(temp))//判断长字符串中是不是有该子串, return temp;//有的话就返回该字符串。 } } return ""; } public static void main(String[] args) { String s1 = "jfdlagehellorkajfalfd"; String s2 = "djkdhellodof"; sop(getMaxSubString(s2,s1)); } }
运行结果:
根据老师写的代码,下面是自己写的代码,同样可以实现这样的功能:
//需求:获取两个字符串中的最大相同子串 /* 写完后发现老师的代码在for循环的那一段不太好理解, 然后根据自己的想法,写了一段,可以运行 代码不分家,只要能实现功能就好 */ public class GetMaxSubString2 { public static void sop(Object obj) { System.out.println(obj); } public static String getMaxSubString(String s1,String s2) { String max,min; max = (s1.length()>s2.length())?s1:s2; min = (max == s1)?s2:s1; //经过分析,判断最大相同子串要把短字符串每次去一位然后角标自增的方式, /* 长度 判断次数 第一次判断:0-min.length()-0 1 第二次判断:0-min.length()-1 2 第三次判断:0-min.length()-2 3 第四次判断:0-min.length()-3 4 */ for (int x = min.length();x>-1 ;x-- )//第一个for控制字符串长度的 { for (int y = 0,z = x;z!=min.length()+1 ;y++,z++ )//第二个for用来控制内层循环判断次数的 { String temp = min.substring(y,z); if (max.contains(temp)) return temp; } } return ""; } public static void main(String[] args) { String s1 = "jfdlagehellorkajfalfd"; String s2 = "djkdhellodof"; sop(getMaxSubString(s2,s1)); } }
运行结果和上图相同。
StringBuffer
StringBuffer是字符串缓冲区,可以用于对字符串进行修改的是一个容器。
特点:
1 长度是可变化的。
2 可以直接操作多个数据类型
3 最终会通过toString方法变成字符串。
C : create U : update R : read D: delete
面盆理论:StringBuffer就是一个面盆,在里边加各种东西,完了返回来的还是这个面盆,同一个面盆,没有任何的改变,
public class StringBufferDemo { public static void main(String[] args) { StringBuffer sb = new StringBuffer(); StringBuffer sb1 = new StringBuffer();//新new了一个,不一样 StringBuffer sb2 = sb.append(345);//经过操作返回来的一个,还是原来的面盆 sop(sb==sb1);//false sop(sb==sb2);//true } public static void sop(Object obj) { System.out.println(obj); } }
1,存储。
StringBuffer append();将指定数据作为参数添加到已有数据的结尾处。
StringBuffer insert(Index,数据)可以将数据插入到指定位置。
class StringBufferDemo { public static void main(String[] args) { StringBuffer sb = new StringBuffer();//定义一个字符串容器 sb.append("abc").append(true).append(34);//在里边数据的末尾处先后添加各种类型的数据 sop(sb.toString());//abctrue34 sb.insert(1,"qq");//在1角标位置处添加qq字符串 sop(sb.toString());//aqqbctrue34 } public static void sop(Object obj) { System.out.println(obj); } }
2,删除
StringBuffer delete(start,end)删除缓冲区中的数据,包含头不包含尾
StringBuffer deleteCharAt()删除指定位置的字符。
//字符串缓冲区的删除方法演示 public class StringBufferDelete { public static void sop(Object obj) { System.out.println(obj); } public static void stringBufferDelete() { StringBuffer sb = new StringBuffer("abcdefghijk"); sop(sb.toString()); sb.delete(2,6);//将指定范围内的字符串删除 sop(sb.toString());//abghijk sb.deleteCharAt(0);//删除指定位置的字符 sop(sb.toString());//bghijk sb.delete(0,sb.length());//清空缓冲区 sop(sb.toString()+";"); } public static void main(String[] args) { stringBufferDelete(); } }
运行结果:
3,获取。
char charAt(Index)获取一个
int indexOf(String str);获取指定字符串出现的角标
int laseIndexOf(String str);倒序查找指定字符串出现的角标
int length() 获取容器里边字符串的长度
String subString(int start,int end)切出来的字符串
这里和Sting类中的方法一样的,,就不演示了。
4,修改
StringBuffer replace(start,end,string);修改区间内的一整片
void setCharAt(int Index,char ch);将指定位置的元素换成指定的字符。
//演示字符串缓冲区中的修改元素的方法 public class StringBufferReplace { public static void sop(Object obj) { System.out.println(obj); } public static void stringBufferReplace() { StringBuffer sb = new StringBuffer("hello world"); sop(sb.toString()); sb.replace(7,12,"java");//将sb中的元素,从角标7到角标12中的元素,替换成java sop(sb.toString()); sb.setCharAt(7,'J');//将hello java中的第7的元素换成J sop(sb.toString()); } public static void main(String[] args) { stringBufferReplace(); } }
运行结果:
5,反转
StringBuffer reverse()反转容器中的字符串
示例:
//演示字符串缓冲区的反转元素的方法 public class StringBufferReverse { public static void sop(Object obj) { System.out.println(obj); } public static void stringBufferReverse() { StringBuffer sb = new StringBuffer("abcdefghijk"); sop(sb.toString());//打印原字符串缓冲区中的字符串 sb = sb.reverse();//将容器中的字符串反转 sop(sb.toString());//打印反转后的字符串 } public static void main(String[] args) { stringBufferReverse(); } }
运行结果:
6, 将字符串缓冲区中的元素转移到指定数组中
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);
StringBuffer sb = new StringBuffer(); sb.append("abcdef"); char[] chs = new char[4]; sb.getChars(1,4,chs,3);//将sb中从角标1到角标4的元素转给chs数组,在数组中从1角标开始依次插入 for(int x = 0;x<chs.length;x++) { System.out.println("chs["+x+"]="+chs[x]+";"); }
运行结果:
在jdk1.5之后出现了StringBuilder。
StringBuffer是线程同步的。
StringBuilder是线程不同步的。
以后开发建议使用StingBuilder
升级三个因素
提高效率
简化书写
提高安全性
基本数据类型对象包装类
根据面向对象的原则,Java中将所有的东西都进行了包装,包括基本数据类型那么将基本数据类型封装成对象有什么用呢?
看下边的一个例子:
//基本数据类型的对象包装类 public class IntegerDemo { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { //假如我们想知道int类型的数值的最大值 sop(Integer.MAX_VALUE); //相同的道理,int类型的数值的最小值 sop(Integer.MIN_VALUE); } }
实验结果:
这并不是基本数据类型对象的最常见的作用,
最常见的作用就是:基本数据类型和字符串类型之间做转换,
基本数据类型转换成字符串:
基本数据类型+”“;
基本数据类型.toString(基本数据类型值);
如:Integer.toString(34);//将34整数变成“34”。
字符串转基本数据类型的操作:
//基本数据类型的对象包装类 public class IntegerDemo { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { //将一个字符串转成整数 int num = Integer.parseInt("123"); sop("num = "+(num+4));//127 } }
int a = Integer.parseInt(“123”);字符串中必须全是int类型的值,否则就是数字格式异常,这个事静态调用方式。
Integer i = new Integer(“123”);
int num = i.intValue();//这个是对象调用方式
其他类型道理也一样的
double b = Double.parseDouble(“12.23”);
boolean b = Boolean.parseBoolean(“true”);
十进制转成其他进制数
Integer.toBinaryString(6);//110 Integer.toOctalString(100);//144 Integer.toHexString(60);//3c
其他进制转换成十进制
parseInt("110",2);//6 parseInt("144",8);//100 parseInt("3c",16);//60
jdk1.5以后的新特性:
看一串代码:
//jdk1.5以后的新特性 public class IntegerDemo { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { Integer a = new Integer("123"); Integer b = new Integer(123); sop("a==b:"+(a==b)); sop("a.equals(b):"+a.equals(b)); } }
运行结果为:
出现这样的结果是为什么呢?
a==b为假,正常,因为都是新new的对象,地址值肯定不一样
a.equals(b)是因为他和字符串一样比较的是值。所以结果为真
再有一个示例:
//jdk1.5以后的新特性 public class IntegerDemo { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { Integer i = 4;//怎么可以直接将数字赋值给对象?在这里4是一个对象,因为Integer是一个类,i就是一个对象了,i指向的一定是对象。 //在这里,4会进行自动装箱,也就是会自动将4封装成对象,赋值给i(new Integer(4)) //在这里,Integer还可以赋值为null(新特征),编译不会出错,就是运算的时候会出现空指针异常 i = i+2; //新特性:i是一个对象,2是一个数字,两个不同类型的东西怎么能相加? //可以,在这里进行运算的时候,i会进行自动的拆箱,i.intValue();转换成int类型的值再进行运算 //计算完结果之后再将结果自动装箱,封装成对象,赋值给i } }
新特征3:
//jdk1.5以后的新特性 public class IntegerDemo { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { Integer a = 128; Integer b = 128; sop("a==b:"+(a==b)); Integer c = 127; Integer d = 127; sop("c==d:"+(c==d)); } }
运行结果:
为什么会出现这样的结果呢?
定义abcd的过程可以看成是:Integer a = new Integer(128);
abcd都是不同的对象,但是,区别在于赋给的数值不一样,
新特征3:对于byte范围内的值,如果该数值已经存在,则不会开辟新的空间,所以说c和d指向了同一个对象。(byte范围-128~127)
相关文章推荐
- EL与JSTL注意事项汇总
- javascript性能优化的几点建议
- HTML 5 的data-* 自定义属性
- HTML4+CSS2与HTML5+CSS3区别
- hadoop-2.6.0 Unhealthy Nodes 问题
- HTML5 – 1.基础
- jquery.callback.js jq 回调
- javascript定时器小结
- HTML5 Canvas八大核心技术及其API用法
- E-JSON数据传输标准
- E-JSON数据传输标准
- HDU 1088 — Write a simple HTML Browser
- Javascript 严格模式详解
- 页面通过jquery上的ajax请求到后台通过POI导出Excel的问题
- C#返回时间格式转换成 js 字符串
- JQuery UI——自动完成组件
- javascript用正则表达式检测用户名的合法性
- 剑指offer || 03_replaceBlank
- JavaScript——函数
- win7下安装fedora20双系统