【4858.com】入门基础叁肆,数组基本操作

By admin in 4858.com on 2019年4月15日

 

数组:数组是1组具备同样类别的值的聚集,能够通过索引来访问数组中的元素。

】2维数组                      衡行纵列

数组:同样数据类型的积极分子组成的一组数据;

有利于管理 ;2个数组里只可以存放1个档次的值;

注:数组必须开始展览初叶化赋值后 能力应用

int 类型的数组    int [] number = {1, 3, 4, 5};

注解数组

int[] numbers;

float[] score;

string[]4858.com, names;

  所谓数组,是雷打不动的元素种类。 若将点滴个类型一样的变量的联谊命名,那么那些名号为数组名。组成数组的一1变量称为数组的份额,也号称数组的因素,有时也称之为下标变量。用于区分数组的依次要素的数字编号称为下标。

注脚数组的语法: A.数据类型 [] 数组名称; B.数据类型 [] 数组名称 =
new 数据类型[数组大小]; C.int [] arr = {壹,三,4,五,5,3,};
通过点名地方索引:arr[0]

int[,] arr = new int[2,3]{{2,3,4},{5,6,7}};            //二行  3列 
  动态伊始化

【4858.com】入门基础叁肆,数组基本操作。开首化数组:动态初叶化、静态开始化

注:在运用数组在此以前必须开始展览伊始化赋值;

一、动态开端化

类型[]数组名 = new 类型[ 数高管度]{元素1,元素2,元素3}  ;

int[] numbers  = new int[10];//int默许值:0
也正是说开首化后Int[] numbers 里面为10个0

float[] score = new float[10]; //double默认值:0.0f

string[] names  = new string[10] ;//默认值:null(空对象)

                                                    //char 默认值
‘0’

int[] number_1 = new int [3]{ 1, 二, 三 };//长度是鲜明的

int[] number_2 = new int[]{ 一, 贰, 3 };//长度不定

int[] number_2 = new int[];

int\[\] number\_2 = new int\[\]错误

注:长度必须有

string[] names_1 = new string []{“China”,”England”,”US”};

2、静态开端化

此种情况下 无法把数组定义和静态起首化值分开

int[] numbers_3 = {1,2,3,4,5,6,7,8};

string[] names_2 = { “蜀道难”, “难于上”, “青天” };

通过数组下标访问数组中的成员(数组下标从0初叶)

string  name  =  names_2[0]; 

Console.WriteLine(name);//name = 蜀道难

数首席营业官度用  .Length表示

int a = 2;

if (a < names_2.Length) {

Console.WriteLine(names_2[a]);

}

  简单的话,数组是三个器皿,存款和储蓄同样档次的数码,并且体量是固定的。上边咱们来总结收10一下数组的为主内容。

多维数组:五个线性数组的值   .GetLength()         1维:int [] arr =
new int[2];  二维:int [,] arr = new int[3,5];  三维:int [,,]
arr = new int[2,4,5];
多维数组使用GetLength获取长度,维数同样是从0早先。

int[,] arr_1 = new int[,]{{1,3},{4,5},{6,7}};          //3行 
2列

注:

一、防止下标越界,系统不会自动物检疫查测试数组下标越界,编制程序时务必保障不会越界

二、数组是贰个完完全全,只好对数组里面包车型客车单个元素进行处理,数组中的成分对应数组的数据类型

三、四个数据类型的同样的数组能够并行赋值
 ,并且五个数据的地点将会化为同样的(数组属于引用类型)

      经常状态用到数组都会用到循环

数组的蕴藏格局;

驰骋数组:“数组中数组”。()  .Length 申明语法:int [][] arr = new
int[2][];//arr包涵三个要素    int [0] = new
int[2];//第一个因素是多个整数的数组    int [1] = new
int[3];//第二个因素是两个整数的数组 赋值:arr[0][0] = 十0;
与多维数组绝相比较,交错数组具备更加好的性质。

int[,] arr_2 = {{12,34,45},{32,16,25} };             //2行  三列    
静态初叶化
                 

