便捷的存储容器--数组

2016.08.03

 

上课内容：数组

 

       首先，什么是数组？

数组是具有相同数据类型的一组数据的组合。列如：球类的集合——足球，羽毛球，网球。电器的集合——电视，电脑，洗衣机。数组中的每个数据具有相同的数据类型。

 

       然后，数组是基本数据类型还是引用数据类型？

基本数据类型有byte int short char long boolean float double 八种基本数据类型

故数组是引用类型

数组有什么方法和属性？

属性：长度，方法：全部继承Object

 

       另外，数组是具有连续的线性数据结构，数组的长度一旦定义就无法更改，列如要是我们开辟了一个长度为10的数组array，当我们引用array[10]时，就会报错说数组溢出，即出现ArrayIndexOutOfBoundsException(数据越界)

 

       数组的应用很广泛，一般来说数组使用来存储数据，也可以利用数组来来对数据进行排序。 数组可以存储的数据类型有很多比如说图片、旦整数、字符串等，虽然可以存很多的数据类型，但是 每一个数组都只能存同一个数据类型的数据。这就像是商店里买的饼干一样，饼干盒里装的只能是 饼干，不可能给你装个苹果或桔子，这是生产商定以好的，不能更改的。数组也是这样的一你定 义好了数据类型就不能在传别的数据类型的数据进去，否则会报错。

 

        数组的定义

        一维数组：数据类型 [] 数组名 = new 数据类型[长度];  这种方式定义的数组，只有数据类型的默认值

       int [] array = new int [10];

 

       数据类型 [] 数组名 = {数据,...};

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

 

       数据类型 [] 数组名 = new 数据类型[]{数据,...};

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

 

       数据类型 [] 数组名;

       int [] array;

 

       数组名 = new 数据类型[]{数据,...};

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

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

 

       二维数组：

数据类型 [][] 数组名 = new 数据类型[行][列];  这种方式定义的数组，只有数据类型的默认值

               int [][]array = new int [][];

数据类型 [][] 数组名 = {{数据,...},...};

int [][] array = {{1,2,3,},{2,3,4}};

数据类型 [][] 数组名 = new 数据类型[][]{{数据,...},...};

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

数据类型 [][] 数组名;

int array [][] array;

数组名 = new 数据类型[][]{{数据,...},...};

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

数组名 = new 数据类型[行][列];

       数组的使用，要想知道数组中能存储多少个元素，数组名.length  length是数组唯一的一个属性，用来获取数组能存储多少元素的属性。

       如果想给数组的某一个位置的赋值，则使用 数组名[下标] = 值;

       如果要想获取某个位置的值，则使用 数据类型  变量名 = 数组名[下标];

       二维数组的使用：

       想知道二维数组中能存储多少个元素：

       使用行数和列数的方式定义的数组：数组名.length ,数组名[行下标].length  

       使用值定义的数组： 数组名[行下标].length+......获取二维数组中的总行数：数组名.length

       获取二维数组中某一行的总列数：数组名[行下标].length

       想给数组某一个位置赋值：数组名[行下标][列下标] = 值;

       获取某一个位置的值：数据类型  变量名 = 数组名[行下标][列下标]; 

练习

1.对一位数组排序

//冒泡法
public class MaoPaoSort{
	public static void main(String[] args){
		int array[] = {87,23,9,10,23,45,109};//定义一组数组
		maopaoSort(array);
	}

	private static void maopaoSort(int[] array) {
		int temp = 0;//定义已给临时变量
		for(int i=0;i<array.length;i++){
			for(int j=0;j<array.length-i-1;j++){
				if(array[j]<array[j+1]){
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		maopaoPrint(array);
	}

	private static void maopaoPrint(int[] before) {
	     for(int k=0;k<before.length;k++){
	    	 System.out.print(before[k]+" ");
	     }
	}
}

 

//插入排序法
public class InsertSort {

	public static void main(String[] args) {
     
		int[] arr = {4,6,13,67,2,89,24,16};//定义数组
		doInsertSort(arr);
	}

	private static void doInsertSort(int[] scr) {
		int len = scr.length;//获取数组的长度
		for(int i=1;i<len;i++){//遍历数组，从1开始
			int j;             //定义变量j
			int temp = scr[i];//临时存储当前的数字
			for(j=i;j>0;j--){//遍历1之前的数字
				if(scr[j-1]>temp){
					scr[j]=scr[j-1];
				}else
					break;
			}
			scr[j] = temp;//把空缺位置赋值为原有的值
		}
		print(scr);
	}

	private static void print(int[] before) {
		for(int i=0;i<before.length;i++){//遍历
			System.out.print(before[i]+" ");//打印，以空格隔开
		}
		System.out.println();//换行
	}
}

 

//直接选择排序
public class SelectSort {
     public static void main(String[] args){
    	int array[] = {89,23,45,18,60,108}; 
    	//创建数组排序类的对象
    	SelectSort ss = new SelectSort();
    	ss.sort(array);
     }
    /*
     * 直接选择排序法
     */
	private void sort(int[] array) {
		int index;
		for(int i=1;i<array.length;i++){
			index = 0;
			for(int j=1;j<=array.length-i;j++){
				if(array[j]>array[index]){
					index = j;
				}
			}
			//交换在位置array.length-i和index(最大值)上的两个值
			int temp = array[array.length-i]; //把第一个元素值保存到临时变量中
			array[array.length-i] = array[index];//把第二个元素值保存到第一个元素单元中
			array[index] = temp;//把临时变量也就是第一个元素原值保存到第二个元素中
		}
		PrintArray(array);
	}
	/*
	 * 显示数组中的所有元素
	 */
	private void PrintArray(int[] array) {
		for(int i:array){
			System.out.print(" " +i);
		}
	}
}

 

2.找出二维数组中最大的值，所有最大值所在的行和列        

 

import java.util.Random;

//二维数组：随机赋值，找出最大值，输出值，行，列
public class Sort {
      public static void main(String[] args){
    	  int[][] array = new int[3][4]; 
    	  Random r = new Random();
    	  int max = 0;
          //循环遍历最大值
    	  for(int i=0;i<array.length;i++){
    		  for(int j=0;j<array[i].length;j++){
    			  array[i][j] = r.nextInt(10);
    			  if(array[i][j]>max){
    				  max = array[i][j];
    			  }
    			  
    		  }
    	  }
    	  System.out.println("最大值为："+max);
      //循环遍历最大值的行和列
      for(int i=0;i<array.length;i++){
		  for(int j=0;j<array[i].length;j++){
                  if(array[i][j]==max){
		  System.out.println(" 第"+i+"行,第"+j+"列");
             }
	      }
     }
  }
}