Java一维数组与二维数组的定义与应用

 

数组

定义：数组是一个存储多个相同类型元素的容器。

一维数组

数组的定义格式：

                              数据类型 [ ]数组名称；

                              数组类型 数组名称 [ ];

举例：
      
                  int []arr;      //定义了一个int类型的数组，数组名是arr
                  int arr[];      //定义了一个int类型arr数组

数组的初始化：

                      动态初始化：具体数组中的元素值，由系统默认给定，数组长度由开发者定义。

                                         数据类型[ ]数组名称 = new 数据类型[ 数组长度]；

                                         数据类型 数组名称[ ] = new 数据类型[ 数组长度 ]；

例：
   

                     int[]arr = new int[3]  //定义了一个int类型的数组，数组名称是arr长度为3；

静态初始化：

                     数组的具体的元素值开发者给定，长度系统默认给定。

                     获取数组中的元素值：通过数组名称[角标]，角标从0开始。

格式：         

                               数据类型[ ]数组名 = new 数据类型[ ]{元素1，元素2,........};

变形格式：

                              数据类型 数组名[ ] = new 数据类型[ ]{元素1，元素2，........};

简写格式：

                              数据类型[ ]数组名称 = {元素1，元素2，元素3，.........};

数组的遍历：就是将数组中的元素一 一输出出来。

class ArrayTest{
	public static void main(String[]args){
		int arr[]= {1,2,3,4,5};             //定义了一个int类型数组 给数组赋值；
		for(int x=0;x<arr.length;x++){      //遍历数组；arr.length代表数组长度
			System.out.print(arr[x]+" ");   //输出结果
		}
	}
}

运行结果：

              

数组中的最值问题：

需求：给定一个数组，获取数组中的最大值或者最小值。

 

class ArrayTest{
	public static void main(String[]args){
		int arr[]={1,2,3,4,5};           //顶一一个一维数组；
		int max = maxArray(arr);         //赋值调用，将数组的最大值赋值给max；
		System.out.println("最大值为："+max);    //输出最大值。
	}
	public static int maxArray(int arr[]){       //定义一个获取最大的方法。
		int max = arr[0];                        //假定最大值是0角标的元素。
		for(int x=0;x<arr.length;x++){           //遍历
			if(arr[x]>max){                      //判断 x是否大于最大数
				max = arr[x];                    //将x定位为最大值
			}
		}
		return max;                               //返回最大值。
	}
}

最小值方法是一样的，只需要吧最大值改为最小值，判断语句里大于号改为·小于号即可。

需求：自定义一个数组求他们元素之和。

class ArraTest{
	public static void main(String[]args){
		int arr[]={1,2,3,4,5};                  //定义一个一维数组；
		int sum = addArray(arr);                //将数组赋值个sum 然后输出sum
		System.out.println("数组和为："+sum);
	}
	public static int addArray(int arr[]){   //定义一个求数组和的方法。
		int sum=0;                           //定义一个sum
		for(int x=0;x<arr.length;x++){       //遍历
			sum += arr[x];                   //元素依次相加
		}
		return sum;                          //返回sum
	}
}

数组的逆序：

需求：有一个数组： int [ ]arr={1,2,3,4,5};

特点： 将0索引对应的元素和arr.length-1索引对应的元素进行互换；

             将1索引对应的元素和arr.length-1-1索引对应的元素进行互换；

               依次往下执行；

class ArrayTest{
	public static void main(String[]args){
		int arr[]={1,2,3,4,5};
		huNiArray(arr);
	}
	public static void huNiArray(int arr[]){
		for(int start=0,end=arr.length-1;start<=end;start++,end--){   //遍历
			int temp = arr[start];                                 //定义第三变量，互换位置。
			arr[start]=arr[end];
			arr[end]= temp;
		}
		for(int x=0;x<arr.length;x++){                             //再次遍历
			System.out.print(arr[x]+" ");                         //输出遍历后的数组。
		}
	}
}

运行结果;

class ArrayTest{
	public static void main(String[]args){
	int arr[]={1,2,3,4,5};
	int index = printArray(arr,4);                    //将数组的值赋给index(索引)求索引值
	System.out.println("索引值是："+index);
	}
	public static int printArray(int arr[],int value){    //定义value  需要输入的数
	for(int x=0;x<arr.length;x++){                         //遍历
		if(arr[x]==value){                                   //判断如果相等输出
			System.out.print(arr[x]);
		}
	}
	return -1;                                                //没有的话输出-1
	}
}

冒泡排序的代码实现

思路：两个两个比较，大的值往后放，第一次比较完之后，最大值出现，在最大索引处，依次这样比较，可以得到一个排好序的数组。

代码体现：

class ArrayTest{
	public static void main(String[]args){
		int arr[]={4,5,3,1,2};
		maoPaoArray(arr);
	}
	public static void maoPaoArray(int arr[]){
		for(int x=0;x<arr.length-1;x++){
			for(int y=0;y<arr.length-1-x;y++){
				if( arr[y]>arr[y+1]){
					int temp =arr[y];
				    arr[y]=arr[y+1];
					arr[y+1]=temp;
					
				}
			}
		}
			for(int x=0;x<arr.length;x++){
			System.out.print(arr[x]);

		}
	}

}

运行结果：

二维数组的定义及使用

定义：二维数组由多个一维数组组成的数组。

格式：

                数据类型[ ][ ]数据名称；

                数据类型[ ]数组名称[ ]；

初始化分为两种：

①动态初始化：   

                                        数据类型[ ][ ]数组名称=new数据类型[m][n]；

解释：等号左边 

int[ ][ ]:定义了一个int类型的二维数组。

arr:数组的名称。

等号右边：

new:在堆内存中开辟空间。

[m]:当前二维数组中有m个一维数组。

[n]:每一个一维数组有n个元素。

格式二：

                           数据类型[ ][ ]数组名称=new数据类型[m][ ];

          m表示一维数组的长度，这种一维数组中的具体元素动态给定。

②静态初始化;

                        数据类型[ ][ ]数组名=new 数据类型[ ] [ ]{元素},{元素},{元素}；

   简化版格式：

                        数据类型[ ][ ]={元素1...},{元素1.....},{元素1.....};

二维数组的遍历：

class ArrayTest{
	public static void main(String[]args){
		int arr[][]={{1,2,3},{4,5,6},{7,8,9}};
		twoArray(arr);
	}
	public static void twoArray(int arr[][]){
		for(int x=0;x<arr.length;x++){              //二维数组的遍历
			for(int y=0;y<arr[x].length;y++){       //二维数组中一维数组的遍历。
				System.out.print(arr[x][y]+" ");
			}
		}
	}
}

运行结果：