String

是一种不可变字符序列

String不可更改（不可变）的理解

Java文档中说 “String 对象是 immutable(不可变的)，是因为不可修改String中的单个字符

不可更改的原因:
查看string的源码 可发现如下

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    }

final数组不可被重写，因此称“不可更改”。

再看下面的例子

String s = "Google";
System.out.println("s = " + s);

s = "Runoob";
System.out.println("s = " + s);
/**
* output:
* s = Google
* s = Runoob
*/

从结果上看是改变了，但为什么说String对象是不可变的呢？
原因在于实例中的 s 只是一个 String 对象的引用，并不是对象本身，当执行 s = "Runoob"; 创建了一个新的对象 "Runoob"，而原来的 "Google" 还存在于内存中。
String这种机制恰恰让它 和 复制值的数据类型相似，而非结结实实引用；
<摘自菜鸟教程网友笔记>
https://www.runoob.com/java/java-string.html

---

初始化

格式化声明：

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

---

String常量池

作用：避免频繁的创建和销毁对象而影响系统性能

比较字符串要用equals(another String)

“==”指的是引用相同，（任何地方都要慎用==）

但是我只想看两个字符串长得一不一样，不关心它们是不是指向的同一个，那就用equals()

String s1 = "abc";
String s2 = "a"+"bc";//s2 = "abc"

String s7 = "c";
String s4 = s1+s7;
System.out.println(s4==s2);//false,编译器没法对s1+s7做优化

String s3 = new String("abc");

System.out.println(s1==s2);//true
System.out.println(s3==s2);//false


//因此通常比较字符串的值是否相等 使用equals
//==号是判断是否同一个对象

---

一些方法

.substring的下标和copyRangeOf一样 前闭后开

//substring
String s1= "How are you?";
s=s1.substring(4,7);
//s="are"


String s2=" How old are you";
s=s2.trim();//去除字符串首尾的空格。注意:中间的空格不能去除
System.out.println(s);//s 字符串前面的空格没了
System.out.println(s2);//因为 String是不可变字符串,所以s2不变

.concat //=="+"
// 连接字符串

/**String的方法**/
    
.charAt(int index)//不建议使用，因为char类型容易引起未知问题，见下文char类型总结

.compareTo(object o/String)

.compareToIgnoreCase(String str)//忽略大小写

boolean endsWith(String suffix)
subString
trim//返回忽略前后空白的副本
    
hashCode
replace(char oldChar,char newChar)//用newChar替换所有oldChar
endsWith
startsWith

string与整型运算

String a = "3";
int b =4;
int c = 5;

System.out.print(a+b);//output:34
System.out.print(b+c+a);//output：93
//b+c  + "3" = "93"

// 换成char

char d ='a';
System.out.print(d+1);//output:98

---

---

可变字符序列

StringBuilder()中,append方法return this,
因此StringBuilder的append可以链式调用:

StringBuilder sb = new StringBuilder();
for(int i = 0;i<26;i++)[
    char temp = (char)('a'+i);
    sb.append(temp);
]

sb.insert(0,"我").insert(1,"可");
//sb = "我可abcdefghijgklmnopqrstuvwxyz"

由此也可以注意到，如果对字符串频繁修改(如循环若干次)，绝不能用String，会导致内存占用巨大，

StringBuilder比StringBuffer

快，但线程不安全

.append//添加

.reverse//反转

.delete(int start,int end)

.insert(int offset,int i)

replace(int start, int end, String str)

indexOf()、lastIndexOf

char

不推荐使用char类型的原因：
Unicode编码和java强制使用的UTF-16不匹配，导致有些一个字符需要两个代码单元才能表示；易诱发未知错误。
Unicode编码中 使用时需要在数字前加上“\u”；

char数组的显示

System.out.println(arr)即可，如果加上arr.toString()，输出的反而会是数组地址

char与String的区别

字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)

处理String的常用方法

String Int的转换

//String转化为Int
String s1 = "999";
int i1 = Integer.parseInt(s1);

//int 转String
int i2 = 999;
String s2 = i2.toString();
String s3 = String.valueOf(i2);

---

String Char[]的转换

1. 利用构造时

char data[] = {'s', 'g', 'k'}; 
String str = new String(data);

2. String的函数
   String.valueOf();

char[] cha = {'s','g','h'};
String n = String.valueOf(cha);

---

String的replace函数

替换后会生成一个新的String，旧的并未改变

---

字符串处理

正则表达式(字符串分割)

正则表达式\s表示匹配任何空白字符，+表示匹配一次或多次

String [] arr = str.split("\\s+");
// 分割空格就要用  "\\s+"