8：String类

最新推荐文章于 2024-07-29 18:00:00 发布

weixin_30662011

最新推荐文章于 2024-07-29 18:00:00 发布

阅读量67

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/sixrain/p/4911860.html

版权

String类

String类的特点：字符串对象一旦被初始化就不会被改变。

字符串是最常用的类型之一，所以为了使用方便java就给封装成了对象方便使用

public static void stringDemo2() {
String s = "abc";//创建一个字符串对象在常量池中。
String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存和常量池中。
System.out.println(s==s1);//false

System.out.println(s.equals(s1));

string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。

其实就是比较字符串内容。

演示字符串定义的第一种方式，并明确字符串常量池的特点.

池中没有就建立，池中有，直接用。

private static void stringDemo1() {
String s = "abc";//"abc"存储在字符串常量池中。
// s = "nba";
String s1 = "abc";
System.out.println(s==s1);//true
// System.out.println("s="+s);
/输出nab，s和s1是俩个字符串对象，s一开始指向了abc，又指向了nba，abc不变说的是这个意思
}

常量池：

因为String类型一旦被初始化是不能被改变的，所以存放在常量池，存放在常量池中还有个很重要的原因：String s1 = “abs”；String s2=“abs”，这时s2并没有新建立一个对象，而是指向了s1这个对象。也就是说每当创建一个字符串时，并不是直接创建而是先到常量池中区找需要创建的对象是否存在，如果存在就不会再创建了。常量池中的元素是不会重复的，这也就是所谓的享元模式，例如当已经存在abs，这时需要创建ahk，这时常量池中只会增加两个字符h和k，然后在从常量池中抽出ahk对象。

特点：

1、String是一种特殊的数据类型，可创建对象。

2、通过String创建的对象分别可存在于常量池和堆内存中

3、String是一个final的类型，即不可被继承修改，一经初始化就终生不可改变。（要改变也是改变的引用）

4、常量池中的数据可共享，即两个引用变量可指向同一个字符串池中的字符串

5、Java中的任何对象都可写成字符串的形式。

6、既然String是对象，那就不得不说说null和“”的区别了。null是String对象指向为空，就是没有指向。而“”代表的是String对象指向的是一个空的字符串。

匿名对象

匿名对象就是表示没有名字的对象，那么什么叫对象的名字了？

一个字符串就是一个string的匿名对象

String类的构造器

将字节数组或者字符数组转成字符串可以通过String类的构造函数完成。

private static void stringConstructorDemo2() {
char[] arr = {'w','a','p','q','x'};//字符串转换成数组
String s = new String(arr,1,3);//字符的一部分转换成数组，从1角标取
System.out.println("s="+s); 输出s=apq
}

public static void stringConstructorDemo() {
String s = new String();
//等效于String s = ""内容一样，地址不一样，都是指向空字符串; 但不等效String s = null;
一般用String s = ""，就行了，能被共享,当需要用构造器传数据，需要用new，
byte[] arr = {97,66,67,68};
String s1 = new String(arr); //将数组变为字符，输出了abcd,编码转成了字节存储起来
System.out.println("s1="+s1);
}

String类的方法（常见功能）

按照面向对象的思想对字符串进行功能分类

字符串常见的操作方法：（String str = "hello java"）

1、获取。
1.1 字符串中的包含的字符数，也就是字符串的长度。
int length():获取长度。str.length()//结果为10
1.2 根据位置获取位置上某个字符。
char charAt(int index)://charAt(1)，结果是e
1.3 根据字符获取该字符在字符串中位置。//indexOf(’l‘)结果是2
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在字符串中出现的位置。
int lastIndexOf(int ch) ：从后往前找，但是字符串中的角标是没有变的。

System.out.println("substring:"+s.substring(2,4));//cd

2、判断。
2.1 字符串中是否包含某一个子串。
boolean contains(str):
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。if(str.indexOf("aa")!=-1)
而且该方法即可以判断，有可以获取出现的位置。
2.2 字符中是否有内容。
boolean isEmpty(): 原理就是判断长度是否为0.
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();

3、转换。

3.1 将字符数组转成字符串。
构造函数：String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串。
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[]):
3.2 将字符串转成字符数组。**
char[] toCharArray():
3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
3.4 将字符串转成字节数组。
byte[] getBytes():
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)
//3+"";//String.valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
4，替换
String replace(oldchar,newchar);
5，切割
String[] split(regex);
6，子串。获取字符串中的一部分。
String substring(begin);
String substring(begin,end);
7，转换，去除空格，比较。
7.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);//大于返回正数，等于返回0，小于返回负数，且值为ASSII值之差。

