C-sharp方法、数组和字符串

方法

相关文章

方法的定义和调用

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo06
{
    class Program
    {
        public static int GetMax(int a,int b)  // 求最大值函数
        {
            if (a>b)
            {
                return a;
            }
            else
            {
                return b;
            }
        }

        public static void Add(int a, int b)    // 求两数之和
        {
            Console.WriteLine("{0}+{1}={2}", a, b, a + b);
        }
        public static void Main(string[] args)
        {
            int x = 2, y = 3;
            Add(x, y);
            Console.WriteLine("{0}和{1}中的最大值为{2}", x, y, GetMax(x, y));
            Console.ReadLine();
        }
    }
}

参数传递

当调用带有参数的方法时，需要向方法传递参数。在 C# 中，有三种向方法传递参数的方式：

  • 值参数
  • 引用参数
  • 输出参数

值参数

值参数是参数传递的默认方式。这种方式下，当调用一个方法时，会为每个值参数创建一个新的存储位置。

实际参数的值会复制给形参，实参和形参使用的是两个不同内存中的值。所以当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。

上述例子即为值参数传递：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo06
{
    class Program
    {
        public static int GetMax(int a,int b)  // 求最大值函数
        {
            if (a>b)
            {
                return a;
            }
            else
            {
                return b;
            }
        }

        public static void Add(int a, int b)    // 求两数之和
        {
            Console.WriteLine("{0}+{1}={2}", a, b, a + b);
        }
        public static void Main(string[] args)
        {
            int x = 2, y = 3;
            Add(x, y);
            Console.WriteLine("{0}和{1}中的最大值为{2}", x, y, GetMax(x, y));
            Console.ReadLine();
        }
    }
}

引用参数

引用参数是对变量的内存位置的引用。当按引用传递参数时，与值参数不同的是，它不会为这些参数创建一个新的存储位置。引用参数表示和提供给方法的实际参数具有相同的内存位置。

在C#中，使用ref关键字声明引用参数。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo07
{
    class Program
    {
        public static void swap(ref int a, ref int b)   // 声明交换函数
        {
            int temp;
            temp = a;
            a = b;
            b = temp;
        } 

        static void Main(string[] args)
        {
            int x = 10, y = 20;
            swap(ref x, ref y);
            Console.WriteLine("x={0},y={1}", x, y);
            Console.ReadLine();
        }
    }
}

输出参数

return语句可用于只从函数返回一个值。但是，可以使用输出参数来从函数中返回两个甚至多个值。

输出参数会把方法输出的数据赋值给自己，其他方面和引用参数相似（即out和ref一样，也是传递的指针）。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo08
{
    class Program
    {
        public static void Getvalue(out int x)
        {
            int temp = 666;
            x = temp;
        }
        static void Main(string[] args)
        {
            int a = 100;
            Console.WriteLine("在方法调用前a的值为：{0}", a);
            Getvalue(out a);
            Console.WriteLine("在方法调用后a的值为：{0}", a);
            Console.ReadLine();
        }
    }
}

提供给输出参数的变量不需要赋值。当参数需要从一个没有指定初始值的方法中返回值时，输出参数特别有用。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo08
{
    class Program
    {
        public static void Getvalues(out int x,out int y)
        {
            Console.WriteLine("请输入第一个值：");
            x = Convert.ToInt32(Console.ReadLine());    // 将字符串转成int类型
            Console.WriteLine("请输入第二个值：");
            y = Convert.ToInt32(Console.ReadLine());    // 将字符串转成int类型
        }
        static void Main(string[] args)
        {
            int a, b;
            Getvalues(out a, out b);
            Console.WriteLine("方法调用后a的值：{0}", a);
            Console.WriteLine("方法调用后a的值：{0}", b);
            Console.ReadLine();
        }
    }
}

上述代码执行后，输出的a和b的值取决于用户输入。

ref和out的区别：

  • ref 是有进有出，即能将参数传进去，函数里对变量的改变在函数结束时会改变值，因此需要在传递进去前初始化。
  • out 是只出不进，即将参数传进去时值是无效的，out会把参数清空，所以无法将一个值从 out 传递进去。

ref的变量初始化了, out的变量不需初始化

params参数

菜鸟教程，相关文章

使用params修饰符来指定数组参数。

当方法参数中既有其他参数类型，又有params修饰的数组参数时，params参数必须放在最后面。只能有一个使用params修饰的数组参数。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo08
{
    class Program
    {
        public static void GetSum(string name,params int[] scores)
        {
            int sum = 0;
            for (int i = 0; i < scores.Length; i++)
            {
                sum = sum+scores[i];
            }
            Console.WriteLine("{0}的{1}门课总成绩为：{2}", name, scores.Length, sum);
        }
        
            
        static void Main(string[] args)
        {
            GetSum("张三", 76, 78, 89, 67, 89, 69);
            Console.ReadLine();
        }
    }
}

数组

菜鸟教程

数组是一组具有相同数据类型的数据组成的集合。

  • 一维数组
  • 多维数组
  • 锯齿数组

一维数组中的每个数据都只有一个元素。

一维数组声明形式：

1
2
3
4
数据类型[] 数组名;		// 仅声明名字，并未分配内存空间
数据类型[] 数组名 = new 数据类型[长度];	// 分配内存空间，用默认值初始化
数据类型[] 数组名 = {元素列表};	// 直接使用初始值来创建数组
数据类型[] 数组名 = new 数据类型[长度]{元素列表};	// 最完整的一维数组声明形式

二维数组声明形式：

