Java中数组的理解和应用

数组的介绍以及概念

数组是存储同一种数据类型多个元素的集合。

数组中的初始化

Java中的数组必须先进行初始化，然后才能使用

所谓的初始化就是，为数组中的元素分配空间，并为每个数组元素进行赋值

动态初始化：只指定了长度，有系统给出初始化值

	格式：数据类型[ ] 数组名 = new 数据类型[数据的长度]; 

静态初始化：给出初始化值，由系统决定长度

	格式：数据类型[ ] 数组名 = new 数据类型[ ]{元素1,元素2,元素3.....};

简化版格式：数据类型[ ]  数组名 ={元素1,元素2,元素3.....};

数组中常见的问题

ArrayIndexOutofBoundsException:数组索引越界异常

原因是你访问了不存在的索引

NullPointerException ：空指针异常

原因是数组不在指向堆内存了

NegativeArrayException：数组负下标异常

数组的常见操作以及练习题

数组的遍历：

//这是数组的遍历操作
//数组的遍历就是依次打印出每一个数组中的元素
class ArrayErgodic{
	public static void main(String[] args){
		//定义一个数组，静态初始化展示
		int[] arr = {12,34,45,65,67,78,88};
		//用for循环遍历得到每一个数组的元素
		for(int x = 0; x < arr.length; x++){
			System.out.print(arr[x]);
		}
		System.out.println();
	}
}

数组获取最大值和最小值：

//数组求最大值和最小值案例：
public class ArrayTest{    
	public static void main(String[] args){        
		//定义一个数组        
		int[] arr = {12,45,23,25.15,55};               
		 //定义一个参照物        
		 int max = arr[0];                
		 for(int x = 1; x < arr.length; x++){ 
			 if(arr[x] > max){                
			 	max = arr[x];           
			 }        
		}        
		System.out.println("Max:" + max);    
	}
}
//同理求最小值，把判断条件换一下就可以了

数组的逆序操作：

/*
	数组的元素逆序：
		思路：
			先定义个数组，并进行静态的一个初始化
			把0索引和array.length-1的数据进行交换
			把1索引和arra.length-2的数据进行交换
			......
		  只要做到array.length/2的时候即可
*/
class ArrayReverse{
	public static void mian(String[] args){
		//定义一个数组，并进行静态初始化
	    int[] arr = {11,24,22,55,21,15};
	    System.out.println("逆序前:");
        ArrayPrint(arr);
        System.out.println("逆序后:");
        reverse(arr);
	}
	//这是一个数组逆序的方法
	public static void reverse(int[] arr){
		 for(int x = 0; x < arr.length / 2; x++){
			int temp = arr[x];
			arr[x] = arr[arr.length - 1- x];
			arr[arr.length - 1 - x] = temp;
		 }
	}
	//数组的遍历
	public static void ArrayPrint(int[] arr){
        System.out.print("[");
        for(int x = 0 ; x < arr.length; x++){
            if(x == arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                System.out.println(arr[x]+", ");
            }
        }
   }
  //另外一种写法（数组逆序）
  public static viod reverse_2(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;
        }
    }
}

数组的排序算法：

/*
	冒泡排序:相邻元素两两比较，大的往后放，第一次完毕后，最大值出现在了最大索引处
*/
class ArrayTest{
    public static void main(String[] args){
        int[] arr = {22,,11,44,55,66,33};
        System.out.println("排序前");
		PrintArray(arr);
        for(int x = 0; x < arr.length - 1; x++){
            for(int y = 0; y < arr.length - x - 1; y++){
                if(arr[y] > arr[y+1]){
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
        System.out.println("排序后:");
		PrintArray(arr);
    }
    //遍历数组
	public static void PrintArray(int[] arr){
		System.out.print("[");
		for(int x = 0; x < arr.length; x++){
			if(x == arr.length -1){
				System.out.print(arr[x] + "]");
			}else{
				System.out.print(arr[x] +", ");
			}
		}
		System.out.println();
}

/*
	选择排序:从0索引开始，依次和后面的元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
*/
class ArrayTest_2{
    public static void main(String[] args){
        int[] arr = {22,34,55,24,11,44};
        System.out.println("排序前：");
		PrintArray(arr);
        for(int x = 0; x < arr.length - 1; x++){
            for(int y = x+1; y < arr.length; y++){
                if(arr[x] > arr[y]){
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
        System.out.println("排序后:");
		PrintArray(arr);
    }
    //遍历数组
	public static void PrintArray(int[] arr){
		System.out.print("[");
		for(int x = 0; x < arr.length; x++){
			if(x == arr.length -1){
				System.out.print(arr[x] + "]");
			}else{
					System.out.print(arr[x] +", ");
			}
		}
		System.out.println();
	}
}