从String类型发散想到的一些东西

2020-08-29 13:31:37 阅读：233 来源： 互联网

标签：String 对象 equals Assert 字符串发散引用类型 string

值类型引用类型

值类型表示存储在栈上的类型，包括简单类型（int、long、double、short）、枚举、struct定义；
引用类型表示存在堆上的类型，包括数组、接口、委托、class定义；
string 是引用类型

字符特殊性

不可变性。字符串创建后，重新赋值的话，不会更新原有值，而是将引用地址更新到一个新的内存地址上。

留存性。.NET运行时有个字符串常量池的概念，在编译时，会将程序集中所有字符串定义集中到一个内存池中，新定义的字符串会优先去常量池中查看是否已存在，如果存在，则直接引用已存在的字符串，否则会去堆上重新申请内存创建一个字符串。
下面是关于字符串的一些单元测试，仔细观察下各个不同：

  [Fact]
  public void Base_Test()
  {
      string a = "abc";
      string b = "abc";
      //字符串的留存性，初始化后会放入常量池，b直接引用a的对象
      Assert.True(string.ReferenceEquals(a, b));

      string c = new String("abc");
      string d = new String("abc");
      //直接new的话，会重新分配内存
      Assert.False(string.ReferenceEquals(c, d));
      Assert.False(string.ReferenceEquals(a, c));

      string e = "abc";
      //这里e还是使用字符串的留存性，且使用的还是a的地址。证明c分配的内存引用并没有放入常量池替换
      Assert.True(string.ReferenceEquals(a, e));
      Assert.False(string.ReferenceEquals(c, e));

      string f = "abc" + "abc";
      string g = a + b;
      string h = "abcabc";
      //f在编译期间确定，实际还是从常量池中获取
      //IsInterned 表示从常量池中获取对应的字符串，获取失败返回null
      //a+b实际上是发生了字符串组合运算，内部重新new了一个新的字符串，所以f,g引用地址不同
      Assert.False(string.ReferenceEquals(f, g));
      Assert.True(string.ReferenceEquals(string.IsInterned(f), h));
      Assert.True(string.ReferenceEquals(f, h));
  }

Stringbuilder

字符串拼接是一个非常耗资源的操作，例如 string a="b"+"c" ，实际上创建了3个字符串"b"、"c"、"bc"。所以在这个时候就需要StringBuilder来专门执行字符串拼接操作了。
那么StringBuilder是如何实现的呢？
实际上StringBuilder内部维护了一个char数组，所有的appned类的操作都是将字符串转化为char存入数组。最后ToString()的时候才去组装string,减少了大量中间string的创建，是非常高效的字符串组装工具。
StringBuilder内部还有一个 Capacity 属性，用于定义数组的初始容量，默认值为25。超过容量会触发扩容操作。所以在实际操作中，如果我们能预估到拼接字符串的长度，在定义StringBuilder给 Capacity 属性附上一个合理的值，将会有更加高效的性能。

equals ==

equals：比较字符串的值
==：比较字符串的引用地址是否相同

首先有个前提，我们所看到的equals,==，来自于System.Object对象，几乎所有的原生对象都对其进行了重写，才构成了我们目前的认知。重写equals必须重写GetHashCode。官方给出重写的实现约定如下：

Equals每个实现都必须遵循以下约定:

自反性(Reflexive): x.equals(x)必须返回true.
对称性(Symmetric): x.equals(y)为true时,y.equals(x)也为true.
传递性(Transitive): 对于任何非null的应用值x,y和z,如果x.equals(y)返回true,并且y.equals(z)也返回true,那么x.equals(z)必须返回true.
一致性(Consistence): 如果多次将对象与另一个对象比较,结果始终相同.只要未修改x和y的应用对象,x.equals(y)连续调用x.equals(y)返回相同的值l.
非null(Non-null): 如果x不是null,y为null,则x.equals(y)必须为false

GetHashCode:

两个相等对象根据equals方法比较时相等，那么这两个对象中任意一个对象的hashcode方法都必须产生同样的整数。
在我们未对对象进行修改时,多次调用hashcode使用返回同一个整数.在同一个应用程序中多次执行,每次执行返回的整数可以不一致.
如果两个对象根据equals方法比较不相等时,那么调用这两个对象中任意一个对象的hashcode方法,不一同的整数。但不同的对象,产生不同整数,有可能提高散列表的性能.

请慎重重写Equals和GetHashCode！！重写Equals方法必须要重写GetHashCode!!

关于equals方法参数 StringComparison