1
2
3
4
数据类型[,] 数组名;	// 仅声明名字，并未分配内存空间
数据类型[,] 数组名 = new 数据类型[第一维长度,第二维长度];	// 分配内存空间，用默认值初始化
数据类型[,] 数组名 = {{元素列表},{元素列表},{元素列表}...}; // 直接用初始值来创建数组
数据类型[,] 数组名 = new 数据类型[第一维长度,第二维长度]{元素列表};

锯齿数组：当一个一维数组的每个元素也是数组，且每个数组长度不同时，这样形成的数组统称为锯齿数组。（相关教程）

数组练习

数组的赋值和输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo01
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 1, 2, 3, 4, 5, 666 };
            arr[2] = 33;    // 数组的赋值
            foreach (var item in arr)   // 数组的输出，这里使用foreach循环
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }
    }
}

计算并输出一个数组的最大值、最小值、总和、平均值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo01
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 1, 2, 3, 4, 5, 666 };
            int max=arr[0], min = arr[0], sum=0;
            double avg=0;

            foreach (var item in arr)   
            {
                if (item>max)
                {
                    max = item;
                }
                if (item < min)
                {
                    min = item;
                }
                sum = sum + item;
            }
            avg = (double)sum / arr.Length;
            Console.WriteLine("最大值是{0}，最小值是{1}，总和是{2}，平均值是{3}", max, min, sum, avg);
            Console.ReadLine();
        }
    }
}

注意：数组间的赋值，是赋予地址值。

数组作为方法的参数

可以使用params关键字，也可以直接使用数组作为方法形参（因为传递到形参是地址值，所以改变的还是原数组）

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo02
{
    class Program
    {
        // 定义一个方法，将一个一维整型数组的全部元素都+3
        public static void Add3(int[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = arr[i] + 3;
            }
        }
        // 定义一个方法，输出一个一维整型数组的全部内容
        public static void PrintArr(int[] arr)
        {
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }
        }
        static void Main(string[] args)
        {
            int[] a = { 1, 2, 3, 4, 5, 666 };
            Console.WriteLine("+3前数组为：");
            PrintArr(a);
            Add3(a);
            Console.WriteLine("+3后数组为：");
            PrintArr(a);
            Console.ReadLine();
        }
    }
}

字符串

字符串是一种特殊的引用类型。

字符串常用方法

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo03
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "helloworld";
            // 1.Length属性，求字符串长度
            Console.WriteLine(str.Length);

            // 2.字符串和字符、字符数组之间的转换
            char ch1 = str[2];  // 字符串转字符
            Console.WriteLine(ch1);

            string str2 = 'a'.ToString();   // 字符转字符串

            char[] arr = str.ToCharArray(); // 字符串转字符数组
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }

            char[] arr2 = { 'x', 'y', 'z' };
            string str3 = new string(arr2); // 字符数组转字符串（通过string构造函数）
            Console.WriteLine(str3);

            // 3.查找指定字符或字符串在已知字符串中的位置
            int i1 = str.IndexOf('o');  // IndexOf()可以有三个参数，具体可自行查看
            int i2 = str.IndexOf("ll");
            Console.WriteLine(i1);
            Console.WriteLine(i2);

            // 4.插入、替换、删除、截取字符串
            string str4 = "abcde";
            string str4_1 = str4.Insert(1, "123");  // 插入
            Console.WriteLine(str4_1);  // a123bcde

            string str4_2 = str4.Replace("de", "22");   // 替换
            Console.WriteLine(str4_2);  // abc22

            string str4_3 = str4.Remove(1, 2);   // 删除（2表示索引位数，3表示删除个数）
            Console.WriteLine(str4_3);  // ade

            string str4_4 = str4.Substring(1, 3);   //截取
            Console.WriteLine(str4_4);  // bcd

            // 5.分离字符串（字符串切割，Split）
            string str5 = "I have a dream";
            string[] str5_1 = str5.Split(' ');  // 字符串以空格切割(Split有一个重载方法可用于删除所有空格，可自行查找)
            foreach (var item in str5_1)
            {
                Console.WriteLine(item);
            }

            // 6.去除字符串两端的空格
            string str6 = "  hello   world    ";
            string str6_1 = str6.Trim();
            Console.WriteLine(str6_1);  // hello   world 

            Console.ReadLine();
        }
    }
}

字符串与其他类型的转换

  1. 使用parse方法。简单类型有一个共同的方法parse，可以将字符串转换为需要的简单类型。
  2. **使用Convert类。**Conver类中包含了若干个方法，可以实现数据类型之间的转换。

注意：使用这两种方法，都要保证被转换的字符串可以正确转换成目标简单类型。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo04
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "666";
            // 1.使用parse方法
            int i = int.Parse(str);
            Console.WriteLine(i + 1);   // 转成数字了，667
            bool b1 = bool.Parse("true");   // 其他类型的转换同理
            Console.WriteLine(b1);


            // 2.使用Convert类
            int i2 = Convert.ToInt32(str);
            Console.WriteLine(i + 2);   // 转成数字了，668
            bool b2 = Convert.ToBoolean("false");   // 其他类型的转换同理
            Console.WriteLine(b2);

            Console.ReadLine();
        }
    }
}

补充TryParse：

1
2
3
string s = "123";
int result = -1;
bool b = int.TryParse(s,out result)

（result作为输出值，如果转换失败则输出值为0）具体用法可自行转换

字符串的赋值

字符串是一种特殊的引用类型。字符串中的内容是不可变的，当执行string str = "abc"; str = "cdd"时，并没有改变原来堆内存的数据（即"abc"），而是另外开辟一块新的堆内存空间保存新值（“cdd”），并将字符串变量在栈内存上的地址引用修改为新的堆内存地址（"cdd"所在地址）

当程序中需要较多次字符串拼接操作时，可以使用StringBuilder操作。（具体可自行查找）