关于C#数组进行的所有操作

最新推荐文章于 2024-08-02 19:42:34 发布
最新推荐文章于 2024-08-02 19:42:34 发布
阅读量4k 收藏 23
点赞数 2
文章标签： c# 数组 数组排序

此页博客是我收集的所有关于数组的操作，并不全面，会持续更新；大家有发现更多的操作方法可以评论留言，我会持续更新；

数组是相同类型的对象的集合。由于数组几乎可以为任意长度，因此可以使用数组存储数千乃至数百万个对象，但必须在创建数组时就确定其大小。数组中的每项都按索引进行访问，索引是一个数字，指示对象在数组中的存储位置或槽。数组既可用于存储引用类型，也可用于存储值类型。

            using System;  
            using System.Collections.Generic;  
            using System.Text;  
             
            namespace ClassAboutArray  
            {  
            public class CreateArray  
            {

一维数组的定义


          /// <summary> 
        /// 一维数组的定义 
        /// </summary> 
        public void testArr1()  
        {  
        int[] myIntArr = new int[100];  
       //定义一个长度为100的int数组 
        string[] mystringArr = new string[100];  
        //定义一个长度为100的string数组 
      object[] myObjectArr = new object[100];  
     //定义一个长度为100的int数组 
         
        int[] myIntArr2 = new int[] { 1, 2, 3 };   
        //定义一个int数组，长度为3  
       string[] mystringArr2 = new string[] { "油", "盐" };  
       //定义一个string数组，长度为2  
        }

多维数组的定义


      
        /// <summary> 
        /// 多维数组的定义 
       /// </summary> 
        public void testArr2()  
        {  
        int[,] myIntArr = new int[10, 100];   
        //定义一个10*100的二维int数组 
        string[, ,] mystringArr = new string[2, 2, 3];   
        //定义一个2*2*3的三维string数组   
         
        int[,] myIntArr2 = new int[,] { { 1, 2, 3 }, { -1, -2, -3 } };  
        //定义一个2*3的二维int数组，并初始化 
        string[,] mystringArr2 = new string[,] { { "油", "盐" }, { "《围城》", "《晨露》" } };  
        //定义一个2*2的二维string数组，并初始化 
        }

交错数组的定义


      
        /// <summary> 
        /// 交错数组的定义 
        /// </summary> 
        public void testArr3()  
        {  
        int[][] myJaggedArray = new int[3][];  
        myJaggedArray[0] = new int[5];  
        myJaggedArray[1] = new int[4];  
        myJaggedArray[2] = new int[2];  
         
        int[][] myJaggedArray2 = new int[][]  
         {  
        new int[] {1,3,5,7,9},  
        new int[] {0,2,4,6},  
        new int[] {11,22}  
         };  
        }  
        }

使用GetLowerBound|GetUpperBound遍历数组


        
        public class TraverseArray  
        {  
        /// <summary> 
        /// 使用GetLowerBound|GetUpperBound遍历数组 
        /// </summary> 
        public void test1()  
        {  
        //定义二维数组 
        string[,] myStrArr2 = new string[,] { { "油", "盐" }, { "《围城》", "《晨露》" }, { "毛毛熊", "Snoopy" } };  
       //循环输出 
        for (int i = myStrArr2.GetLowerBound(0); i <= myStrArr2.GetUpperBound(0); i++)  
        {  
        Console.WriteLine("item{0}", i);  
        for (int j = myStrArr2.GetLowerBound(1); j <= myStrArr2.GetUpperBound(1); j++)  
        {  
        Console.WriteLine(" item{0}{1}:{2}", i, j, myStrArr2.GetValue(i, j));  
        }  
        }  
        }

使用foreach遍历数组


      
        /// <summary> 
        /// 使用foreach遍历数组 
        /// </summary> 
        public void test2()  
        {  
        //定义二维数组 
        string[,] myStrArr2 = new string[,] { { "油", "盐" }, { "《围城》", "《晨露》" }, { "毛毛熊", "Snoopy" } };  
       //循环输出 
        foreach (string item in myStrArr2)  
        {  
        {  
        Console.WriteLine("{0}", item);  
       }  
        }  
        }  
        }

利用Sort方法进行数组排序


     
        public class SortArray  
     {  
     /// <summary> 
    /// 利用Sort方法进行数组排序 
    /// </summary> 
     public void test1()  
     {  
     //定义数组 
    int[] myArr = { 5, 4, 3, 2, 1 };  
      
    //输出原始数组：原始数组:5->4->3->2->1-> 
    Console.WriteLine("原始数组:");  
     for (int i = 0; i < myArr.Length; i++)  
     Console.Write("{0}->", myArr[i]);  
    Console.WriteLine();  
      
   //对数组排序 
     Array.Sort(myArr);  
     
     //并输出排序后的数组：1->2->3->4->5-> 
     Console.WriteLine("排序以后数组:");  
     for (int i = 0; i < myArr.Length; i++)  
     Console.Write("{0}->", myArr[i]);  
     }

多个数组的关键字排序


      
    /// <summary> 
    /// 多个数组的关键字排序 
     /// </summary> 
    public void test2()  
    {  
     //定义数组 
     int[] arrSid = { 5, 4, 3, 2, 1 };  
     string[] arrSname = { "张三", "李四", "王五", "麻子", "淘气" };  
     
     //输出原始数组：原始数组:张三(5)->李四(4)->王五(3)->麻子(2)->淘气(1)-> 
    Console.WriteLine("原始数组:");  
     for (int i = 0; i < arrSid.Length; i++)  
     Console.Write("{0}({1})->", arrSname[i], arrSid[i]);  
     Console.WriteLine();  
     
   //根据学号关键字排序 
     Array.Sort(arrSid, arrSname);  
    
     //并输出排序后的数组：淘气(1)->麻子(2)->王五(3)->李四(4)->张三(5)  
    Console.WriteLine("排序以后数组:");  
     for (int i = 0; i < arrSid.Length; i++)  
    Console.Write("{0}({1})->", arrSname[i], arrSid[i]);  
    }  
     }

利用BinarySearch方法搜索元素


 
    public class SearchArray  
     {  
     /// <summary> 
    /// 利用BinarySearch方法搜索元素 
    /// </summary> 
   public void test1()  
     {  
    //定义数组 
     int[] myArr = { 5, 4, 3, 2, 1 };  
     
     //对数组排序 
    Array.Sort(myArr);  
     
     //搜索 
     int target = 3;  
    int result = Array.BinarySearch(myArr, target); //2  
     Console.WriteLine("{0}的下标为{1}", target, result); //2  
    }

判断是否包含某个值


  
     /// <summary> 
     /// 判断是否包含某个值 
     /// </summary> 
     public void test2()  
    {  
     //定义数组 
     string[] arrSname = { "张三", "李四", "王五", "麻子", "淘气" };  
     
     //判断是否含有某值 
     string target = "王五";  
     bool result = ((System.Collections.IList)arrSname).Contains(target);  
    Console.WriteLine("包含{0}?{1}", target, result); //true  
     }  
     }

利用Reverse方法反转数组


 
    public class ReverseArray  
    {  
     /// <summary> 
     /// 利用Reverse方法反转数组 
    /// </summary> 
     public void test1()  
     {  
    //定义数组 
    int[] myArr = { 5, 4, 3, 2, 1 };  
      
    //输出原始数组：原始数组:5->4->3->2->1-> 
     Console.WriteLine("原始数组:");  
    for (int i = 0; i < myArr.Length; i++)  
     Console.Write("{0}->", myArr[i]);  
    Console.WriteLine();  
    
     //对数组反转 
   Array.Reverse(myArr);  
     
     //并输出反转后的数组：1->2->3->4->5-> 
    Console.WriteLine("反转以后数组:");  
     for (int i = 0; i < myArr.Length; i++)  
    Console.Write("{0}->", myArr[i]);  
     }  
     }

利用Copy静态方法复制数组


     public class CopyArray  
     {  
     /// <summary> 
    /// 利用Copy静态方法复制数组 
    /// </summary> 
     public void test1()  
     {  
     //定义数组 
    int[] myArr = { 5, 4, 3, 2, 1 };  
     
     //输出原始数组：原始数组:5->4->3->2->1-> 
     Console.WriteLine("原始数组:");  
    for (int i = 0; i < myArr.Length; i++)  
     Console.Write("{0}->", myArr[i]);  
     Console.WriteLine();  
    
     //复制数组 
     int[] newnewArr = new int[3];  
     Array.Copy(myArr, newArr, 3);  
    
     //并输出反复制的数组：5->4->3-> 
    Console.WriteLine("复制数组:");  
     for (int i = 0; i < newArr.Length; i++)  
    Console.Write("{0}->", newArr[i]);  
    }

利用CopyTo实例方法复制数组


     /// <summary> 
     /// 利用CopyTo实例方法复制数组 
     /// </summary> 
     public void test2()  
     {  
     //定义数组 
     int[] myArr = { 5, 4, 3, 2, 1 };  
      
     //输出原始数组：原始数组:5->4->3->2->1-> 
     Console.WriteLine("原始数组:");  
     for (int i = 0; i < myArr.Length; i++)  
     Console.Write("{0}->", myArr[i]);  
     Console.WriteLine();  
      
     //复制数组 
     int[] newnewArr = new int[7];  
     myArr.CopyTo(newArr, 2);  
      
     //并输出反复制的数组：0->0->5->4->3->2->1-> 
     Console.WriteLine("复制数组:");  
     for (int i = 0; i < newArr.Length; i++)  
     Console.Write("{0}->", newArr[i]);  
     }  
     }

利用CreateInstance动态创建数组


     public class DynamicCreateArray  
     {  
     /// <summary> 
     /// 利用CreateInstance动态创建数组 
     /// </summary> 
     public void test1()  
     {  
     //定义长度数组 
     int[] lengthsArr = new int[] { 3, 4 };  
     int[] lowerBoundsArr = { 1, 11 };  
      
     Array arr = Array.CreateInstance(Type.GetType("System.Int32"), lengthsArr, lowerBoundsArr);  
      
     Random r = new Random(); //声明一个随机数对象 
     //循环赋值、输出 
     for (int i = arr.GetLowerBound(0) - 1; i < arr.GetUpperBound(0) - 1; i++)  
     {  
     for (int j = arr.GetLowerBound(1) - 1; j < arr.GetUpperBound(1) - 1; j++)  
     {  
     arr.SetValue((int)r.Next() % 100, i, j);//用1～100的随即数赋值 
     Console.WriteLine("arr[{0},{1}]={3}", i, j, arr.GetValue(i, j));  
     }  
     }  
     }  
     }  
    }