public enum StringComparison
{
    //
    // 摘要:
    //     使用区分区域性的排序规则和当前区域性比较字符串。
    CurrentCulture = 0,
    //
    // 摘要:
    //     通过使用区分区域性的排序规则、当前区域性，并忽略所比较的字符串的大小写，来比较字符串。
    CurrentCultureIgnoreCase = 1,
    //
    // 摘要:
    //     使用区分区域性的排序规则和固定区域性比较字符串。
    InvariantCulture = 2,
    //
    // 摘要:
    //     通过使用区分区域性的排序规则、固定区域性，并忽略所比较的字符串的大小写，来比较字符串。
    InvariantCultureIgnoreCase = 3,
    //
    // 摘要:
    //     使用序号（二进制）排序规则比较字符串。
    Ordinal = 4,
    //
    // 摘要:
    //     通过使用序号（二进制）区分区域性的排序规则并忽略所比较的字符串的大小写，来比较字符串。
    OrdinalIgnoreCase = 5
}

通常情况下最好使用 Ordinal或者OrdinalIgnoreCase，性能上最为高效。
除非有特殊的需要，不要使用 InvariantCulture或者InvariantCultureIgnoreCase，因为它要考虑所有Culture的字符转化对比情况，性能是极差的。
CurrentCulture和CurrentCultureIgnoreCase由于只有本地Culture对比，所以性能还可以接受。

参数传递

首先关于参数的存储，参数是存在栈上的。传递参数时，会将对象的“值”在栈copy一份，然后将副本的值传给方法。对象参数的传递分为两种 “值传递”和“引用传递”。（注意这里的引号）

值传递。默认的参数传递都是这种方式。会将对象的值在栈copy一份，然后将复制集的值传给方法。这里的值对于值类型来说，即为对象副本的值。对于引用类型来说，即为对象在堆上的地址。
引用传递。可以通过 ref out 关键字实现。对于值类型，会直接传入原对象在栈上的引用。对于引用类型，会传入原有对象的堆地址的引用。

这里string虽然是引用类型，但是产生的效果缺和值类型参数传递一样的。大家参考上面关于string的特性思考下原因。

静心慢慢回味下列单元测试

    [Fact]
    public void Base_Test()
    {
        //引用类型参数
        TestClass s = new TestClass();
        s.Tag = "abc";

        TestMethod m = new TestMethod();
        m.ReNew(s);
        //参数s 实际是对象 s的 地址拷贝。两者在栈上不同，但是指向的堆地址相同
        //在ReNew方法中 "参数s" 重新指向了一个新的对象，但是不影响旧的对象s
        Assert.True(string.Equals("abc", s.Tag));

        m.Change(s, "123");
        //Change方法是直接修改 参数s 指向的堆对象内的字段数据，所有对象s字段也发生了变化
        Assert.True(string.Equals("123", s.Tag));

        m.ReNew2(ref s);
        //注意和ReNew的区别，因为是ref 引用传递，所有原对象引用地址指向了新new的对象地址
        Assert.False(string.Equals("abc", s.Tag));
        Assert.True(string.Equals("cba", s.Tag));

        //值类型参数
        int val = 100;
        //Change方法内部改变了val的值，但不影响val原来的值
        m.Change(val);
        Assert.True(val == 100);

        m.Change(out val);
        //使用out标记，改变了val原来的值
        Assert.True(val == 123);
    }
}

public class TestMethod
{
    public void ReNew(TestClass c)
    {
        c = new TestClass() { Tag = "cba" };
    }

    public void ReNew2(ref TestClass c)
    {
        c = new TestClass() { Tag = "cba" };
    }

    public void Change(TestClass c, string tag)
    {
        c.Tag = tag;
    }

    public void Change(int a)
    {
        a = 123;
    }
    public void Change(out int a)
    {
        a = 123;
    }
}

public class TestClass
{
    public string Tag { get; set; }
}

ref out

ref out都是用来标识通过引用传递方式传参。不同的是，ref 需要参数在方法调用前初始化，out 则要求参数在方法体内赋值。

装箱拆箱

装箱，即值类型转化为引用类型；从内存存储角度，将值类型从栈的值copy,然后放到堆上，并附加额外的引用类型功能内存占用（如类型指针、同步块索引等）。
拆箱，即引用类型转化为值类型。从内存存储角度，获取引用类型的指针，得到值copy,放到栈上。
从性能角度上，装箱的性能损耗>拆箱的性能损耗。在实际运用中，我们要尽量避免装箱和拆箱，这也是泛型类型出现后，一个非常大的作用就是避免了装箱拆箱的大量操作。

标签：String,对象,equals,Assert,字符串,发散,引用,类型,string
来源： https://www.cnblogs.com/gt1987/p/13581958.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9