C#学习笔记(二)简单的C#类问题

本文介绍了C#中string类型的null与""的区别,包括内存分配和对象状态。接着讨论了类与结构的相似点和不同点,如实例化、继承和类型。此外,讲解了拆箱、装箱的概念,以及ArrayList、HashTable和泛型集合如List、Dictionary的特点和使用场景。最后,对比了const和readonly、out和ref参数的区别,以及StringBuilder与String在字符串操作上的性能差异。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

01:在C#中,string str = null 与 string str = “”的区别
String str=null 这句话的意思就是定义一个字符串,变量str,字符串的内容为空值。

String str=“” 定义一个String类型的变量str,并为其赋值。
(1)""分配了内存;null没有分配内存。

(2)""是一个字符串(String).它在内存中是存在的.而null它是一个空对象.在内存中是不存在的。

(3)""占内存,在内存中会分配一个空间。 null不占内存. 为空引用.

String str1= null; str引用为空String str2= “”; str应用一个空字符串也就是null没有分配空间,"“分配了空间,因此str1还不是一个实例化的对象,而str2已经实例化。注意null不是对象,”"是对象。总结: null表示的是一个对象的值,而并不是一个字符串。例如声明一个对象的引用,String a = null ; “”表示的是一个空字符串,也就是说它的长度为0。例如声明一个字符串String str = “” ;

内存分配 String str= null ; 表示声明一个字符串对象的引用,但指向为null,也就是说还没有指向任何的内存空间; String str= “”; 表示声明一个字符串类型的引用,其值为”“空字符串,这个str引用指向的是空字符串的内存空间;

02:简述类和结构的相同点和不同点。
结构:
(1).结构可以不通过new操作符来实例化;
(2).结构在使用之前必须进行数据初始化;
(3).结构不可以定义无参构造函数;
(4).结构定义有参的构造函数,必须在构造函数对字段进行初始化;
(5).结构不可以继承,也不可以被继承,但可以实现接口;
(6).结构是值类型;

using System;
using System.Text;
     
struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   public void getValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id; 
   }
   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }

};  
public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1;        /* 声明 Book1,类型为 Book */
      Books Book2;        /* 声明 Book2,类型为 Book */

      /* book 1 详述 */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali"; 
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;

      /* book 2 详述 */
      Book2.title = "Telecom Billing";
      Book2.author = "Zara Ali";
      Book2.subject =  "Telecom Billing Tutorial";
      Book2.book_id = 6495700;

      /* 打印 Book1 信息 */
      Console.WriteLine( "Book 1 title : {0}", Book1.title);
      Console.WriteLine("Book 1 author : {0}", Book1.author);
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);

      /* 打印 Book2 信息 */
      Console.WriteLine("Book 2 title : {0}", Book2.title);
      Console.WriteLine("Book 2 author : {0}", Book2.author);
      Console.WriteLine("Book 2 subject : {0}", Book2.subject);
      Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);       

      Console.ReadKey();

   }
}

类:
(1).类必须通过new实例化
(2).引用类型
(3).可以定义无参构造函数
(4).可以被继承,可以继承其他类;

    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1,类型为 Box
            Box Box2 = new Box();        // 声明 Box2,类型为 Box
            double volume = 0.0;         // 体积

            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积: {0}",  volume);

            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积: {0}", volume);
            Console.ReadKey();
        }
    }

03:什么是拆箱和装箱

