String字符串的存储原理
第一部分
package com.bjpowernode.javase.test001;
/**
关于java JDK中内置的一个类:java.lang.String
1、String表示字符串类型,属于引用数据类型,不属于基本数据类型。
2、在java中随便使用双引号括起来的都是String对象,例如:"abc"、"def"、"hello world!",这是3个String对象。
3、java中规定,双引号括起来的字符串,是不可变的,也就是说"abc"自出生到死亡,不可变,不能变成"abcd"。
4、在JDK当中双引号括起来的字符串,例如:"abc""def"都是直接存储在"方法区"的"字符串常量池"当中的。
为什么SUN公司把字符串存储在一个"字符串常量池"当中呢,因为字符串在实际的开发中使用太频繁了。为了执行效率,
所以把字符串放到了方法区的字符串常量池当中。
*/
public class StringTest01 {
public static void main(String[] args) {
// 这两行代码表示底层创建了3个对象
String s1 = "abcdef";
String s2 = "abcdef" + "xyz";
// 分析:这是使用new的方式创建的字符串对象。这个代码中的"xyz"是从哪里来的?
// 凡是双引号括起来的都在字符串常量池中有一份。
// new对象的时候一定要在堆内存当中开辟空间。
String s3 = new String("xyz");
}
}
- String字符串的存储原理
第二部分
- User.class
package com.bjpowernode.javase.test001;
public class User {
private int id;
private String name;
public User() {
super();
}
public User(int id, String name) {
super();
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- UserTest
package com.bjpowernode.javase.test001;
public class UserTest {
public static void main(String[] args) {
User user = new User(110,"zhangsan");
}
}
- 程序内存结构图
第三部分
package com.bjpowernode.javase.test001;
public class StringTest02 {
public static void main(String[] args) {
String s1 = "hello";
// "hello"是存储在方法区的字符串常量池中
// 所以这个"hello"不会新建。(因为这个对象已经存在了)
String s2 = "hello";
// 双等号比较的是不是变量中保存的内存地址?是的
System.out.println(s1 == s2);// true
String x = new String("xyz");
String y = new String("xyz");
// 双等号比较的是不是变量中保存的内存地址?是的
System.out.println(x == y);// false
// 通过这个案例的学习,我们知道了,字符串对象之间的比较不能使用"=="
// "=="不保险,应该调用String类的equals方法
// String类已经通过重写了equals方法,以下的equals方法调用的是String类重写之后的equals方法
System.out.println(x.equals(y));// true
String k = new String("testString");
// "testString"这个字符串可以后面加"."呢?
// 因为"testString"是一个字符串对象,只要是对象都能调用方法。
System.out.println("testString".equals(k));// true
// String k1 = null;
// System.out.println("testString".equals(k1));// false 建议使用这种方式,因为这个可以避免空指针异常
// System.out.println(k1.equals("testString"));// java.lang.NullPointerException
}
}
String面试题
package com.bjpowernode.javase.test001;
// String面试题
// 分析以下程序,一共创建了几个对象
public class StringTest03 {
public static void main(String[] args) {
/*
* 一共3个对象:
* 方法区字符串常量池中有1个:"hello"
* 堆内存当中有两个String对象
*/
String s1 = new String("hello");
String s2 = new String("hello");
}
}
String的常用构造方法
package com.bjpowernode.javase.test001;
/**
* 关于String类的常用构造方法
* 第一个:String s = "";最常用
* 第二个:String s = new String("");
* 第三个:String s = new String(byte数组);
* 第四个:String s = new String(byte数组,起始下标,长度);
* 第五个:String s = new String(char数组);
* 第六个:String s = new String(char数组,起始下标,长度);
*/
public class StringTest04 {
public static void main(String[] args) {
// 创建字符串对象最常见的一种方式
String s1 = "hello world!";
// s1这个变量中保存的是一个内存地址
// 按说以下应该输出一个地址
// 但是输出一个字符串,说明String类已经重写了toString()方法
System.out.println(s1);//hello world!
System.out.println(s1.toString());//hello world!
// 这里只掌握常用的构造方法
byte[] bytes = {97,98,99};// 97是a,98是b,99是c
String s2 = new String(bytes);
// 前面说过:输出一个引用的时候,会自动地调用toString()方法,默认Object的话,会自动地调用对象的内存地址。
// 通过输出结果我们得出一个结论:String类已经重写了toString()方法。
// 输出字符串对象的话,输出的不是字符串对象的内存地址,而是字符串内容。
System.out.println(s2);
System.out.println(s2.toString());
// String(字节数组,数组元素下标的起始位置,长度)
// 将byte数组中的一部分转换成字符串
String s3 = new String(bytes,1,2);
System.out.println(s3);// bc
// 将char数组全部转换成字符串
char[] chars = {'我','是','中','国','人'};
String s4 = new String(chars);
System.out.println(s4);// 我是中国人
// 将char数组部分转换成字符串
String s5 = new String(chars,2,3);
System.out.println(s5);// 中国人
String s6 = new String("hello");
System.out.println(s6);// hello
}
}
String类的常用方法
package com.bjpowernode.javase.test001;
public class StringTest05 {
public static void main(String[] args) {
// String类中的常用方法
// 1.(掌握)char charAt(int index)
char c = "中国人".charAt(1);// "中国人"是 一个字符串String对象,只要是对象就能"."
System.out.println(c);// 国
// 2.(了解)int compareTo(String anotherString)
// 字符串之间比较大小不能直接使用 > <,要使用compareTo方法
int result = "abc".compareTo("abc");
System.out.println(result);// 0(等于0)前后一致 10 - 10 = 0
int result2 = "abcd".compareTo("abce");
System.out.println(result2);// -1(小于0)前小后大 8 - 9 = -1
int result3 = "abce".compareTo("abcd");
System.out.println(result3);// 1(大于0)前大后小 9 - 8 = 1
// 拿着字符串第一个字母和后面字符串的第一个字母比较,能分胜负就不再比较了。
int result4 = "xyz".compareTo("yxz");
System.out.println(result4);// -1
// 3.(掌握)boolean contains(CharSequence s)
// 判断前面的字符串中是否包含后面的子字符串
System.out.println("HelloWorld.java".contains(".java"));// true
System.out.println("http://www.baidu.com".contains("https://"));// false
// 4.(掌握)boolean endsWith(String suffix)
// 判断当前字符串是否以某个字符串结尾
System.out.println("test.txt".endsWith(".java"));// false
System.out.println("test.txt".endsWith(".txt"));// true
System.out.println("hellloWorld!".endsWith("World!"));// true
System.out.println("helloWorld!".endsWith("lloWorld!"));// true
// 5.(掌握)boolean equals(Object anObject)
// 比较两个字符串必须使用equals方法,不能使用"=="
// equals只能看出相等不相等
// compareTo可以看出是否相等,同时可以看出谁大谁小
System.out.println("abc".equals("abc"));// true
// 6.(掌握)boolean equalsIgnoreCase(String anotherString)
// 判断两个字符串是否相等,同时忽略大小写
System.out.println("ABc".equalsIgnoreCase("abC"));// true
// 7.(掌握)byte[] getByte()
// 将字符串对象转换成字节数组
byte[] bytes = "abcdef".getBytes();
for(int i = 0; i < bytes.length; i ++) {
System.out.println(bytes[i]);
}
// 8.(掌握)int indexOf(String str)
// 判断某个字符串在当前字符串第一次出现处的索引(下标)。
System.out.println("oraclejavac++.netcWphppythonjavaoraclec++".indexOf("java"));// 6
// 9.(掌握)boolean isEmpty()
// 判断某个字符串是否为空
String s = "";
System.out.println(s.isEmpty());// true
System.out.println("abc".isEmpty());// false
// 10.(掌握)int length()
// 面试题:判断数组长度和判断字符串长度不一样
// 判断数组长度是length属性,判断字符串长度是length()方法
System.out.println("abc".length());// 3
System.out.println("".length());// 0
int[] arr = {1,2,3,4};
System.out.println(arr.length);// 4
// 11.(掌握)int lastIndexOf(int ch)
// 判断某个字符串在当前字符串最后一次出现处的索引(下标)。
System.out.println("oraclejavac++.netcWphppythonjavaoraclec++".lastIndexOf("java"));// 28
// 12.(掌握)String replace(CharSequence target, CharSequence replacement)
// String的父接口就是CharSequence
String newStrings = "http://www.baidu.com".replace("http:", "https:");
System.out.println(newStrings);// https://www.baidu.com
// 把以下字符串中的"="替换成":"
String newString2 = "name=zhangsan&password=123&age=20".replace("=", ":");
System.out.println(newString2);// name:zhangsan&password:123&age:20
// 13.(掌握)String[] split(String regex)
// 拆分字符串
String[] ymd = "1980-10-11".split("-");
for(int i = 0; i < ymd.length; i ++) {
System.out.println(ymd[i]);
}
String[] parms = "name=zhangsan&password=123&age=20".split("&");
for(int i = 0; i < parms.length; i ++) {
System.out.println(parms[i]);
// 可以继续向下拆分,可以通过"="拆分。
String[] buf = parms[i].split("=");
for(int j = 0; j < buf.length; j ++) {
System.out.println(buf[j]);
}
}
// 14.(掌握)boolean startsWith(String prefix)
// 判断某个字符串是否以某个子字符串开始
System.out.println("http://www.baidu.com".startsWith("http"));// true
System.out.println("http://www.baidu.com".startsWith("https"));// false
// 15.(掌握)String substring(int beginIndex)参数是起始下标
// 截取字符串
System.out.println("http://www.baidu.com".substring(7));// www.baidu.com
// 16.(掌握)String substring(int beginIndex, int endIndex)【左闭右开】
System.out.println("http://www.baidu.com".substring(7,10));// www
// 17.(掌握)char[] toCharArray()
// 将字符串转换成char数组
char[] chars = "我是中国人".toCharArray();
for(int i = 0; i < chars.length; i ++) {
System.out.println(chars[i]);
}
// 18.(掌握)String toLowerCase()
// 转换成小写
System.out.println("ABc".toLowerCase());// abc
// 19.(掌握)String toUpperCase
// 转换成大写
System.out.println("abC".toUpperCase());// ABC
// 20.(掌握) String trim()
// 去除字符串前后空白
System.out.println(" hello world ".trim());// hello world
// 21.(掌握)String中只有一个方法是静态的,不需要new对象
// 这个方法叫做valueOf
// 作用:将“非字符串”转换成“字符串”
String s1 = String.valueOf(true);
System.out.println(s1);
String s2 = String.valueOf(100);
System.out.println(s2);
String s3 = String.valueOf(3.14);
System.out.println(s3);
// 这个静态的valueOf()方法,参数是一个对象的时候,会自动地调用该对象的toString()方法
String s4 = String.valueOf(new Customer());
//System.out.println(s4);// 没有重写toString()方法之前是调用对象内存地址com.bjpowernode.javase.test001.Customer@15db9742
System.out.println(s4);// 重写toString()方法之后 --> I am javaman!
// 现在我们可以研究下println源代码了
System.out.println(100);
System.out.println(3.14);
System.out.println(true);
Object object = new Object();
// 通过源代码可以看出,为什么输出引用的时候,会自动地调用toString()方法
// 本质上System.out.println()这个方法在输出任何数据的时候都是先调用toString()方法,再输出
System.out.println(object);// 对象的内存地址
System.out.println(new Customer());// 已经重写toString()方法 --> I am javaman!
}
}
class Customer{
@Override
public String toString() {
return "I am javaman!";
}
}
StringBuffer
package com.bjpowernode.javase.test001;
/**
思考:我们在实际的开发中,如果需要进行字符串的频繁拼接,会有什么问题?
因为java中的字符串时不可变的,每一次拼接都会产生新字符串。
这样会占用大量的方法区内存。造成内存空间的浪费。
String s = "abc";
s += "hello";
就以上两行代码,就导致在方法区字符串常量池当中创建了3个对象;
"abc"
"hello"
"abchello"
*/
public class StringBufferTest01 {
public static void main(String[] args) {
String s = "";
// 这样做会给java的方法区字符串常量池带来很大的压力
for(int i = 0; i < 100; i ++) {
s += i;
System.out.println(s);
}
}
}
package com.bjpowernode.javase.test001;
import java.lang.StringBuffer;
/*
如果以后需要进行大量字符串的拼接操作,建议使用JDK中自带的:
java.lang.StringBuffer
java.lang.StringBuilder
如何优化StringBuffer的性能?
在创建StringBuffer的时候尽可能给定一个初始化容量。
最好减少底层数组的扩容次数。预估计一下,给一个大一些初始化容量。
关键点:给一个合适的初始化容量。可以提高程序的执行效率。
*/
public class StringBufferTest02 {
public static void main(String[] args) {
// 创建一个初始化容量为16byte[]数组。(字符串缓冲区对象)
StringBuffer stringbuffer = new StringBuffer();
// 拼接字符串,以后拼接字符串统一调用append()方法
stringbuffer.append("a");
stringbuffer.append("b");
stringbuffer.append("d");
stringbuffer.append(3.14);
stringbuffer.append(true);
// append方法底层在进行追加的时候,如果byte数组满了,会自动扩容。
stringbuffer.append(100L);
System.out.println(stringbuffer.toString());
// 制定初始化容量的StringBuffer对象(字符串缓冲区对象)
StringBuffer sb = new StringBuffer(100);
sb.append("hello");
sb.append("world");
sb.append("hello");
sb.append("kitty");
System.out.println(sb);
}
}
StringBuilder
package com.bjpowernode.javase.test001;
/**
java.lang.StringBuilder
StringBuffer和StringBuilder的区别?
StringBuffer中的方法都有:synchronized关键字修饰的。表示StringBuffer在多线程环境下运行是安全的。
StringBuilder中的方法都没有:synchronized关键字修饰的。表示StringBuilder在多线程环境下运行是不安全的。
StringBuffer是线程安全的。
StringBuilder是非线程安全的。
*/
public class StringBuilderTest01 {
public static void main(String[] args) {
// 使用StringBuilder也是可以完成字符串的拼接。
StringBuilder sb = new StringBuilder();
sb.append(100);
sb.append(true);
sb.append("hello");
sb.append("kitty");
System.out.println(sb);
}
}
面试官问
package com.bjpowernode.javase.stringbuffer;
/**
*
1、面试题:String为什么是不可变的?(JDK8中String类中是char[]数组)
我看过源代码,String类中有一个byte[]数组,这个byte[]数组采用了final修饰,
因为数组一旦创建长度不可变,并且被fianl修饰的引用一旦指向某个对象之后,不可再
指向其他对象,所以String是不可变的!
2、StringBilde/StringBuffer为什么是可变的呢?(JDK的StringBuffer/StringBuilder中是char[]数组)
我看过源代码,StringBuffer/StringBuilder内部实际上是一个byte[]数组,
这个byte[]数组没有被final修饰,StringBuffer/StringBuilder的初始化
容量我记得应该是16,当存满之后会进行扩容的,底层调用了数组拷贝的方法
System.arraycopy()...是这样扩容的。所以StringBuilder/StringBuffer
适合于使用字符串的频繁拼接操作。
*/
public class StringBufferTest04 {
public static void main(String[] args) {
// 字符串不可变是什么意思?
// 是说双引号里面的字符串对象一旦创建不可变。
String s = "abc";
// s变量是可以指向其他对象的。
// 字符串不可变不是指以上变量s不可变,是说“abc”不可变
s = "zyx";
}
}