private static void stringMethodDemo_4() {
System.out.println("abc".compareTo("aqz"));
}
stringMethodDemo_4();
}

public class StringObjectDemo {
public static void main(String[] args) {
// String s1 = "abc";
// String s2 = "abc";
// intern():对字符串池进行操作的
String s1 = new String("abc");
String s2 = s1.intern();
System.out.println(s1 == s2); // false
}
}

public class StringDemo {
public static void main(String[] args) {
String str = "asdfghjaszxsa.java";
method_get(str);
print("------------------------------------------");
method_is(str);
print("------------------------------------------");
method_transform(str);
print("------------------------------------------");
method_replace(str);
print("------------------------------------------");
method_split(str);
print("------------------------------------------");
method_sub(str);
print("------------------------------------------");
method_change();
}
/*
* String获取方法凡是获取的字符或者是字符串不存在，就返回-1
*/
private static void method_get(String str) {
// 获取字符串的长度
int length = str.length();
print("length: " + length);
// 根据位置获取位置上的某个字符
char ch = str.charAt(1);
print("ch: " + ch);
// 根据字符获取该字符在字符串中的位置
int index = str.indexOf("index: " + 'a');// 获取该字符第一次出现的位置
print("index: " + index);
// int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexf = str.indexOf('a', 2);
print("indexf: " + indexf);
// int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexs = str.indexOf("as");
print("indexs: " + indexs);
// int indexOf(String str, int fromIndex)
// :从fromIndex指定位置开始，获取str在字符串中出现的位置。
int indexsf = str.indexOf("as", 3);
print("indexsf: " + indexsf);
// int lastIndexOf(int ch)
int indexlast = str.lastIndexOf('a');
print("indexlast: " + indexlast);
}
/*
* String中的判断
*/
private static void method_is(String str) {
// 字符串中是否包含某一个子串
/*
* 特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。
* 所以，也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法即可以判断，有可以获取出现的位置。
*/
boolean iscon = str.contains("asd");
print("iscon: " + iscon);
// 字符中是否有内容。boolean isEmpty(): 原理就是判断长度是否为0.
boolean isemp = str.isEmpty();
print("isemp: " + isemp);
// 字符串是否是以指定内容开头。boolean startsWith(str);
boolean start = str.startsWith("asd");
boolean startoffset = str.startsWith("sd", 1);
print("start: " + start);
print("startoffset: " + startoffset);
// 字符串是否是以指定内容结尾。boolean endsWith(str);
boolean end = str.endsWith(".java");
print("end: " + end);
// 判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str);
boolean equal = str.equals("asdfghjaszxsa.java");
print("equal: " + equal);
// 判断内容是否相同，并忽略大小写。boolean equalsIgnoreCase();
boolean equ = "AASD".equalsIgnoreCase("Aasd");
print("equ: " + equ);
}
/*
* 转换
*/
private static void method_transform(String str) {
char[] chs = { 'a', 's', 'd', 'f', 'g' };
byte[] bts = { 'a', 's', 'd', 'f', 'g' };
// 将字符数组转成字符串
String trChStr = new String(chs);
String trChStrO = new String(chs, 1, 3);
print("trChStr: " + trChStr + "....trChStrO: " + trChStrO);
String copyvalueof = String.copyValueOf(chs);
print("copyvalueof: " + copyvalueof);
// 将字符串转成字符数组****
char[] tochar = str.toCharArray();
for (int x = 0; x < tochar.length; x++) {
print("char[" + x + "] = " + tochar[x]);
}
// 将字节数组转成字符串。
String trBtStr = new String(bts);
String trBtStrO = new String(bts, 1, 3);
print("trBtStr: " + trBtStr + "....trBtStrO: " + trBtStrO);
// 将字符串转成字节数组。byte[] getBytes():
// 特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
byte[] getBts = str.getBytes();
for (int x = 0; x < getBts.length; x++) {
print("byte[" + x + "] = " + getBts[x]);
}
// 将基本数据类型转成字符串。static String valueOf(数据类型)
// 3+"";//String.valueOf(3);
String num = String.valueOf(2);
print("num: " + num);
}
/*
* 替换
*/
private static void method_replace(String str) {
// 如果要替换的字符不存在，返回的还是原串。
String newStr = str.replace('a', 'm');// 替换掉所有的该字符
print(str);
print(newStr);
String newSt = str.replace("asd", "qqq");
print(str);
print(newSt);
}
/*
* 切割
*/
private static void method_split(String str) {
// String[] split(regex);
String[] strs = str.split("s");
for (int x = 0; x < strs.length; x++) {
print("String[" + x + "] = " + strs[x]);
}
}
/*
* 获取字符串中的一部分
*/
private static void method_sub(String str) {
print(str.substring(2));// 从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
print(str.substring(2, 4));// 包含头，不包含尾。s.substring(0,s.length());
}
/*
* 转换，去除空格，比较。
*/
private static void method_change() {
String s = " Hello Java ";
print(s.toLowerCase());// 转小写
print(s.toUpperCase());// 转大写
print(s.trim());// 去空格
// 对两个字符串进行自然顺序的比较
String s1 = "aaa";
String s2 = "aaa";
print(s1.compareTo(s2));// 大于返回正数，小于返回负数，相等返回0
}
private static void print(Object obj) {
System.out.println(obj);
}

System.out.println("abc".concat("kk"));连接字符串，没什么用，直接连就行

System.out.println("abc"+"kk");

System.out.println(String.valueOf(4)+1)；//41将基本数据类型变为字符串，再连接

System.out.println(""+4+1);和上一样

练习

* 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。

* {"nba","abc","cba","zz","qq","haha"}

* 思路：

* 1,对数组排序。可以用选择，冒泡都行。

* 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。

* 字符串对象怎么比较呢？对象中提供了用于字符串对象比较的功能。

public class StringTest_1 {
public static void main(String[] args) {
String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };
printArray(arr); // 原来的
sortString(arr);
printArray(arr); // 比较后的
}
public static void sortString(String[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i].compareTo(arr[j]) > 0)// 字符串比较用compareTo方法
swap(arr, i, j);
}
}
}
private static void swap(String[] arr, int i, int j) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArray(String[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
System.out.print(arr[i] + ", ");
else
System.out.println(arr[i] + "]");
}
}
}

