String类

String类

目录

• String类
  • String结构
  • String创建
  • String特性

String结构

1、String对象用于保存字符串，也就是字符序列。

2、字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节。

3、String类常用构造器：

String s1= new String();
String s2= new String(String original);
String s3= new String(char[] a);
String s4= new String(char[] a,int starIndex,int count);
String s5= new String(byte[] b);

4、String类实现了接口Serializable（String 可以串行化：可以子啊网络传输）

​ 接口Comparable（String 对象可以比较大小）

5、String是 final 类，不能被其他类继承

6、String 有属性 private final char value[];用于存放字符串内容

​ value 是一个final类型，不可以修改。

String创建

1、直接赋值

​ String s= "tmm";

先从常量池查看是否有”tmm“数据空间，如果有就直接指向，没有则重新创建，然后指向，最终指向的是常量池的空间地址

2、调用构造器

String s =new String（"tmm"）;

先在堆中创建空间，里面维护了value属性，指向常量池的tmm空间，如果常量池没有就重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址

• 测试题：

String a="abc";
String b="abc";
System.out.println(a.equals(b));//T
System.out.println(a==b);//T

String a="abc";//a指向常量池的 "abc"
String b=new String("abc");//b指向堆中的对象value
System.out.println(a.equals(b));//T
System.out.println(a==b.intern());//T
System.out.println(b==b.intern());//F
//b.intern()方法最终返回的是常量池的地址（对象）
//调用intern方法，如果池中已经包含一个等于String对象的字符串，则返回池中字符串。否则，将String对象添加到池中，并返回此String对象的引用

String s1="tmm";//常量池
String s2="java";//常量池
String s3=new String("java");//堆——》常量池中的java
String s4="java";//常量池
System.out.prinln(s2==s3);//F
System.out.prinln(s2==s4);//T
System.out.prinln(s2.equals(s3);//T
System.out.prinln(s1==s2);//F

Person p1= new Person();
p1.name="tmm";
Person p2=new Person();
p2.name="tmm";

System.out.prinln(p1.name.equals(p2.name));//T
System.out.prinln(p1.name==p2.name);//T
System.out.prinln(p1.name=="tmm");//T

String s1=new String("abc");
String s2=new String("abc");
System.out.prinln(s1==s2);//F

String特性

1、String是一个final类，代表不可变的字符序列

2、字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的

• 测试题：

//下面语句创建了几个对象？
String s1="hello";
s1="haha";
//创建了2个对象

String a="hello"+"abc";//创建了1个对象
//编译器会优化等价--》String a="helloabc"; 

String a="hello";
String b="abc";
String c=a+b;//创建了3个对象 
//先创建一个StringBuilder sb=StringBuilder() 
//执行 sb.append("hello");
//执行 sb.append("abc");
//String c=sb.toString(); toString底层是new sb是指向堆中的String
//最后c指向堆中对象（String） value[]-->池中"helloabc"

String d="helloabc";
System.out.prinln(c==d);//F

• String c1="a"+"b"常量相加，看的是池
• String c1=a+b 变量相加，是在堆中

//下面代码输出什么？
String s1="tmm";//指向池中tmm
String s2="java";//指向池中java
String s5="tmmjava";//指向池中tmmjava
String s6=(s1+s2).intern();//tmmjava 池中已有
System.out.prinln(s5==s6);//T
System.out.prinln(s5.equals(s6));//T

public class Demo1 {
   String s=new String("tmm");//堆中 value-->池中"tmm"
   final char[] c={'j','a','v','a'};//数组 堆中
   public void change(String s,char c[]){
       s="java";
       c[0]='h';
   }
    public static void main(String[] args) {
        Demo1 d=new Demo1();
        d.change(d.s,d.c);//调用方法，进栈 栈中的s--》java c[0]=h
        System.out.println(d.s+"and");//堆中value还是--》tmm,c是数组 tmmand
        System.out.println(d.c);//hava
    }
}