【原创】数据类型基础讲解-后续持续更新

da11

* 类型类型讲解拓扑图图示

        /*类型分类：
         * · 通用类型系统CTS（Common Type System）是.NET框架
         * 中的一个组成部分，为所有面向.NET框架的语言定义了数据
         * 类型的规则
         *

         * · 值类型：存储数据本身（存放比较小的数据类型）
         *      - 结构(struct)
         *          - 数值类型
         *          - bool
         *          - char
         *      - 枚举
         *      
         * · 引用类型：存储数据的引用（内存地址）（存放比较大的数据类型）
         *      - 接口
         *      - 类(class)
         *          - string
         *          - Array
         *          - 委托
         *

* 类型归属图示

         * 内存：
         * · 是CPU与其他外部存储器交换数据的桥梁。
         * · 用于存储正在执行的程序与数据，既数据必须加载到内存才能被CPU处理。
         * · 通常开发人员表达的“内存”都是值内存条。
         *
         * 内存的分配：
         * · 程序运行时，CLR将申请的内存空间从逻辑上进行划分
         * · 栈区：
         *      - 空间小（1MB），读取速度快。
         *      - 用于存储正在执行的方法，分配的空间叫做栈帧。栈帧中存储方法的参数以及变量
         *      等数据。方法执行完毕后，对应的栈帧将被清除，清除之后，如果堆中还存在数据，那堆中的这个数据就称为垃圾，此时需要使用垃圾回收器机制进行垃圾回收，见此贴下方回复讲解。
         * · 堆区：
         *      - 空间大，读取速度慢。
         *      - 用于存储引用类型的数据。
         * · 注意，两者的速度快慢是相对的，不是说堆区中的数据就读取的慢，而是相比较栈区的数据而言

* 开发中的内存讲解图示

* 堆栈地址分配图示

         * 局部变量
         * · 定义在方法内部的变量
         * · 特点：
         *      - 没有默认值，必须自行设定初始值，否则不能使用。
         *      - 方法被调用时，存在栈中，方法调用结束时从栈中清除。
         *          - 因为方法执行在栈中，所以在方法中声明的变量都在栈中！并不是说值类型都是在栈中，而是在方法内部定义的值类型才在栈中！！之后会持续更新此贴。     
         *
         * 值类型与引用类型
         * · 值类型：声明在栈中，数据存储在栈中。
         * · 引用类型：声明在栈中，数据存储在堆中，栈中存储该数据的引用。
         *
         * · 记住，改变的是栈或者堆，看赋值变量的左边位置，没有中括号[]的代表改变的是栈，有中括号的[]，代表改变的是堆！！
         */
        static void Main(string[] args)
        {
            //a变量在栈中，int数值 1在栈中
            int a = 1;
            //Arr变量在栈中存储数组对象的引用，元素 1在堆中
            int[] Arr = new[] { 1 };

            int[] SZ = new int[] { 1};
            int[] SZ1 = SZ;
            SZ[0] = 2;  //修改的是堆中的数据
            Console.WriteLine(SZ1[0]); //因为SZ1中存储的是指向堆中数据的内存地址，所以显示的实际是堆中的数据
            Console.ReadLine();

            //
            string s1 = "1";
            string s2 = s1;
            s1 = "2"; //修改的是栈中存储的引用
            //s1[0] = "2";  //修改堆中的文字，但是语法上不能这样修改
            Console.WriteLine(s2);
            Console.ReadLine();

            //o1在栈中 数据1在堆中
            object o1 = 1;
            object o2 = o1; //o2得到的是 数据1的地址
            o1 = 2;         //修改的是栈中o1存储的引用
            Console.WriteLine(o2);
            Console.ReadLine();


        }

da11

        /*垃圾回收器
         * · GC（Garbage Collection）是CLR中一种针对托管堆自动回收释放内存的服务。
         * · GC线程从栈中的引用开始跟踪，从而判定哪些内存是正在使用的，若GC无法跟踪到某一块堆内存
         *   那么就认为这块内存不再使用了，即为可回收的。
         * · 一般GC线程不干预的时候，是在内存快不够用的情况下才开始运行清理垃圾工作
         *   一旦开始工作，GC线程将会占用大量CPU资源
         *
        */