2，一个子串在整串中出现的次数。

* "nbaernbatynbauinbaopnba"

* 思路：

* 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。

* 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，

* 而剩余字符串的起始位是出现位置+子串的长度.

* 3,以此类推，通过循环完成查找，如果找不到就是-1，并对每次找到用计数器记录。

public class StringTest_2 {
public static void main(String[] args) {
String str = "nbaernbatnbaynbauinbaopnba";
String key = "nba";
int count = getKeyStringCount_2(str, key);
System.out.println("count=" + count);
}
public static int getKeyStringCount_2(String str, String key) {
int count = 0;
int index = 0;
while ((index = str.indexOf(key, index)) != -1) {
index = index + key.length();
count++;
}
return count;
}
/**
* 获取子串在整串中出现的次数。
*/
public static int getKeyStringCount(String str, String key) {
// 1,定义计数器。
int count = 0;
// 2，定义变量记录key出现的位置。
int index = 0;
while ((index = str.indexOf(key)) != -1) {
str = str.substring(index + key.length());//这个前面的str别不写
count++;
}
return count;
}
}

* 3，两个字符串中最大相同的子串。

* "qwerabcdtyuiop"

* "xcabcdvbn"

* 思路：

* 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。

* 如果存在，短的那个字符串就是最大子串。

* 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。

* 如果存在就已找到，就不用在找了。

public class StringTest_3 {
public static void main(String[] args) {
String s1 = "qwerabcdtyuiop";
String s2 = "xcabcdvbn";
String s = getMaxSubstring(s2, s1);
System.out.println("s=" + s);
}
/**
* 获取最大子串
*
* @param s1
* @param s2
* @return
*/
public static String getMaxSubstring(String s1, String s2) {
String max = null, min = null;
max = (s1.length() > s2.length()) ? s1 : s2;
min = max.equals(s1) ? s2 : s1;
System.out.println("max=" + max);
System.out.println("min=" + min);
for (int i = 0; i < min.length(); i++) {
for (int a = 0, b = min.length() - i; b != min.length() + 1; a++, b++) {
String sub = min.substring(a, b);
// System.out.println(sub);
if (max.contains(sub))
return sub;
}
}
return null;
}
}