int val = 100; 
object obj = val; 
Console.WriteLine (“对象的值 = {0}", obj); 
//这是一个装箱的过程,是将值类型转换为引用类型的过程

 

int val = 100; 
object obj = val; 
int num = (int) obj; 
Console.WriteLine ("num: {0}", num); 
//这是一个拆箱的过程,是将值类型转换为引用类型,再由引用类型转换为值类型的过程

04:冒泡排序

    class Program
    {
        static void Main(string[] args)
        {
            int temp = 0;
            int[] arr = {23, 44, 66, 76, 98, 11, 3, 9, 7};
            for (int i = 0; i < arr.Length - 1; i++)
            {
                #region将大的数字移到数组的arr.Length-1-i
                for (int j = 0; j < arr.Length - 1 - i; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        temp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
            Console.WriteLine("排序后的数组:");
            foreach (int item in arr)
            {
                Console.Write(item+"");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }

05:编程实现一个递归方法

//代码实现Fibonacci数列
 public static int Fibonacci(int n)
      {
         if (n < 0) return -1;
         if (n == 0) return 0;
         if (n == 1) return 1;
         return Fibonacci(n - 1) + Fibonacci(n - 2);
      }

06:集合有哪些?,每一种集合的特点以及使用场景
(1)ArrayList

     ArrayList类似于数组,有人也称它为数组列表。ArrayList可以动态维护,而数组的容量是固定的。

它的索引会根据程序的扩展而重新进行分配和调整。和数组类似,它所存储的数据称为元素,它所保存的元素数就是它的容量。默认初始容量为0,在使用它时,需引入命名空间System.Connections;以下代码可以定义一个ArrayList:

using System.Collections;

//创建容量为0的ArrayList对象

ArrayList myList = new ArrayList();

//创建容量为5的ArrayList对象

ArrayList myList = new ArrayList(5);

//获取对象中实际包含的元素数

int num = myList.Count();

ArrayList通过Add()方法添加元素,其方法返回一个Int类型的值,这个值代表所添加的元素在集合中的索引。

参数:如果向ArrayList中添加的元素是值类型,那么这些元素就会自动装箱处理转换为Object引用类型,然后保存,所以ArrayList中的所有元素都是对象的引用。

删除ArrayList中的元素有三种方法,分别为:

对象名.RomoveAt(int index);

对象名.Romove(Object value);

对象名.Clear();(这种方法会将集合中的所有元素删除,俗称"清空"~~~)

(2)HashTable

C# /提供了一种称为HashTable的数据结构,通常称为哈希表,有的人称它为"字典".HashTable的数据是通过键(Key)和值(Value)来组织的,同ArrayList一样,它也属于System.Collections命名空间中,它所存放的每个元素都是键/值对.以下为HashTable的常用方法和属性:

属性名称:Count

属性名称:Keys

属性名称:Values 说明: 获取包含在HashTable中值的集合

方法名称:Add(Object key,Object Value)

方法名称:Remove(Object Key)

方法名称:Clear()

和ArrayList不同,访问HashTable元素时可以直接通过键名来获取具体值,同样,由于值类型是Object.所以当得到一个值时也需要通过类型转换得到指定类型的对象.

(3)泛型集合: List

泛型是C#2.0中的一个新特性。泛型引入了一个新概念:类型参数。通过使用类型参数(T),减少了运行时强制转换成装箱操作的风险。通过泛型集合可以最大限度的重用代码、保护类型的安全及提高性能。

定义一个 List泛型集合的方法如下:

List 对象名 = new List();

List添加元素、获取元素、删除元素以及遍历和ArrayList用法都是类似的,但 List保障了类型的安全性。在获取元素时无需进行类型转换.下面我们把List和ArrayList作以比较

不用点:List对所保存元素做类型约束,而ArrayList可以增加任意类型。添加、读取值类型元素 List无需拆箱装箱,而ArrayList需要做拆箱、装箱处理。

相同点:通过索引访问集合中的元素,添加、删除元素方法相同

(4)泛型集合Dictionary<K,V>

它具有泛型的全部特性,编译时检查类型约束,获取元素时无需类型转换,并且它存储数据的方式和HashTable类似。也是通过Key/Value对元素保存的。定义语法为:

Dictionary<K,V>对象名 = new Dictionary<K,V>

<K,V>中的K表示集合中Key的类型,V表示Value的类型,它的含义和List是相同的.例如:

Dictionary<string,SE> engineers = new Dictionary<string,SE>();

在这个集合中,Key类型是string类型,Value是SE类型。 下面我们把 Dictionary<K,V> 和HashTable作以比较:

不同点: Dictionary<K,V>对所保存的元素做类型约束,而HashTable可以增加任何类型。 Dictionary<K,V>添加、读取值类型元素无需拆箱、装箱,而HashTable需要做拆箱、装箱处理

相同点:通过Key获取Value, 添加、删除、遍历元素方法相同

07:变量被标记为 “const” 和readonly” 有何不同?
const修饰的常量在声明的时候必须初始化;readonly修饰的常量则可以延迟到构造函数初始化 ;
const 只读 但不能修改,readonly 只读可修改

08:“out” 和 “ref” 参数有何不同?
(1)使用ref型参数时,传入的参数必须先被初始化,对out而言,必须在方法中对其完成初始化。
(2)使用ref和out时,在方法的参数和执行方法时,都要加Ref或Out关键字,以满足匹配。
(3)out适合用在需要retrun多个返回值的地方,而ref则用在需要被调用的方法修改调用者的引用的时候。
(4)ref传进去的参数在函数内部可以直接使用,而out不可。
(5)系统对ref的限制是更少一些的。
(6)若要使用 ref 参数,必须将参数作为 ref 参数显式传递到方法,ref 参数的值被传递到 ref 参数。

(7)当希望方法返回多个值时,声明 out 方法非常有用;使用 out 参数的方法仍然可以返回一个值。
ref:

class Program
    {
        static void Main(string[] args)
        {
            Program pg = new Program();
            int x = 10;
            int y = 20;
            pg.GetValue(ref x, ref  y);
            Console.WriteLine("x={0},y={1}", x, y);
 
            Console.ReadLine();
        }
 
        public void GetValue(ref int x, ref int y)
        {
            x = 521;
            y = 520;
        }
    }
运行结果为 
x=521,y=520

out:

class Program
    {
        static void Main(string[] args)
        {
            Program pg = new Program();
            int x=10;
            int y=233;
            pg.Swap(out x, out y);
            Console.WriteLine("x={0},y={1}", x, y);
 
            Console.ReadLine();
        }
 
        public void Swap(out int a,out  int b)
        {
            int temp = a;   //a,b在函数内部没有赋初值,则出现错误。
            a = 521;
            b = 520;
        }     
    }
运行结果为 
x=521,y=520

09:“StringBuilder” 和 “String” 有何不同?

  1. string 对象时恒定不变的,stringBuider对象表示的字符串是可变的。stringBuilder是.net提供的动态创建string的高效方式,以克服string对象恒定性带来的性能影响。

  2. 对于简单的字符串连接操作,在性能上stringBuilder并不一定总是优于string。因为stringBuider对象创建代价较大,在字符串目标连接较少的情况下,过度滥用stringBuilder会导致性能的浪费,只有大量的或者无法预知次数的字符串操作,才考虑stringBuilder来实现。事实上,一般连接次数设置100次以内,根本看不出两者的性能差别。

  3. 当修改字符串信息时,此时不许创建对象,可以使用stringBuilder对象。

String 对象是不可改变的。每次使用 System.String 类中的方法之一时,都要在内存中创建一个新的字符串对象,这就需要为该新对象分配新的空间。

例如: string a=“a”;a+=“b”;,每次在后面追加都会重新申请一个能放字符串的内存空间;

string Interning(字符串驻留)指的是通过维护一张表来存放字符串。CLR内部维护了一个哈希表(Hash Table)来管理其创建的大部分string对象,其中key为string本身,而value为分配给对应string的内存地址。

public static string Intern(string str);

public static string IsInterned(string str);

两者的处理机制都是在哈希表中查找是否存在str参数字符串,如果找到就返回已存在的string对象的引用,没有找到,Intern方法将该str字符串添加到哈希表,并返回引用;而IsInterned方法则不会向哈希表中添加字符串,而是返回null;

StringBuilder 对象是动态对象,允许扩充它所封装的字符串中字符的数量,但是您可以为它可容纳的最大字符数指定一个值,当修改 StringBuilder 时,在达到容量之前,它不会为其自己重新分配空间。当达到容量时,将自动分配新的空间且容量翻倍。可以使用重载的构造函数之一来指定 StringBuilder 类的容量。

例如: StringBuilder sb = new StringBuilder(); sb.Append(“a”)他不会频繁申请内存空间,他会自动向后扩展。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值