数组的遍历(全部打字与印刷)

for(int i = 0; i < numbers_3.Length – 1;++i){

Console.WriteLine (numbers_3 [i]);

}

修改数组成员(元素)

直接把数组中的成分表示出来

numbers_3[5]= 7;//将第5个改成7;

在2、10进制转变中用到

例:反向打字与印刷数组全数成员

Array是数组的意思;

int[] intArray = { 1, 12, 34, 2, 5, 6 };

for(int i =  intArray.Length – 1; i >= 0;–i){

Console.WriteLine (“{0}”, intArray [i]);

}

例:求数组中有着因素的和

int sum = 0;

for (int i =0;i < intArray.Length;++i){

sum += intArray [i];

}

Console.WriteLine (“{0}”, sum);

}

//数组属于1种引用类型,假使将数组名
B赋给数组A,那么数组B在操作数组成分时,实质上操作的要么数组A

// int []intArr = {1,2,3,45,5,16};

// int sum = 0;

// int max = 0, min = intArr [0];

// for (int i =intArr.Length – 1 ; i >= 0; i–) {

// Console.Write (intArr [i]);

// sum += intArr[i];

// max = max > intArr [i] ? max : intArr [i];

// min = min > intArr [i] ? intArr [i] : min;

//        }

// Console.WriteLine (sum+”  “+max+ ”  “+min);

//将三个数组对应相加

  用贰个新数组来选择

// int a = 5;

// int[] arr_1 = { 1, 2, 15, 41, 33 };

// int[] arr_2 = new int []{ 3, 5, 56, 7, 8 };

// int[] arr_3 = new int[arr_1.Length];

//

// for (int i = 0; i < arr_1.Length; ++i) {

// arr_3 [i] = arr_1 [i] + arr_2 [i];

// }

  全部的数组都以由三番五次的内部存款和储蓄器地方组成的。最低的地点对应率先个因素,最高的地方对应最终贰个要素。

System.Array数组: 注脚语法:Array arr =
Array.CreateInstance(typeof(int),三);//类型为int,长度为三