* 4，模拟一个trim功能一致的方法。去除字符串两端的空白

* 思路：

* 1，定义两个变量。

* 一个变量作为从头开始判断字符串空格的角标。不断++。

* 一个变量作为从尾开始判断字符串空格的角标。不断--。

* 2,判断到不是空格为止，取头尾之间的字符串即可。

public class StringTest_4 {
public static void main(String[] args) {
String s = " ab c ";
s = myTrim(s);
System.out.println("-" + s + "-");
}
public static String myTrim(String s) {
int start = 0, end = s.length() - 1;
while (start <= end && s.charAt(start) == ' ') {
start++;
}
while (start <= end && s.charAt(end) == ' ') {
end--;
}
return s.substring(start, end + 1);
}
}

练习五：将字符串反转。

/*
思路：
1，将字符串变成数组。
2，对数组反转。
3，将数组变成字符串。
*/
public class ReverseString {
public static void main(String[] args) {
String str = "shag klh";
String out = reverseString(str);
System.out.println(out);
}
/*
* 将字符串反转
*/
private static String reverseString(String str) {
// 将字符串变成数组
char[] chs = str.toCharArray();
// 将数组反正，也就是收尾调换
reverseArray(chs);
return new String(chs);
}
private static void reverseArray(char[] chs) {
char temp;
for (int start = 0, end = chs.length - 1; start < end; start++, end--) {
temp = chs[start];
chs[start] = chs[end];
chs[end] = temp;
}
}

StringBuffer

* StringBuffer:就是字符串缓冲区。

* 用于存储数据的容器。

* 特点：

* 1，长度的可变的。

* 2，可以存储不同类型数据。

* 3，最终要通过toString方法变成字符串进行使用。

* 4，可以对字符串进行修改。

Stringbuffer类：可以被修改的字符序列

* 既然是一个容器对象。应该具备什么功能呢？

1、存储。
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。不支持byte和char，需要对其进行转换才能操作。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
2、删除。
StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAt(index):删除指定位置的字符。
3、获取。
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end)
4、修改。
StringBuffer replace(start,end,string);
void setCharAt(int index, char ch) ;
5、反转。
StringBuffer reverse();
6、将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)//第一个参数是说StringBuffer 从哪开始取值，第二个就是在哪结束啦，第三个参数是插入到哪个数据，第四个是说从数组中的哪个索引开始插入。

* 增删改查 C(create)U(update)R(read)D(delete)

public class StringBufferDemo {
public static void main(String[] args) {
bufferMethodDemo_2();
}
private static void bufferMethodDemo_2() {
StringBuffer sb = new StringBuffer("abce");
// sb.delete(1, 3);//ae
// 清空缓冲区
// sb.delete(0,sb.length());
// sb = new StringBuffer();
// sb.replace(1, 3, "nba");
// sb.setCharAt(2, 'q');
// sb.setLength(10);
// System.out.println("sb:"+sb);
// System.out.println("len:"+sb.length());
System.out.println(sb.reverse());
}
private static void bufferMethodDemo_1() {
StringBuffer sb = new StringBuffer("abce");
// sb.append("xixi");
sb.insert(2, "qq");
System.out.println(sb.toString());
}
public static void bufferMethodDemo() {
// 创建缓冲区对象。
StringBuffer sb = new StringBuffer();
sb.append(4).append(false);// .append("haha");输出4falsehahh，连起来了
sb.insert(1, "haha")；//4hahhfalse
// sb.append(true);//4hahhfalsetru，一个一个append和.append效果一样
System.out.println(sb);
}
}

StringBuilder

* jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder

* 不同的是：

* StringBuffer是线程同步的。通常用于多线程。

* StringBuilder是线程不同步的。通常用于单线程。它的出现提高效率。

* jdk升级：

* 1，简化书写。

* 2，提高效率。

* 3，增加安全性。

eg：

