C#——数组

Biegral 2014/2/17 13:41:00 2194

C#——数组

 

一、数组的声明

例如：int[]nums = {5,3,8}                          类型后加[],就是这个类型的数组类型

           int[] nums = new int[3]{5,3,8}          注意：个数和声明数必须一致。

 二、数组的循环
 
数组的循环有两种：
第一种：for循环
第一种：foreach循环(具体语法结构如下图)
 
二者的区别：for循环可以不逐个遍历，foreach循环逐个遍历
 
 
对图中例子foreach循环的解释如下：
   string[] names = {"job","jerry","lily"};   
            声明一string类型的数组
 

            foreach (string name in names)          
            对于数组names中的每一个元素进行循环，循环的变量名叫name     
 
 
            { }表示：对每一个元素执行{}中的操作  
            {
                Console.WriteLine("我的名字{0}",name);         
            }
 

三、实例

例1：数据的声明

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace 数据  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //声明三个int类型的变量i1,i2,i3  
  8.             int i1 = 20;  
  9.             int i2 = 30;  
  10.             int i3 = 50;  
  11.   
  12.             //声明一个int类型的数组（里面包含三个元素，其等价于上面的变量）  
  13.             int[]values={20,30,50};     //类型后加[],就是这个类型的数组类型  
  14.              
  15.         }  
  16.     }  
  17. }</span>  


int[]values = {20,30,50}  表明声明int类型的数组，有三个无素20，30，50。

 

例2：对数组值元素进行赋值

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace 数据  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             int[] values = { 20, 30, 50 };//类型后加[],就是这个类型的数组类型（声明一个int类型的数组）  
  8.              
  9.             Console.WriteLine(values.Length);  
  10.             Console.WriteLine(values[0]);  
  11.             values[2] = values[2] * 2;  
  12.             Console.WriteLine(values[2]);  
  13.             Console.ReadKey();  
  14.         }  
  15.     }  
  16. }</span>  

 

数组循环for


例3：访问数组元素

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace 数据  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //声明一个int类型的数组  
  8.             int[]values={20,30,50};     //类型后加[],就是这个类型的数组类型  
  9.   
  10.             //访问数组中的每一个元素  
  11.             for (int i = 0; i < values.Length; i++)//是<,而不是<=,length和最后一个元素的序号相差1，  
  12.             {  
  13.                 Console.WriteLine(values[i]);  
  14.             }  
  15.                 Console.ReadKey();  
  16.         }  
  17.     }  
  18. }</span>  

注意：数组元素的序号是从0开始的。


数组循环foreach

例4：打印数据中的每一元素

[csharp] view plaincopyprint?
  1. <span style="font-size:18px;">namespace foreach循环  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             string[] names = {"job","jerry","lily"};  
  8.             foreach (string name in names)  
  9.             {  
  10.                 Console.WriteLine("我的名字{0}",name);  
  11.             }  
  12.             Console.ReadKey();  
  13.         }  
  14.     }  
  15. }</span>  

 

         练习4：将一个整数数组的每一个元素进行如下的处理：如果元素是正数则将这个位置的元素的值加1，如果元素是负数则将这个位置的元素的值减1。       

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace 数据练习04  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //将一个整数数组的每一个元素进行如下的处理：如果元素是正数则将这个位置的元素的值加1，如果元素是负数则将这个位置的元素的值减1  
  8.   
  9.             int[] values = { 30, -5, 90, 100, 0, -9 };  
  10.             for (int i = 0; i < values.Length; i++)     //遍历数组中的每一个元素  
  11.             {  
  12.                 if (values[i] > 0)  
  13.                 {  
  14.                     values[i]++;  
  15.                 }  
  16.                 else if (values[i] < 0)  
  17.                 {  
  18.                     values[i]--;  
  19.                 }  
  20.             }  
  21.   
  22.             for (int i = 0; i < values.Length; i++)    //int i=0 ,体现了变量的作用域问题（大括号{}圈定了变量的使用范围）  
  23.             {  
  24.                 Console.WriteLine(values[i]);  
  25.             }  
  26.             Console.ReadKey();  
  27.         }  
  28.     }  
  29. }  
  30. </span>  

   

          练习5：有一个整数数组，请声明一个字符串数组，将整数数组中的每一个元素的值转换为字符串数组中。   

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace 数组练习05  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //有一个整数数组，请声明一个字符串数组，将整数数组中的每一个元素的值转换为字符串数组中。  
  8.             int[] values = {20,25,-50,9};  
  9.             string[] strs = new string[values.Length];  
  10.               
  11.             for (int i = 0; i < values.Length; i++)  
  12.             {  
  13.                 strs[i] = Convert.ToString(values[i]); //整数数组中的每一个元素的值转换为字符串数组中  
  14.             }  
  15.   
  16.             for (int i = 0; i < strs.Length; i++)     //遍历字符串数组  
  17.             {  
  18.                Console.WriteLine(strs[i]);  
  19.             }  
  20.             Console.ReadKey();  
  21.         }  
  22.     }  
  23. }  
  24. </span>  

练习5：将一个字符串数组的元素的顺序进行反转，{"3","a","8","haha"}。

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace 数组练习06  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //将一个字符串数组的元素的顺序进行反转，{"3","a","8","haha"}。  
  8.             string[]strs={"3","a","8","haha"};  
  9.             for (int i = 0; i < strs.Length / 2; i++)  //计算机中的整数运算7/2=3，因为是整除  
  10.             {  
  11.                 string temp = strs[i];  
  12.                 strs[i]=strs[strs.Length-1-i];  
  13.                 strs[strs.Length - 1- i] = temp;  
  14.                   
  15.             }  
  16.             for (int i = 0; i < strs.Length; i++)  
  17.             {  
  18.                 Console.WriteLine(strs[i]);  
  19.             }  
  20.                 Console.ReadKey();  
  21.         }  
  22.     }  
  23. }  
  24. </span>  


练习5：将一个字符串数组的元素的顺序进行反转，{"3","a","8","haha"}。

问题的关键：

         将一个字符串数组的元素的顺序进行反转，字符串的数组元素无论是奇数个还是偶数个？都是 i , length-1-i这两个位置的元素进行交换。

         字符串的数组元素是奇数个：{"3","a",“0”,"8","haha"}

         字符串的数组元素是偶数个：{"3","a","8","haha"}

          元素反转的位置： i , length-1-i

          反转的个数：length/2

          如下图：

        

 

（2）与“两个变量值交换”思路相同，都是寻求中间变量：

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace 数组练习06  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.              
  8.             //交换两个变量的值  
  9.             int i1 = 3;  
  10.             int i2 = 5;  
  11.             int i = i1;  //保存i1的值，这样不会因为i1=i2而丢失i1原先的值。  
  12.             i1 = i2;       
  13.             i2 = i;  
  14.             Console.WriteLine("i1={0},i2={1}",i1,i2);  
  15.             Console.ReadKey();  
  16.         }  
  17.     }  
  18. }  
  19. </span>  

思想：“数组的元素的顺序进行反转”和“两个变量的值的交换”解题思想是相同的，体现了复杂都是从简单中演变来的。

本文转载:CSDN博客

阅读排行

分类

归档