for (int i = 0; i < 2; i++) {                                  
 //行数

作业

A:

1、注脚八个长度为5的int类型的数组,将八个数组的呼应成分相加,放到另1个数组中;

int[] a = new int[5]{1,2,3,4,5};

int[] b = new int[5]{5,5,5,5,5,};

for(int i = 0;i<5;++i){

int[] sum = new int[5];

sum [i] = a[i] + b [i];

Console.WriteLine (“{0}”, sum[i]);

}

贰、声美赞臣个尺寸为8的int类型数组,求出其下标为奇数的富有因素的和

int [] number_1 = new int[8]{1,2,3,4,5,6,7,8};

int i = 0;

int sum = 0;

for (; i < number_1.Length ; ++i) {

if (i % 2 != 0) {

sum += number_1 [i];

Console.WriteLine (“{0}”,number_1 [i] );

}

}Console.WriteLine (“{0}”, sum);

B:

三、在命令行输入八个学生战绩存入数组,求出九个中最高的大成;

int[] a = new int[8];

Console.WriteLine(“请输入战绩”);

for (int i = 0; i < a.Length ; ++i) {

a [i] = int.Parse (Console.ReadLine ());

if (a [0] < a [i]) {

a [0] = a [i];

}

}

Console.WriteLine(“{0}”,a[0]);

  4858.com 1

typeof关键字用于数据类型。

 Using  System.Collections 集合:使用count获取集合长度。
Hashtable集合:语法:Hashtable name = new Hashtable(); 例:Hashtable hs =
new Hashtable();             //增多             hs.Add(4,”张三”);
            hs.Add(陆,”李肆”);             hs.Add(7,”王伍”);            
//hs.Remove(四);//删除            
//Console.WriteLine(hs.Count);//获取集合长度            
Console.WriteLine(hs[“Key”]);//获取key值            
Console.WriteLine(hs[“Values”]);//获取values值     
//foreach遍历数组Values值             foreach(object lan in hs.Values )
            {                 Console.WriteLine(lan.ToString());
            }

ArrayList集合:语法:ArrayList name = new ArrayList(); 例: ArrayList al
= new ArrayList();      //添卢比素             al.Add(1二);            
al.Add(“蓝天”);             al.Add(三.1四);            
al.RemoveAt(0);//移除数组列表中钦命的目录地点的成分            
al.Insert(0,”O(∩_∩)O哈哈~”);//插入数组列表中钦点的目录地方     
Remove:移除成分。TrimToSize:将容积设置为ArrayList霜月素的骨子里数据
            for (int i = 0; i < al.Count;i++ )             {
                Console.WriteLine(al[i]);//循环输出全体因素
            }

==============================================================================
数组与聚集的分别:

  数组         集合     使用length获取长度         
    使用count获取长度       固定的长度         
   非固定长度,可增可删(object)
差别 数据类型固定(申请什么品种就得抬高什么类型的值)  object类型(任意加多任何类型)
     直接赋值          使用Add加多               
for                                                      foreach
             system下                                                

            for (int j = 0; j < 3; j++) {                        
//列数

 

collection下

hashtable与Arraylist的分化:
hashtable键值映射,轻巧说键对应值,大家认给每值都起名字,键所谓名字,我们通过名字来寻觅值,而arraylist集合,线性结构存款和储蓄数据,集合存款和储蓄内容都值,并且大家给每值用索引做编号,所遍历进程大家用索引;

arraylist有序,而hashtable无序;

arraylist可在一定岗位增多、删除成分,而hashtable只可以挨个增加。

                       Console.Write(“{0} “,arr[i,j]);

一维数组:

arraylist  索引为0      hashtable   object(自定义)

嵌套循环:外层循环用来支配输出的行数,内层循环用来支配输出的列数。

//99乘法表             for(int i = 0;i <= 9;i++)             {
                for (int j = 0; j < i;j++ )                 {
                    Console.WriteLine((j+1)+”*”+i+”=”+(i*(j+1))+” “);
                }                 Console.WriteLine(“\n”);            
}

冒泡排序:数组成分的排序。 (一种算法)

两层循环嵌套:外层循环  N-一   内层循环  N-一-i  (N
代表数组或集合的尺寸)

例: //冒泡排序             int[] arrl = {3,六,二,七,玖,1贰,4 };//申请数组
            int temp;//定义全局变量             for(int i = 0;i <
arrl.Length-①;i++)//调控相比的趟数,这一个轮回一次代表相比较了一趟
            {                 for (int w = 0; w < arrl.Length – i –
一; w++)                 {                     if(arrl[w] <
arrl[w+1])                     {                         temp =
arrl[w];                         arrl[w] = arrl[w+1];
                        arrl[w+1] = temp;                     }
                }             }             foreach(int wy in
arrl)//遍历输出排序之后的数组             {                
Console.WriteLine(wy);             }

==============================================================================

谬误调节和测试: try{//抛出相当      //程序代码; }catch(Exception
e){//捕获并处理万分.假若有多少个catch块,父类(Exception)必须在前边     
//非凡处理代码;     
Console.WriteLine(e.Message);//展现描述失实处境的文件     
Console.WriteLine(e.Source);//呈现导致格外爆发的应用程序或对象的称呼
    
Console.WriteLine(e.StackTrace);//提供在库房中所调用方法的详细消息,并率先近日调用的章程。
     Console.WriteLine(e.InnerException);//提供对中间卓殊的拜会。

} finally{//最终处理 }

黑盒测试:不管代码是何等,只要成效可以达成正是马到功成。
白盒测试:与黑盒相反。

              }

  

Console.WriteLine ();                                       //换行

申明数组

  datatype[] arrayName;

注:datatype定义存款和储蓄的数据类型,[]意味着数组的维数,arrayName
数组名;

例如:

 

1  int[] arr;

 

 

}

伊始化数组

  直接定义三个已知成分值的数组

  类型[]