public class StringBuilderTest {
public static void main(String[] args) {
int[] arr = { 3, 1, 5, 3, 8 };
String s = arrayToString_2(arr);
System.out.println(s);
}
public static String arrayToString_2(int[] arr) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
sb.append(arr[i] + ", ");
else
sb.append(arr[i] + "]");
}
return sb.toString();
}
/**
*
* 将一个int数组变成字符串。
*/
public static String arrayToString(int[] arr) {
String str = "[";
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
str += arr[i] + ", ";
else
str += arr[i] + "]";
}
return str;
}
}

public class StringBuilderTest {
public static void main(String[] args) {
StringBuilder s1 = new StringBuilder("hello");
StringBuilder s2 = new StringBuilder("java");
show(s1, s2);
System.out.println(s1 + "......." + s2);
}
private static void show(StringBuilder s1, StringBuilder s2) {
s1.append(s2);
s1 = s2;
//输出hellojava.......java
}
}

基本数据类型对象包装类

* 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。

* 用于描述该对象的类就称为基本数据类型对象包装类。

* byte Byte

* short Short

* int Integer

* long Long

* float Float

* double Double

* char Character

* boolean Boolean

* 该包装对象主要用基本类型和字符串之间的转换。

基本类型--->字符串

基本类型数值+""
用String类中的静态方法valueOf(基本类型数值);
用Integer的静态方法valueO(基本类型数值);

字符串--->基本类型

使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");*****

* int parseInt("intstring");

* long parseLong("longstring");

* boolean parseBoolean("booleanstring");

* 只有Character没有parse方法

2.如果字符串被Integer进行对象的封装。

* 可使用另一个非静态的方法，intValue();

* 将一个Integer对象转成基本数据类型值。

System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.toBinaryString(-6));
int num = 4;
Integer i = new Integer(5);
int x = Integer.parseInt("123");
System.out.println(Integer.parseInt("123")+1);
Integer i = new Integer("123");
System.out.println(i.intValue());

1. 1. Integer a = new Integer("89");
  2. Integer b = new Integer(89);
  3. System.out.println(a==b);//flase
  4. System.out.println(a.equals(b));//ture
  5. // System.out.println(3>3);
  6. System.out.println(a.compareTo(b));//0,内容相同，地址不同

* 整数具备不同的进制体现。

* 十进制-->其他进制。

* toBinaryString

* toOctalString

* toHexString

* 其他进制-->十进制。

* parseInt("string",radix)

十进制-->其他进制。

System.out.println(Integer.toBinaryString(60));
System.out.println(Integer.toOctalString(60));
System.out.println(Integer.toHexString(60));
// System.out.println(Integer.toString(60,16));

其他进制-->十进制。

class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//整数类型的最大值。
//sop("int max :"+Integer.MAX_VALUE);
// 将一个字符串转成整数。
int num = Integer.parseInt("123");//必须传入数字格式的字符串。
//long x = Long.parseLong("123");
// sop("num="+(num+4));
// sop(Integer.toBinaryString(-6));
// sop(Integer.toHexString(60));
int x = Integer.parseInt("3c",16); //后面传入前面是什么进制的
sop("x="+x);

自动装箱拆箱

class IntegerDemo1
{
public static void main(String[] args)
{
// Integer x = new Integer(4);
Integer x = 4;//自动装箱。//new Integer(4)
x = x/* x.intValue() */ + 2;//x+2:x 进行自动拆箱。变成成了int类型。和2进行加法运算
//再将和进行装箱赋给x
Integer m = 128;
Integer n = 128;
sop("m==n:"+(m==n));//结果为false
Integer a = 127;
Integer b = 127;
sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象
//因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间
}
public static void method()
{
Integer x = new Integer("123");
Integer y = new Integer(123);
sop("x==y:"+(x==y));
sop("x.equals(y):"+x.equals(y));
}

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/sixrain/p/4911860.html

weixin_30662011

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
8：String类

String类String类的特点：字符串对象一旦被初始化就不会被改变。字符串是最常用的类型之一，所以为了使用方便java就给封装成了对象方便使用public static void stringDemo2() {String s = "abc";//创建一个字符串对象在常量池中。 String s1 = new String("abc");//创建两个对象一个new一个字符串...
复制链接

扫一扫