* GC线程清理垃圾抽象图

        static void Main(string[] args)
        {
            CS1();

        }

        private static void CS1()
        {
            int[] Arr = new int[100]; //重复赋值的数组时，第一次赋值的数组就没用了，统称垃圾（内存垃圾）
            Arr = new int[200];
        }

da11

        //拆装箱讲解
        /* 装箱 box
         * · 值类型隐式转换为object类型或由此值类型实现的任何接口类型的过程。重点语句
         * · 内部机制：
         *      1.在堆中开辟内存空间
         *      2.将值类型的数据复制到堆中
         *      3.返回堆中新分配对象的地址
         *
         * 拆箱 unbox
         * · 从object类型到值类型或从接口类型到实现该接口的值类型的 显示 转换
         * · 内部机制：
         *      1.判断给定类型是否是装箱时的类型
         *      2.返回已装箱实例中属于原值类型字段的地址
         *
         * 装箱操作和拆箱操作都比较消耗性能，装箱操作会比较更加消耗性能
         * 方法中形参object类型，实参传递值类型，则装箱
         * 可以通过重载，泛型避免。

        */
        private static void CS2()
        {
            int a = 1;

            //下面这句就叫装箱
            object o = a;

            //下面这句就叫拆箱
            int b = (int)o;

            int num = 100;
            string str = num.ToString();//此行没有装箱操作

            string str1 = "" + num; //有一次装箱操作，字符串跟值类型的拼接-->int-->object
            //内部方法实际是：string str1=string.Concat("",num); 此方法的形参是object类型

        }