arr={成分1,元素2,成分叁,…};这种格式唯有在成立数组时才方可用

  定义三个已知长度的数组;

  类型[] arr=new
类型[长度];

  定义1个已知长度已知多少的数组

  类型[] arr=new
类型[长度]{成分一,元素二,成分三,…}; 就算尚未定义长度,但通过前面包车型地铁要素也得以鲜明数组的尺寸   类型[] arr=new
类型[]{元素1,元素2,元素3,…};

注:

  1. 要素正是数组中储存的数量;
  2. 长度便是数组中可存款和储蓄的成分个数

 

例如:

  

1 int[] arr={1,2,3};//数组总共存储了3个元素
2 int[] brr=new int[4];//数组存储了4个0
3 bool[] crr=new bool[3];//数组中存储了3个false

 

 

二维数组中,第n个元素对应的值为

走访数组中的成分

  arrayname[下标]

注:下标是数组中的索引,编号,第一个要素的下标是0,第叁个是

  一,依次类推,最终3个尺寸-一;

例如:

  

1 int[] arr={1,3,5};
2 //访问第二个元素
3 Console.WriteLine(arr[1]);

>>结果:3

 

int [a,b];

修改钦定下标的值

  arrayname[下标]=值;

注:通过赋值符号=,可以给数组钦赐的下标重新赋值,但数据足以去除或增加新因素,因为是固定长度;

例如:

  int[] arr={1,3,5,7}; arr[0]=2; Console.WriteLine(arr[0]);

>>结果:二;//数组第一个下标的要素发生改造了

  访问数组的长度arrayname.Length;

例如:

int[] arr={1,3,5,4};
Console.WriteLine(arr.Length);

>>结果:4

留意:未有增加和删除的不二等秘书技

多维数组

i = (n-1)/b;

C# 支持多维数组。多维数组又称之为矩形数组。

宣示数组

  声多美滋(Dumex)个2维数组,如下:
类型[,] 数组名;

  声美素佳儿(Friso)个三维数组,如下:
类型[,,] 数组名;

j = (n-1)%b;

2维数组

多维数组最简便的样式是二维数组。一个2维数组,在本质上,是三个一维数组的列表。

二个2维数组能够被感到是1个带有 x
行和 y 列的报表。下边是三个二维数组a,包括 三 行和 四 列:

  4858.com 2

 

由此访问2维数组的因素:a[行下标,列下标];

开端化2维数组:

两行3列  =>  三行两列

int[,] arr=new int[行数,列数];

int[,] arr={{元素,元素},{元素,元素},{元素,元素}}

int[,] arr=new int[,]{{},{},{}};

 

访问2维数组的因素:

数组名[行下标,列下标]

例如:

1 arr[2,3]

 

 

点名下标赋值:

数组名[行下标,列下标]=新值;

例如:arr[2,3]=2000;

 

访问数组的尺寸:

new 类型[行数,列数]

  1. 行数:数组名.GetLength(0);
  2. 列数
    :数组名.GetLength(1);
  3. 总的成分个数:数组名.Length

//多维数组:二维数组,矩形数组bool[,] crr=new bool[3,4];

//行数,2维数组的行数

Console.WriteLine(“行数:”+crr.GetLength(0));

//列数,2维数组的列数

Console.WriteLine(“列数:”+crr.GetLength(1));

//重临2维数组中的总成分个数: Console.WriteLine(crr.Length);

 

int[,] arr = new int[2,3]{{2,3,4},{5,6,7}};

驰骋数组

驰骋数组是数组的数组,3个一维数组中得以储存多少个例外交市长短的一维数组从而造成了交错数组的贰维数组;

宣示数组

你可以声雀巢个含有 int
值的交错数组 scores,如下所示:

1 int [][] scores;

扬言数组不占内部存款和储蓄器,创设下面的数组:

1 int[][] scores = new int[5][];
2 for (int i = 0; i < scores.Length; i++)
3 {
4 scores[i] = new int[4];
5 }

 

起头化数组

