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";
}
}
700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
