Java中字符串的学习（一）String类的概述及常见方法使用 - devtrees - 博客园
&转载请注明出处/devtrees/p/4347079.html
（拓展：Api:编程语言对外给我们提供的应用程序接口。）
一．概述：
我们平时上网发帖，帖子的标题、内容，QQ的聊天内容都是字符串。因为很常用，编程语言常常会把字符串封装成一类，实现方法，添加功能，以方便我们编程时的日常操作。
Java中将字符串封装成java.lang包下的String类。
查看javaapi，我们发现string是final所修饰的。代表着string这个类不能有子类。（也就是指类中对字符串操作的功能是不能被我们复写。）
String类代表字符串。Java程序中的所有字符串字面值（如&abc&）都作为此类的实例实现。也就是说，在java中，只要是被&&概括的内容都是字符串，都是string的一个具体对象。
查看java的api，我们发现string类有无参构造函数，也就是说：
String s = new String();等同于：String s = &&;
这样我们很容易发现第二种更简便，所以第一种初始化不多见。
下面来个小示例：
String s1 = &abc&;
对于这样一个string例子，s1是一个类类型变量，类类型变量，一定指向对象。所以&abc&是一个对象。所以字符串（即所有用双引号引起来的）是一个特殊的对象。
字符串最大特点：（对象）一旦被初始化，就不可以改变。（字符串常量）
String s = &abc&;
System.out.println(s);
打印输出的是kk。
可能有的朋友会有疑问，说不能改变，但为什么还会打印kk呢？
正如前面所说，s是一个类类型变量，s是可变的，它在一开始指向的是字符串对象（或者说常量）&abc&，而&abc&才是我们说的字符串对象，它这里面的内容是不会被其他东西改变的。同样&kk&也是一样。变的是s，不变的是&abc&和&kk&。同时&abc&和&kk&在内存中是同时存在的。
还是看api，我们发现在string的有参构造函数中，还可以传入字符串。
String s = &abc&;
String s1 = new String(&abc&);
在使用上都是一样的，但是有区别：
System.out.println(s == s1); //false,原因在于&abc&是一个对象，new String()是另一个对象。两者地址值不同。
System.out.println(s.equals(s1));//true,虽然String的父类Object类的equals()方法比较的是地址值，但是String类复写了父类的这一方法，该方法用于判断字符串是否内容相同。
String s = &abc&;
String s1 = new String(&abc&);
有什么区别？
s在内存中有一个对象
s1在内存中有两个对象
有关字符串常量池的简单说明
字符串是存储在一个叫常量池的内存中，以数组的形式进行存储像&a&，&b&和&c&这样的字符。
我们都知道，字符串是由字符数组组成。
当我们存&abc&时，内存将其放在数组中，然后我们又存一个&efg&,内存同样把它们分解放在数组中，而当我们再存储&abf&这个字符串时，内存会在数组中找到相应的字符来拼这个字符串。
引申出一道小练习：
String s1 = &abc&;
String s2 = new String(&abc&);
String s3 = &abc&;
System.out.println(s1==s2);
System.out.println(s1==s3);
答案分别输出：
关于第一个，我们上一部分已经说了。
那么第二个是怎么回事呢？
S1指向一个对象字符串，s3也指向一个字符串， s1创建的字符串之前已经在内存中存在。字符串作为一种特殊的对象，且是在常量池里存储的数据。S3在初始化时发现，字符串中的字符已经在内存中存在的话，因为字符串内容相同（字符数组相同），s3就不会再独立开辟内存空间了。
如果s3再开辟内存空间就会产生浪费空间的现象:字符串已经存在且不会再改变，所以就不会再开辟空间。
二．常见方法
前面已经说了String类是用于描述字符串事物。那么它就提供了多个方法对字符串进行操作。常见的操作有哪些？
1。1字符串中包含的字符数（长度）
int length();
注意：数组也有长度，也是length,但是数组的长度是属性，没有括号。
1.2根据位置获取位置上的某个字符。
char charAt（int index）当访问到字符串中不存在的脚标时，会发生字符串脚标越界异常：StringIndexOutOfBoundsException.
1.3根据字符获取该字符在字符串中的位置。
int indexOf(int ch);接收传入的参数是ascii码，返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中所在位置。
访问不到（字符串中没有这个字符）返回-1.
1.4根据字符串获取该字符串在字符串中的位置（大的字符串中找小字符串）
int indexOf(String str);接收传入的参数是ascii码，返回的是str在字符串中第一次出现的位置。
int indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中所在位置。
1.5根据字符反向获取该字符在字符串中的位置
int lastIndexOf(int ch);接收传入的参数是ascii码，返回的是ch在字符串中第一次出现的位置。
int lastIndexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中所在位置。
1.6根据字符串反向获取该字符串在字符串中的位置
int lastIndexOf(String str);接收传入的参数是ascii码，返回的是str在字符串中第一次出现的位置。
int lastIndexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中所在位置。
2.1字符串中是否包含某一个子串。
boolean contains(String str);
特殊变种：indexOf(String str)可以所以str第一次出现的位置，如果返回-1，表示该str不在字符串中存在。所以，也可以用于对指定字符串进行判断是否包含。而且该方法既可以判断，又可以获取出现的位置。
应用：如果只为判断，用contains，如果既要判断，又要获取位置用indexOf
2.2字符串中是否有内容
boolean isEmpty();原理就是判断长度是否为0
2.3字符串是否以指定内容开头
boolean startsWith(String str)
2.4字符串是否以指定内容结尾
boolean endsWith(String str)
2.5判断字符串的内容是否相同
boolean equals(String str)& 复写了Object类中的equals方法。
2.6判断字符串内容是否相同并忽略大小写
boolean equalsIgnoreCase()
3.1将字符数组转换成字符串
构造函数：在字符串的构造函数中就有一个构造函数是传入字符数组的，
String(char[] value)
在字符串初始化的时候，就能完成字符数组转换成字符串的操作。
还有它的一个的重载构造函数
String(char[] value,int offset,int count)：将字符数组中的一部分转换成字符串
其中 第二个参数是偏移位，第三个参数是个数
同理:还有一个字节数组的构造函数也是一样的。仅仅是多了一个编码集
静态函数& static String copyValueOf(char[] data),注意是静态的，因为其内部并没有操作特有数据。同样他也有重载函数，将字符数组中的一部分转化成字符串
& & & & & & & & & & & &static String copyValueOf(char[] data,int offset,int count)
& & & & & & & & & & & &static String valueOf(char[] data)
3.2将字符串转换成字符数组**
查找api技巧：肯定不是构造，转成数组，就会有返回值，且是char类型数组所以根据方法的返回值类型去找
char[] toCharArray(),这里为什么没有传入一个字符串参数呢？因为方法是由对象调用的，这里调用这个方法的对象就是一个字符串，所以括号内有隐藏的this.
3.3将字节数组转换成字符串(IO)
String(byte[] value)
String(byte[] value,int offset,int count) 将字节数组中的一部分转换成字符串
3.4将字符串转换成字节数组
byte[] getBytes()
3.5 将基本数据转换成字符串。
static String valueOf(int)
static String valueOf(double)
示例：String.valueOf(3)==&3&== 3+&&
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
String replace(char oldChar,char newChar),需要注意的是，返回的是一个新字符串，因为字符串一旦被创建就无法修改，所以返回的是一个新串。
如果要替换的字符不存在，返回的还是原字符串。但是这样一个字符一个字符的替换很麻烦。Java给我们提供了另外一个方法
String replace(CharSequence target,CharSequence replacement)这个方法可以直接接收、替换字符串。前一个参数是老串，后一个参数是新串。
还有其他两种方法：
String replaceAll(String regex,String replacement);
String replaceFirst(String regex,String replacement);
因为涉及正则表达式，暂时先不学习。了解其是按指定的规则进行替换即可。
注意：将一个字符串分隔成若干个字符串，返回的是字符串数组。
String[] split(String regex);
这里传入的参数也是一种规则，但这种规则有点特殊，不用指定规则（正则表达式），写入一般的字符串也可以。
String s = &zhangsan,lisi,wangwu&;
String[] arr = s.split(&,&);
for(intx = 0;x&arr.x++){
System.out.println(arr[x]);
注意：分割不等于获取，在本例中字符串中有&,&，而分割后获取得到的数组中没有&,&，分割字符串的标准字符串是获取不到的。
6.子串。获取字符串中的一部分（可以放在获取里）
String substring(int beginIndex):从指定位置到结尾。
String substring(int beginIndex,int endIndex)包含头，不包含尾。
如果脚标不存在，会出现字符串脚标越界异常。
在切割的案例中，我们可以将逗号的脚标索引出来，在用这里的方法获取姓名。就是麻烦，没有切割快。
将字符串转换成大写或者小写。
String toUpperCase();
String toLowerCase();
8.去除空格
将字符串两端的多个空格去除
String trim();
对两个字符串进行自然顺序(字典顺序)的比较
int compareTo(String str)
会有三种结果：大于、小于、等于
对象等于传入的参数返回0
对象小于传入的参数返回负数
对象大于传入的参数返回正数
返回的值是两个字符串中相同脚标对应字符的ASCII码值相比的结果，若相同就会会一直比下去，直到比出不同的，若不同，输出结果，不再继续比。
JDK1.5中，String类新增了一个很有用的静态方法String.format():&format(Locale l, String format, Object... args) 使用指定的语言环境、格式字符串和参数返回一个格式化字符串。&format(String format, Object... args) 使用指定的格式字符串和参数返回一个格式化字符串。
阅读(...) 评论()2011年4月 Java大版内专家分月排行榜第二2010年8月 Java大版内专家分月排行榜第二2010年5月 Java大版内专家分月排行榜第二2008年2月 Java大版内专家分月排行榜第二2007年7月 Java大版内专家分月排行榜第二
2011年2月 Java大版内专家分月排行榜第三2010年9月 Java大版内专家分月排行榜第三2008年9月 Java大版内专家分月排行榜第三2008年1月 Java大版内专家分月排行榜第三2007年11月 Java大版内专家分月排行榜第三2007年9月 Java大版内专家分月排行榜第三
2011年4月 Java大版内专家分月排行榜第二2010年8月 Java大版内专家分月排行榜第二2010年5月 Java大版内专家分月排行榜第二2008年2月 Java大版内专家分月排行榜第二2007年7月 Java大版内专家分月排行榜第二
2011年2月 Java大版内专家分月排行榜第三2010年9月 Java大版内专家分月排行榜第三2008年9月 Java大版内专家分月排行榜第三2008年1月 Java大版内专家分月排行榜第三2007年11月 Java大版内专家分月排行榜第三2007年9月 Java大版内专家分月排行榜第三
2011年4月 Java大版内专家分月排行榜第二2010年8月 Java大版内专家分月排行榜第二2010年5月 Java大版内专家分月排行榜第二2008年2月 Java大版内专家分月排行榜第二2007年7月 Java大版内专家分月排行榜第二
2011年2月 Java大版内专家分月排行榜第三2010年9月 Java大版内专家分月排行榜第三2008年9月 Java大版内专家分月排行榜第三2008年1月 Java大版内专家分月排行榜第三2007年11月 Java大版内专家分月排行榜第三2007年9月 Java大版内专家分月排行榜第三
2012年1月 其他开发语言大版内专家分月排行榜第二2011年5月 其他开发语言大版内专家分月排行榜第二2010年12月 其他开发语言大版内专家分月排行榜第二2009年2月 其他开发语言大版内专家分月排行榜第二2008年9月 其他开发语言大版内专家分月排行榜第二2008年8月 其他开发语言大版内专家分月排行榜第二2008年5月 其他开发语言大版内专家分月排行榜第二2007年11月 其他开发语言大版内专家分月排行榜第二
2011年4月 其他开发语言大版内专家分月排行榜第三2011年1月 其他开发语言大版内专家分月排行榜第三2009年6月 其他开发语言大版内专家分月排行榜第三2009年4月 其他开发语言大版内专家分月排行榜第三2009年1月 其他开发语言大版内专家分月排行榜第三2008年11月 其他开发语言大版内专家分月排行榜第三2008年7月 其他开发语言大版内专家分月排行榜第三2008年6月 其他开发语言大版内专家分月排行榜第三2006年9月 其他开发语言大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。2635人阅读
Java基础（14）
方式一：String a = “aaa” ;
方式二：String b = new String(“aaa”);
两种方式都能创建字符串对象，但方式一要比方式二更优。
因为字符串是保存在常量池中的，而通过new创建的对象会存放在堆内存中。
一：常量池中已经有字符串常量”aaa”
通过方式一创建对象，程序运行时会在常量池中查找”aaa”字符串，将找到的”aaa”字符串的地址赋给a。
通过方式二创建对象，无论常量池中有没有”aaa”字符串，程序都会在堆内存中开辟一片新空间存放新对象。
一：常量池中没有字符串常量”aaa”
通过方式一创建对象，程序运行时会将”aaa”字符串放进常量池，再将其地址赋给a。
通过方式二创建对象，程序会在堆内存中开辟一片新空间存放新对象，同时会将”aaa”字符串放入常量池，相当于创建了两个对象。
public class StringNewTest {
public static void main(String[] args) {
String a = "aaa";
String b = "aaa";
String c = new String("aaa");
System.out.println("a==b:"+(a == b));
System.out.println("a==c:"+(a == c));
System.out.println("a与b的值相等:"+(a.equals(c)));
a==c:false
a与b的值相等:true
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：9441次
排名：千里之外
原创：22篇
(5)(5)(12)Java中关于String类和Integer类的用法小结 -
- ITeye博客
& String是普通类，Integer又叫包装类，但你也可以认为他是普通类。其它包装类还包括Char,Short,Float。。。 注意，首字母是大写，java的默认规则（不成文）类名以大字开头
& 而相应的char,byte,short,float,int等是基本数据。
& 因此可以总结出Java的数据分类分为两大类： 1。基本数据(int,short,float,byte)生成出来的变量不是具体对象，跟Object没有任何关系； 2。类数据：每个变量都是对象，所有对象都是Object类的子类或子孙。
String类的用法：
　　public final class String extends Object　implements Serializable, Comparable&String&, CharSequence
　　String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现
　　常用方法：
　　public char charAt(int index)
　　返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。
　　序列的第一个 char 值位于索引 0 处，第二个位于索引 1 处，依此类推，这类似于数组索引。
　　public int compareTo(String anotherString)
　　按字典顺序比较两个字符串
　　public String concat(String str)
　　将指定字符串连接到此字符串的结尾
　　public String replace(char oldChar,
　　char newChar)
　　返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
　　public String[] split(String regex)
　　根据给定正则表达式的匹配拆分此字符串。
　　public String trim()
　　返回字符串的副本，忽略前导空白和尾部空白。
　　public char[] toCharArray()
　　将此字符串转换为一个新的字符数组
　　public int indexOf(String str,&&&&&&&&&&&&&&&&&& int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始下面给出一个实例参考String类的用法
　　/**
　　* 测试String的常用方法
　　*/
　　public class TestString {
　　/**
　　* 统计字符串中大写字母的个数，小写字母的个数，非字母的个数
　　* @param str 字符串
　　*/
　　private static void countString(String str) {
　　int countUpperNumber = 0;
　　int countLowerNumber = 0;
　　int countOtherNumber = 0;
　　for (int i=0; i&str.length(); i++) {
　　char ch = str.charAt(i);
　　if (ch &= 'A' && ch &= 'Z') {
　　countUpperNumber ++; //注意++的格式
　　} else if (ch &= 'a' && ch &= 'z') {
　　countLowerNumber ++;
　　} else {
　　countOtherNumber ++;
　　}
　}
　　System.out.println("字符串" + str + "\n大写字母数为：" + countUpperNumber+ "\t小写字母数为:" + countLowerNumber + "\t非字母数为:" + countOtherNumber);
　　}
　　/**
　　* 输出在一个字符串中指定字符串出现的次数
　　* @param src原字符串 sub子串
　　*/
　　private static void count(String src, String sub) {
　　int count = 0;
　　int subLength = sub.length();
　　int srcLength = src.length();
　　int index = 0;
　　int pos = 0;
　　while (index & srcLength) {
　　pos = src.indexOf(sub, index);
　　if (pos != -1) {
　　count ++;
　　index =
　　index += subL
　　} else {
　　
　　}
　　}
　　System.out.println(sub + "在" + src +"中出现" + count + "次");
　　}
　　/**
　　* 测试String中方法的用法
　　* @param args
　　*/
　　public static void main(String[] args) {
　　String s1 = "hello";
　　String s2 = "world";
　　String s3 = "hello";
　　System.out.println(s1 == s3);&
&&& //true 字符常量保存在data segment，一般相同的常量在data segment只有一份
　　s1 = new String("hello");
　　s2 = new String("hello");
　　System.out.println(s1 == s2); //false
　　System.out.println(s1.equals(s2));
&&& //true 类String重写了Object的equals方法
　　char c[] = {'s', 'u', 'n', ' ', 'j', 'a', 'v', 'a'};
　　String s4 = new String(c);
　　String s5 = new String(c,4,4);
　　System.out.println(s4); //sun java
　　System.out.println(s5); //java
　　s1 = "sun java";
　　s2 = "Sun Java";
　　System.out.println(s1.charAt(1)); //u 字符串是从0记数的
　　System.out.println(s2.length()); //8
　　System.out.println(s1.indexOf("java")); //4
　　System.out.println(s1.indexOf("Java")); //-1
　　System.out.println(s1.equals(s2)); //false
　　System.out.println(s1.equalsIgnoreCase(s2)); //true
　　String s = "我是程序员，我在学java";
　　String str = s.replace('我', '你');
　　System.out.println(str); //你是程序员，你在学java
　　s = "Welcome to Java World!";
　　str = "& sun java&&& ";
　　System.out.println(s.startsWith("Welcome")); //true
　　System.out.println(s.endsWith("World")); //false
　　System.out.println(s.toLowerCase()); //把字符串全改为小写& welcome to java world!
　　System.out.println(s.toUpperCase()); //把字符串全改为大写 WELCOME TO JAVA WORLD!
　　String subs = s.substring(11);
　　System.out.println(subs); //Java World!
　　String sp = str.trim();
　　System.out.println(sp); //sum java
　　int j = 1234567;
　　String sNumber = String.valueOf(j);
　　System.out.println("j 是" + sNumber.length() + "位数");
　　s = "Mary,F,1985";
　　String[] split = s.split(",");
　　for ( String str1 : split) {
　　System.out.println(str1);
　　}
　　str = "ab cdGF;D&& ";
　　countString(str);
　　String src = "jav attja vattt aj";
　　String sub = " a";
　　count(src, sub);
　　}
}
Integer类的使用方法
Interger：整数类型
１、属性。
static int MAX_VALUE：返回最大的整型数；
static int MIN_VALUE：返回最小的整型数；
static Class TYPE ：返回当前类型。
例子：
System.out.println("Integer.MAX_VALUE: " + Integer.MAX_VALUE );
结果为：Integer.MAX_VALUE:
２、构造函数。
Integer(int value) ：通过一个int的类型构造对象；
Integer(String s) ：通过一个String的类型构造对象；
例子：
Integer i = new Integer("1234");
生成了一个值为1234的Integer对象。
３、方法。
说明：
1. 所有方法均为public；
2. 书写格式：［修饰符］　&返回类型& &方法名（［参数列表］）&
如：
static int parseInt(String s) 表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。
1. byteValue()：取得用byte类型表示的整数；
2. int compareTo(Integer anotherInteger) ：比较两个整数。相等时返回０；小于时返回负数；大于时返回正数。
Integer i = new Integer(1234);
System.out.println("i.compareTo: " + i.compareTo(new Integer(123)) );
结果为：i.compareTo: 1
3. int compareTo(Object o) ：将该整数与其他类进行比较。如果o也为Integer类，进行方法2 的操作；否则，抛出ClassCastException异常。
4. static Integer decode(String nm) ：将字符串转换为整数。
5. double doubleValue() ：取得该整数的双精度表示。
6. boolean equals(Object obj) ：比较两个对象。
7. float floatValue() ：取得该整数的浮点数表示。
8. static Integer getInteger(String nm) ：根据指定名确定系统特征值。
9. static Integer getInteger(String nm, int val) ：上面的重载。
10. static Integer getInteger(String nm, Integer val) ：上面的重载。
11. int hashCode() ：返回该整数类型的哈希表码。
12. int intValue() ： 返回该整型数所表示的整数。
13. long longValue() ：返回该整型数所表示的长整数。
14. static int parseInt(String s) ：将字符串转换成整数。s必须是时进制数组成，否则抛出NumberFormatException异常。
15. static int parseInt(String s, int radix) ：以radix为基数radix返回s的十进制数。所谓的基数，就是“几进制”。
String s1 = new String("1010");
System.out.println("Integer.parseInt(String s, int radix): " + Integer.parseInt(s1,2) );
结果为：Integer.parseInt(String s, int radix): 10
16. short shortValue() ：返回该整型数所表示的短整数。
17. static String toBinaryString(int i) ：将整数转为二进制数的字符串。
18. static String toHexString(int i) ：将整数转为十六进制数的字符串。
19. static String toOctalString(int i) ：将整数转为八进制数的字符串。
20. String toString() ：将该整数类型转换为字符串。
21. static String toString(int i) ：将该整数类型转换为字符串。不同的是，此为类方法。
22. static String toString(int i, int radix) ：将整数i以基数radix的形式转换成字符串。
例子：
int i1 = 54321;
System.out.println("Integer.toString(int i, int radix): " + Integer.toString(i1,16) );
结果为：Integer.toString(int i, int radix): d431
23. static Integer valueOf(String s) ：将字符串转换成整数类型。
24. static Integer valueOf(String s, int radix) ：将字符串以基数radix的要求转换成整数类型。
& 希望大家在以后实际应用时能更深刻地理解这两个类的用法。
浏览: 5453 次
来自: 长沙
↖(^ω^)↗用户名：其实你可以
文章数：29
访问量：38597
注册日期：
阅读量：1297
阅读量：3317
阅读量：447435
阅读量：1132674
51CTO推荐博文
&该方法的定义为：public boolean contains(CharSequence&s) ，用作当且仅当此字符串包含指定的 char 值序列时，返回 true。注意这里的参数是一个CharSequence，如果我们用char作为参数，比如：
String&s&=&&abcd&;&System.out.println(s.contains('a'));&
会报语法错误：The method contains(CharSequence) in the type String is not applicable for the arguments (char)。参数类型不匹配。
打开api我们看到CharSequence是一个interface，所以我们没法直接用它的对象，只能用它的实现类的对象，它有几个实现类String，StringBuilder等，所以我们这里传入String的对象即可。
System.out.println(s.contains(&a&));&
&本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：┆阅读(0)┆评论(0)