你能够初步化三个参差不齐数组,如下所示:

1 int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

 

当中,scores
是贰个由五个整型数组组成的数组 — scores[0] 是四个涵盖 二个整数的数组,scores[1] 是3个含有 四 个整数的数组。

 

巡回遍历交错数组

如下所示:

1 for(int i=0;i<scores.Length;i++){//循环外维的长度
2     for(int j=0;j<scores[i].Length;j++){//循环内维的长度
3         Console.WriteLine(scores[i][j]);
4     }
5 }

 

 

int[,] arr_1 = new int[3,2];

数组总结:

int[] 是一维数组,1组同样档次的数量的联谊;

int[,] 是多维二维数组,它就是古板意义上 n
x m 的表;

int[][] 是交错数组2维数组,为不定数组,它实际是叁个int[] 里嵌套着int[],能够清楚为 (int[])[]。

正如图所示:

4858.com 3

 

for (int i = 0; i < 2; i++) {

            for (int j = 0; j < 3; j++) {

                       arr_1[j,i] = arr[i,j];                   
//行列沟通

             }

}

for (int a = 0; a < 3; a++) {                            
//遍历数组 打印

            for (int b = 0; b < 2; b++) {

                        Console.Write(“{0} “,arr_1[a,b]);

              }

Console.WriteLine ();

}

//求最大因素及所在行和列

int[,] arr_1 = new int[,]{{1,3,5,6},{5,6,4,5},{6,7,5,8}};

//记录最大值及大街小巷的下标

int max = arr_1 [0, 0], x=0, y=0;

for (int i = 0; i < 3; i++) {

            for (int j = 0; j < 4; j++) {

                        if (max <arr_1[i,j]){

                            max = arr_[i,j];

                            x=i;                                  
 //鲜明下标

                            y=j;

              }

       }

}

Console.WriteLine (“max= “+max+”x= “+x+”y= “+y);

对角线成分和

int sum = 0;

int[,] arr = new int[3, 3]{{1,2,3},{4,5,6},{7,8,9} };

for (int i = 0; i < 3; i++) {

            for (int j = 0; j < 3; j++) {

                       if (i == j) {

                            sum += arr[i,j];

                        }

             }

}

Console.WriteLine (“{0}”,sum);

驰骋数组

类型 [ ] [ ] 数组名 = new 类型 [数高管度][ ];

例如    int [ ] [ ] arr  = new int[3][ ];

int[ ] arr_1 = {1,3,5 };

int[ ] arr_2 = {2,4 };

int[ ] arr_3 = {23,45,12,34 };

int [ ][ ] arr = new int[3][ ]{arr_1,arr_2,arr_3};

arr [0] = new int[ ]{27,23,56 };                            
//修改下标为0的成分

arr [1] = arr_3;                                                    
 //使下标为壹的要素等于arr_3的元素

//遍历数组

for (int i = 0; i < arr.Length; i++) {

            for (int j = 0; j < arr[i].Length; j++) {

                       Console.Write (“{0} “,arr[i][j]);

              }

Console.WriteLine();

}

foreach遍历数组

int[ ] arr = {1,2,5,6,8,7};

int sum = 1;

foreach (var a in arr) {                       //a无法拓展退换

               sum *= a;

}

Console.WriteLine (“{0}”,sum);

string str = “Hello,lanou!”;

char[ ] chars = str.ToCharArray();                                  
//获得字符串的字符数组

//char[ ] chars_1 = “Hello,lanou!”.ToCharArray();

int sum = 0;

for (int i = 0; i < chars.Length; i++) {

            if (chars[i] ==’l’) {

                 ++sum

          }

}

Console.WriteLine (“{0}”,sum);

string str = “Hello,lanou!”;

char[ ] chars = str.ToCharArray();

// char[ ] chars_1 = “Hello,lanou!”.ToCharArray();

int sum = 0;

foreach (var ch in chars) {

               if (ch == ‘l’) {

                    ++sum;

}

Console.WriteLine (“{0}”,sum);

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有