以上内容原文地址：https://www.cnblogs.com/chentao123/p/6507436.html

丶博Liang
关注
C#数组的常用操作方法小结
09-02
以下是对C#数组常用操作方法的详细说明： 1. **数组的声明和赋值**： - 单行声明并初始化：`int[] myArray = {1, 2, 3, 4};` - 分步声明和初始化：首先声明数组变量`int[] myArray;`，然后通过`new`关键字分配...
C#中的数组
Mr_ChenDaBao的博客
04-22 289
数组： //数组 //给数组添加10个元素，分别是1-10； int[] c = new int[10]; for(int d = 0; d < 10; d++) { c[d] = d + 1; } for(int e = 0; e < c.Length; e++) ...
C# 数组
09-10 578
数组 day06 2018.01.09 周二 -------------------------------------------------------- 上午 数组 数组的定义： 数组类型[] 数组名 ; 如：int[] ages ; 数组的初始化：明确数组长度和数组元素赋值的...
C# Array
最新发布
m0_74918341的博客
08-02 995
/获取多维数组中第一个维度的长度。//1.数组的声明,声明数组类似声明变量,需要指定数组中存储的数据类型,一般数组变量的名称以复数的形式命名(加s)//数组中数据的操作都是基于索引的,索引从0开始,到数组的长度(Length)-1结束,用于访问数组中存储的数据。交错数组其实就是元素为数组的数组，换句话说就是交错数组中的每个元素都可以是维度和大小不同的数组，所以有时交错数组也被称为“数组的数组”。//如果初始化的时候指定了数组的初始值,那么就可以省略指定数组的长度,会自动根据数组的初始值判定数组的长度。
c#中数组长度的几种定义
mlxg99999的博客
11-15 1万+
1.定义与已知数组长度的一维数组 已知nums[],定义res[]. int[] res = new int[nums.Length];//方括号里是数组的长度，nums.Length是一个数，表示nums的长度 想再定义数组的内容 int[] res = new int[3]{1,2,3};//大括号代表长度为3的数组的内容 2.定义与一个数组长度为sum的一维数组 int[] res = new int[sum];//方括号里是数组的长度 想再定义数组的内容的方法同上。 3.多维数组 方括号里数
C# 数组Array.Sort()、List.Sort()排序使用方法
热门推荐
enternalstar的博客
08-27 2万+
【对一维数组】 数据：int[] A = {16, 67, 12, 50, 8, 46, 4}; 整体升序：Array.Sort(A); 整体降序：先升序，再反转Array.Reverse(A); 局部升序：Array.Sort(A,2,4);//从索引为2的元素开始的4个元素进行升序 局部降序：Array.Reverse(A,2,3);//对索引为2的元素开始的3个元素进行反转，这是接着Array.Sort执行的 从左到右的图片分别是从整体升序到 的结果 【对二维数组】 数据： ...
定义一个包含 10 个元素的整型数组，通过随机产生 10 以内的随机数，给数组中的每个元素赋值，并输出结果。
CNSA183_20的博客
04-30 7424
任务： 功能：定义一个包含 10 个元素的整型数组，通过随机产生 10 以内的随机数，给数组中的每个元素赋值，并输出结果。 运行结果：0332632709 注：由于数组元素值为随机产生，所以运行结果不固定，此运行结果仅作为示例 请在下图中的第6、11、17行中将代码填写完整。 package world; public class Sui { public static void main(String[] args) { ...
C#byte数组传入C操作方法
01-20
将C语言封装成函数dll供C#端调用，需要传递的byte数组作为函数参数来传递。 1、打开Visual Studio2017创建一个C的dll工程；取名为Dll1 2、打开dllmain.cpp，增加一个byte数组元素求和的函数： Cal(unsigned char* ...
详解c# 数组（Array）
12-17
以下是对C#数组的详细解释： 1. **数组定义与声明**： 在C#中，数组的声明使用以下语法： ```csharp datatype[] arrayName; ``` 其中，`datatype` 表示数组中元素的数据类型，如 `int`、`string` 或 `double`...
使用不同随机数为数组赋值
qq_42541819的博客
09-26 709
定义一个长度为10的int型的数组arr，要求使用不重复的随机数为arr赋值，随机数范围为[1,20]。 public static void main(String[] args) { int[] arr = new int[10]; Random r = new Random(); for (int i = 0; i < arr.length; i++) { int num = r.nextInt(20)+1;
C#_基础_数组（九）
A1185222867的博客
06-10 155
概念：一次性存储多个相同类型的变量，区别结构一次性声明多个不同类型的变量 1.动态初始化数组 //数组类型[] 数组名字 = new 数组类型[数组长度]; int[] nums = new int[10]; //声明一个 int类型， 长度10的 数组 数组中默认是0 给数组赋值： 　　1 nums[5] = 10; 　　2 nums[3] ...
C#中常见的数组（一维）排序算法
G_Peter的博客
05-31 2001
选择排序:        排序轮数：元素个数-1        算法逻辑：每一轮获取当前轮的第一个元素，依次和其后的各个元素进行比较，按照排序规则进          行相应的元素值交换。每一轮排序完成，会找到当前轮的一个最值存储在第一个元素中，下一轮比较        忽略该元素             例：8  3 6  5  1   从小到大排序              * 第...
c#固定数组大小_在C＃中声明一个固定大小的数组
cumubi7552的博客
07-17 8287
c#固定数组大小In C#, an array can be declared with a fixed size length and a variable length. Sometimes it's required that we need to have an array of fixed length. In this tutorial, we will learn how to de...
C#一维数组排序方法：选择排序法
wenchm的博客
02-08 495
通过遍历实现排序，第i次遍历获得index=i以后的元素中的最小值，然后与index=i的元素互换。常见的排序法：选择排序法、冒泡排序法、快速排序法、直接插入法、希尔排序法、Array.Sort方法。
C# 数组排序
weixin_45411626的博客
06-22 1158
C# 数组排序
创建一个长度为10的int型数组，要求数组元素的值都在 1~10之间，且是随机赋值，同时要求元素的值各不相同
weixin_46990454的博客
10-21 1923
public class Test001 { public static void main(String[] args) { //笔试题 /* * 创建一个长度为10的int型数组，要求数组元素的值都在 * 1~10之间，且是随机赋值，同时要求元素的值各不相同 */ int[] array = new int[10]; for(int i = 0; i < array.length; i++) { A:do { array[i] = (int)(Ma
定义一个长度为10的整数数组A，并从键盘为数组A赋值。并将数组A中的元素按从大到小的顺序进行排序，并输出。
m0_73509057的博客
12-08 3476
#include<stdio.h> int main() { int i,j,k,r; int a[10]; printf("请输入十个数："); for (i = 0; i < 10; i++) { scanf("%d", &a[i]); } for (j = 0; j < 9; j++) { for(k=0;k<9-j;k++) if (a[k] > a[k + 1]) { r = a[
C#基础 string PadLeft 在字符串前、后加入指定字符，达到指定长度
心少朴
05-11 1360
 .NET Framework : 4.7.2        IDE : Visual Studio Community 2019         OS : Windows 10 x64     typesetting : Markdown         blog : blog.csdn.net/yushaopu        gi...
C#数组基础：访问与操作数组元素
7. **System.Array类**：C#中的System.Array类提供了许多操作数组的通用方法，如Sort()用于对数组进行排序，Clone()用于复制数组，以及Copy()用于将一个数组的内容复制到另一个数组。 8. **字符串处理**：字符串在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值