da11

        //字符串特性讲解主Main
        /*
         * · 字符串常量具备字符串池特性
         *      - 字符串常量在创建前，首先在字符串池中查找是否存在相同文本。
         *      如果存在，则直接返回该对象引用；如果不存在，则开辟空间存储。
         *      - 目的：提高内存利用率。
         * · 字符串具有不可变性
         *      - 字符串常量一旦进入内存，就不得再次改变，因为如果在原位置改变会
         *      使其他对象内存被破坏，导致内存泄漏。当遇到字符串变量引用新值时，
         *      会在内存中新建一个字符串，将该字符串地址交由该变量引用。
         *
         *
        */
        private static void Main()
        {
            string s1 = "dza";
            string s2 = "dza";

            //判定两个对象的引用地址是否相等的方法
            bool bo1 =  object.ReferenceEquals(s1, s2);  //结果为true

            //object 引用类型，每次重新赋值修改，都是开辟新的堆区空间，修改的是栈区的引用
            //详看字符串池的字符串具有不可变性讲解！
            object o1 = 1;
            o1 = 2.0;
            o1 = "3";
            o1 = true;

            string S3 = "";
            for (int i = 0; i < 10; i++)
            {
                //循环没执行一次就会产生一个垃圾，此方法拼接字符串太占内存
                S3 = S3 + i.ToString();
            }
            Console.WriteLine(S3);

            //可变字符串：一次开辟可以容纳10个字符大小的空间
            //优点：可以在原有空间修改字符串，避免产生垃圾
            //适用性：频繁对字符串操作（增加、替换、移除）
            //此方法为字符串可变方法，循环拼接的时候字符串字节小于方法设定内，则不会产生垃圾，方法实参（设定开辟空间字符串大小）可以不填，则是默认值
            StringBuilder S4 = new StringBuilder(10);
            for (int i = 0; i < 10; i++)
            {

                S4.Append(i);
            }
            S4.Append("dsdsdas"); //如果增加字符串时超过了设定的字符串字节大小值，此方法则会创建一个更大的字符串空间，原有的字符串空间则成为垃圾
            //所以使用此方法前尽量预估准确此数值

            Console.WriteLine(S4);

            Console.ReadLine();
        }


            //以下为字符串特性方法的自学

            //ToArray方法，将字符串变为数组，数组的类型为char，数组无论定义多大，他都会根据字符串的长度改变数组长度
            //如定义数组长度为1时，字符串为10，则数组的长度改为10
            char[] charSZ=new char[1];
            charSZ= S3.ToArray();
            foreach (char item in charSZ)
            {
                Console.WriteLine(item);
            }

            string S5 = "Dza Hello And My Love XM";

            //ToLower方法，将字符串中，所有的大写字母转换为小写，需要字符串类型接收
            string S6 = S5.ToLower();

            Console.WriteLine(S6);

            //ToUpper方法，将字符串中，所有的小写字母转换为大写，需要字符串类型接收
            S6=S5.ToUpper();
            Console.WriteLine(S6);

            //Substring方法，将指定的字符串索引位置复制给一个新的字符串
            S6=S5.Substring(0,5);
            Console.WriteLine(S6);

            //Trim方法，将字符串的首个字符前和末尾字符后的空格删除
            S6=S5.Trim();
            Console.WriteLine(S6);

            //Split方法，将字符串中每个分割符分割的子字符串放入string类型的数组中，需要字符串数组类型接收
            string[] StrSZ =  S5.Split();
            foreach (var item in StrSZ)
            {
                Console.WriteLine(item);
            }

            //join方法，将一个字符串的数组，按照指定的分隔符分隔
            S6 = String.Join("-",StrSZ);
            Console.WriteLine(S6);
            Console.ReadLine();
        }




        //字符串练习主Main
        private static void Main()
        {
            //1.单词反转 How are you -->  you are How
            string S1 = "How are you";

            //使用Split方法，将字符串中每个分割符分割的子字符串放入string类型的数组中，需要字符串数组类型接收
            string[] StrSZ = S1.Split();
            Console.WriteLine(StrSZ.Length);

            //新建一个字符串类型数组用作后续操作
            string[] StrSz2 = new string[StrSZ.Length];
            int Count1=0;//计数器
            for (int i = StrSZ.Length-1; i >= 0; i--)  
            {
                //倒序装入新的字符串数组
                StrSz2[Count1] = StrSZ;
                Count1 += 1;
            }
            //使用join方法，将一个字符串的数组，按照指定的分隔符分隔
            string S2 = string.Join(" ", StrSz2);
            Console.WriteLine(S2);

            //2.字符反转 How are you --> uoy era woH
            char[] char1 = new char[1];

            //使用ToArray方法，将字符串元素变为数组
            char1= S1.ToArray();
            char[] char2 = new char[char1.Length];
            Count1 = 0;
            for (int i = char1.Length - 1; i >= 0; i--)
            {
                //倒序装入新的字符串数组
                char2[Count1] = char1;
                Count1 += 1;
            }
            foreach (var item in char2)
            {
                Console.Write(item);
            }
            Console.WriteLine();

            //3.查找指定字符串中，不重复出现的字符
            string S3 = "dddzamsasyjhtxom";
            char[] char3 =new char[10];
            char[] char4 = new char[char3.Length];

            //使用ToArray方法，将字符串元素变为数组
            char3 = S3.ToArray();
            int int1;

            //去除重复的字符for嵌套循环
            for (int WC = 0; WC < char3.Length; WC++)
            {
                for (int NC = 0; NC < char3.Length; NC++)
                {
                    if (WC==NC)
                    {
                        continue;
                    }
                    else
                    {
                        if (char3[WC] == char3[NC])
                        {
                            char3[NC] = '-';
                        }
                    }
                }
            }
            string S4=" ";
            string S5;

            int Count2=0;
            //将不重复的字符收集成一个新的字符串
            for (int i = 0; i < char3.Length;i++)
            {
                if (char3 == '-')
                {
                    continue;
                }
                S5 = char3.ToString();
                S4 = S4.Insert(Count2, S5);
                Count2++;
            }
            Console.WriteLine(S4);
            //foreach (var item in char3)
            //{
            //   Console.Write(item);
            //}

            Console.ReadLine();
        }

da11

         /*
         * 总结：
         * 数据类型的重点项：
         *      1.值类型
         *      2.引用类型
         *      3.方法执行在？
         *      4.局部变量的值类型
         *      5.局部变量的引用类型
         *      6.区分修改的是栈中存储的引用，还是堆中数据
         */

da11

         *成员变量
         * · 定义在类中方法外的变量
         * · 特点：
         *      - 具有默认值
         *      - 所在类被实例化后，存在堆中，对象被回收时，成员变量从堆中清楚。
         *      - 可以与局部变量重名。
         * · 值类型与引用类型：
         *      - 值类型：声明在堆中，数据存储在堆中。
         *      - 引用类型：声明在堆中，数据存储在堆的另一块空间中。