表示方法
编辑 播报
数组元素是组成数组的基本单元。数组元素也是一种变量， 其标识方法为数组名后跟一个下标。下标表示了元素在数组中的顺序号。数组元素的一般形式为：数组名[下标] 其中的下标只能为整型常量或整型表达式。如为小数时，C编译将自动取整。例如，a[5],a[i+j],a[i++]都是合法的数组元素。数组元素通常也称为下标变量。必须先定义数组， 才能使用下标变量。在C语言中只能逐个地使用下标变量， 而不能一次引用整个数组。
赋值方法
编辑 播报
初始化赋值的一般形式为：static类型说明符数组名[常量表达式]={值，值……值}； 其中static表示是静态存储类型， C语言规定只有静态存储数组和外部存储数组才可作初始化赋值（有关静态存储，外部存储的概念在第五章中介绍）。
在{ }中的各数据值即为各元素的初值， 各值之间用逗号间隔。例如：static int a[10]={ 0,1,2,3,4,5,6,7,8,9 }; 相当于a[0]=0;a[1]=1...a[9]=9;
使用规则
编辑 播报
1.数组的类型实际上是指数组元素的取值类型。对于同一个数组，其所有元素的数据类型都是相同的。
2.数组名的书写规则应符合标识符的书写规定。
3.数组名不能与其它变量名相同。
1.可以只给部分元素赋初值。当{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：static int a[10]={0,1,2,3,4};表示只给a[0]～a[4]5个元素赋值，而后5个元素自动赋0值。
2.只能给元素逐个赋值，不能给数组整体赋值。例如给十个元素全部赋1值，只能写为：static int a[10]={1,1,1,1,1,1,1,1,1,1};而不能写为：static int a[10]=1；（请注意：在C、C#语言中是这样，但并非在所有涉及数组的地方都这样，数据库是从1开始。）
3.若不给可初始化的数组赋初值，则全部元素均为0值。
4.假如给全部元素赋值，则在数组说明中， 可以不给出数组元素的个数。例如：static int a[5]={1,2,3,4,5};可写为：static int a[]={1,2,3,4,5};动态赋值可以在程序执行过程中，对数组作动态赋值。这时可用循环语句配合scanf函数逐个对数组元素赋值
数组是相同数据类型的一组数据的集合数组分为一维数组和二维数组
数组是一个固定长度的存储相同数据类型的数据结构，数组中的元素被存储在一段连续的内存空间中。它是最简单的数据结构之一，大多数现代编程语言都内置数组支持。
//声明数组 int arr[]; String str[]; long ser[];
//数组名称 =new 数组元素类型[shuzuyuansugeshu] arr =new int [10]; //数组元素类型 数组名 =new 数组元素类型[shuzuyuansugeshu] int month[] =new int [20]; //初始化的数组 1 int arrt [] =new int []{12,34,56,78,94}; //初始化的数组 2 int arrt2[] ={5645,645,147,89};
int num [] =new int []{7,89,7455,551,1522,21559,4222,2225,5441, 7,89,7455,551,1522,21559,4222,2225,5441,2111}; for (int k= 0; k < num.length; k++) { System.out.print(+k); } //Eng3 int numt[] =new int []{7,89,7455,551,1522,21559,4222,2225,5441, 7,89,7455,551,1522,21559,4222,2225,5441,2111}; for(int h=0;h<=18;h++){ System.out.print(h); }
package 数组; import java.util.Arrays; /** * 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们 * @author MZFAITHDREAM * */ public class DemoTest1 { public static void main(String[] args) { //变量的类型 变量的名字 = 变量的值 //数组类型 int[] nums; //1.定义:声明数组 int nums2[];//声明数组的第二种方式 // 数组的定义与声明 nums = new int[10]; //2.创建 //给数组赋值 nums[0] = 1; nums[1] = 2; nums[2] = 3; nums[3] = 4; nums[4] = 5; nums[5] = 6; nums[6] = 7; nums[7] = 8; nums[8] = 9; nums[9] = 10; // 数组的初始化 int[] a={1,2,3,5,6};//初始化数组a System.out.println("数组初始化一"); System.out.println(Arrays.toString(a)); // 数组初始化二 int[] b = new int[10]; b[0] = 10;//动态初始化数组b System.out.println("数组初始化二"); System.out.println(Arrays.toString(b)); //下标合法区间：[0,length-1]，如果越界就会报错 int[] c=new int[2]; System.out.println(c); //计算所有元素的和 int sum = 0; for (int i = 0; i < nums.length; i++) {//nums,length为数组长度 sum+=nums[i];//通过i索引 } System.out.println("总和为"+sum);//打印结果 // 数组具体的使用 forrach int[] arrays = {1,2,3,4,5};//创建一个数组 //没有下标,增强for循环，注意：这里无法修改数组里面内容 for (int array : arrays) { System.out.println("利用增强for循环"); System.out.println(array); } // 方案二 System.out.println("方案三打印数组"); for (int i : arrays) { System.out.print(i); } } }
// 数组的初始化 int[] a={1,2,3,5,6};//初始化数组a System.out.println("数组初始化一"); System.out.println(Arrays.toString(a));
package 数组; import java.util.Arrays; public class DemoTest2 { public static void main(String[] args) { int[] arrays = {1,2,3,4,5}; //打印全部数组元素 for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]); } System.out.println(Arrays.toString(arrays)); //计算所有元素的和 int sum =0; for (int i = 0; i < arrays.length; i++) { sum +=arrays[i]; } System.out.println("sum="+sum); //查找最大元素 int max =arrays[0]; int min=arrays[0]; for (int i = 0; i <arrays.length ; i++) { if(arrays[i]>max){ max = arrays[i]; } else if(arrays[i]<min){ min = arrays[i]; } } System.out.println("max="+max); System.out.println("min"+min); System.out.println("平均值"+sum/5); print(arrays); // 下标地址 System.out.println(arrays); System.out.println(Arrays.toString(arrays)); } // 数组作方法入参 public static void print(int[] a){ for (int i = 0; i < a.length; i++) { System.out.print(a[i]+" "); } System.out.println(); } }
package 数组; /** * 数组的反转 * @author MZFAITHDREAM * */ public class DemoTest3 { public static void main(String[] args) { int[] arrays = {1,2,3,4,5}; arrays = reverse(arrays); for (int array : arrays) { System.out.println(array); } } //反转数组方法 public static int[] reverse(int[] a){ int[] result = new int[a.length];//返回结果的数组 for (int i = 0,j=0; i < a.length; i++,j++) { result[j] = a[a.length-1-i]; } return result; } }
package 数组; /** * 多维数组可以看成数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。 * @author MZFAITHDREAM * */ public class DemoTest4 { public static void main(String[] args) { //创建一个二维数组 int[][] array ={{1,2},{2,3},{3,4},{4,5}}; //打印二维数组 for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++) { //根据定义可知，二维数组每一个元素都是一个一维数组，所以这里用array[i].length来表示长度 System.out.print(array[i][j]); } } } }
package 数组; import java.util.Arrays; /** * 冒泡排序 * @author MZFAITHDREAM * */ /** * 1. 相邻两个数两两相比，n[i]跟n[j+1]比，如果n[i]>n[j+1]，则将连个数进行交换， 2. j++, 重复以上步骤，第一趟结束后，最大数就会被确定在最后一位，这就是冒泡排序又称大（小）数沉底， 3. i++,重复以上步骤，直到i=n-1结束，排序完成。 * @param args */ public class DemoTest5 { /** * 当你学了算法又是这么简单 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int[] n = new int[]{100,55,66,77,88}; // 定义一个空的值 int temp; for (int i = 0; i < n.length-1; i++) { for (int j = 0; j <n.length-1; j++) { if(n[j]>n[j+1]){ temp = n[j]; n[j] = n[j+1]; n[j+1] = temp; } } } System.out.println("冒泡排序的思想是两个两个比较大的在后面小的在前面"); System.out.println(Arrays.toString(n)); } }
package 数组; //稀疏数组案例 public class DemoTest6 { public static void main(String[] args) { //创建一个案例中的数组 int[][] array1 = new int[6][7]; //赋值有效值 array1[0][3] = 22; array1[0][6] = 15; array1[1][1] = 11; array1[1][5] = 17; array1[2][3] = -6; array1[3][5] = 39; array1[4][0] = 91; array1[5][2] = 28; //打印案例数组 for (int[] ints : array1) { for (int anInt : ints) { System.out.print(anInt+"\t"); } System.out.println();//换行 } //获取稀疏数组 int[][] array2 = sparse(array1); System.out.println("====================");//分割线 //打印稀疏数组 System.out.println("打印稀疏数组:"); for (int[] ints : array2) { for (int anInt : ints) { System.out.print(anInt+"\t"); } System.out.println();//换行 } //稀疏数组还原 System.out.println("==================");//分割线 int[][] array3 = recovery(array2); //打印还原的数组 System.out.println("打印还原的数组"); for (int[] ints : array3) { for (int anInt : ints) { System.out.print(anInt+"\t"); } System.out.println();//换行 } } //稀疏数组转换 public static int[][] sparse(int[][] array){ //获取数组中有效值个数 int sum = 0; for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++) { if(array[i][j]!=0){ sum++; } } } System.out.println("有效值个数："+sum); //创建稀疏数组 int[][] Sarray = new int[sum+1][3];//因为稀疏数组只有行列值三列，所以后面是3，行为有效个数+1 //给稀疏数组赋值 Sarray[0][0] = array.length; Sarray[0][1] = array[0].length; Sarray[0][2] = sum; int count = 0; //计数 for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++) { if(array[i][j]!=0){ count++; Sarray[count][0] = i; Sarray[count][1] = j; Sarray[count][2] = array[i][j]; } } } //返回稀疏数组 return Sarray; } //稀疏数组还原 public static int[][] recovery(int[][] Sarray){ //创建还原后的数组 int[][] array = new int[Sarray[0][0]][Sarray[0][1]]; //赋值阶段 for (int i = 0; i < Sarray.length-1; i++) { int x = Sarray[i+1][0];//行 int y = Sarray[i+1][1];//列 array[x][y] = Sarray[i+1][2];//值 } return array;//返回 } }
感兴趣的可以去下面的文章上了解十大排序有关算法的十种思想
《十大排序算法》让你的思维流动起来。今天的主角又是排序思想你了解多少。每种算法的内容在代码中体现出来。_风雪夜花的博客-CSDN博客
