菜鸟阿鑫对于一堆数组的总结以及理解

一堆数组总结的简单总结**

概念

数组：可以存储多个元素的一个容器。
前提条件：这个多个元素的类型（）必须是一致的。

定义一个数组，格式有两种
1）数据类型[]数组名称；例如：int[]arrary；
2）数据类型 数组名称[]；int arrary[]；
这两类型都是对的

一堆数组的初始化

在定义一个数组时，没有为它的元素分配存储空间，因此该数组不能直接使用，经过初始化，为数组分配内存空间，才能完成一个数组的创建

1）动态初始化

定义了数组的长度，里面的元素值默认系统给定值（默认值）；
数据类型[]数组名称=new 数据类型[数组长度]；例如int[]arrary=new int3；
数据类型[]数组名称；
数组名称=new 数据类型[数组长度]；例如int[]arrary；array=new int3；
注意事项：在java中，数组的索引值的值是从0开始，不是1；

int[]arrary=new int3;
int:当前数组的类型为int类型；
[ ]:表示定义的是一个一堆数组；
arrary：数组名称（小驼峰式）；
new：在java语法中就是在堆内存中开辟空间
int：定义的是一个int类型的数组；

注意事项：长度为第3，元素分别为：arrar[0],arrar[1],arrar[2];

2)数组的静态初始化：

数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3…};
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3…} ;
简写格式:
数据类型[] 数组名称 = {元素1,元素2,…} ;
数据类型 数组名称[] = {元素1,元素2,…} ;

注意事项:定义数组的时,不能同时动态和静态集合使用!
举例:int[] arr = new int3{1,2,3} ; //错误写法: 动静结合!

数组的简单练习

Test1：

/*
	需求:遍历数组中的元素
	遍历:就是将数组中的元素获取到并一一打印出来!
*/
public class Test1{//定义一个类
	public static void main(String[]args){//main主方法
		int[]array={1,2,3,4,5};//定义一个静态数组
		printArray(array);//对方法进行调用
	}
	public static void printArray(int[]array){//定义一个方法
	      for(int i=0;i<array.length;i++){//因为数组的索引值是从0开始，所有i是从0开始，索引值是小于array.length的
		  System.out.println(array[i]);//遍历数组中的元素
		  }
	}
}

Test2

/*[元素1, 元素2, 元素3, ...]*/
public class Test2{//定义一个类
	public static void main(String []args){//main主方法
		int[]array={1,2,3,4,5};//定义一个静态数组
	    printArray(array);//对方法进行调用
	}
public static void printArray(int[]array){//定义一个方法
          System.out.print("[");//打印一个]，去ln掉，就是不换行
	   for(int i=0;i<array.length;i++){//让数组进行遍历
		     if(i==array.length-1){//进行条件判断当判断是最后一个元素时
			System.out.println(array[i]+"]");//输出最后一个元素，并且有ln表示下一行换行，不加ln也是可以的，就是下一行不换行而已
		}else{
		    System.out.print(array[i]+", ");//否择输出其他的元素
	   }
     } 
  }
}

Test3

/*数组中的最值问题:
	给定一个数组,{1,2,3,4,5} 
	求出数组的最大值问题*/
public class Test3{//定义一个类
	public static void main(String []args){//main主方法
		int []array={1,2,3,4,5};//定义一个数组
	      printArray(array);//方法的调用
	}
public static void printArray(int []array){//定义一个方法
	       int max=array[0];//现给定一个初始元素，就是用第一号元素去和其他元素进行比较
		for(int i=1;i<array.length;i++){//注意这个要写i=1，因为要和第二个元素进行比较，如果写成0，就是自己和自己比较一次
			if(array[i]>max){//当第i号元素大于max时，将第i号元素赋值给max即可，如果max是最大值，直接输出即可
				max=array[i];
			}
		}
          System.out.println("数组中的最大值为"+max);//输出最大值
	}
}

Test4

/*数组中的应用:
		元素逆序
		给定一个数组{1,2,3,4,5} 
		元素逆序:
	 将索引值0对应的元素和arr.length-1对应的元素互换
		 将索引值1对应的元素和arr.length-1-1对应的元素进行互换...
		 依次这样....
		 最终只要保证 角标 < arr.length/2*/
public class Test4{//定义一个
	public static void main(String []args){
		int[]array={1,2,3,4,5};
	      printArray(array);
		  printArray1(array);
	}
    public static void printArray(int[]array){//定义一个方法
	for(int i=0;i<array.length/2;i++){//要实行数组元素的逆序就是第一个元素与最后一个元素进行调换，然后依次递进，第二个元素与倒数第二个元素进行调换，以数组中间为分界线，如果是奇数个自己与自己不需要进行交换，所以是小于不需要等于
		int temp=array[i];
		array[i]=array[array.length-1-i];
		 array[array.length-1-i]=temp;
	   }  
	}
      public static void printArray1(int[]array){//最后实行数组的遍历
		  System.out.print("[");
	   for(int x=0;x<array.length;x++){
			if(x==array.length-1){
				System.out.print(array[x]+"]");
			}else{
			System.out.print(array[x]+", ");
			}
		}
	  }
	}		

Test5

/*
		获取数组中某个元素第一次出现的索引值的方法
			两个明确
				1)明确返回值类型 int
				2)明确参数类型以及参数个数
			int类型 两个参数:在某个数组中查询某个元素
					*/
public class Test5{
	public static void main (String []args){
		int[] array={1,2,3,4,5};//定义一个数组
		int index=printArray(array,5);
		System.out.println(index);
	}

	public static int printArray(int[] array,int value){//定义一个方法，我们需要传一个数组，一个元素
		for(int i=0;i<array.length;i++){
			if(array[i]==value){//当我们输出的值与数组元素值相等时，我们取出元素的索引值
		       return i;//我输入的是5，注意他的索引值是4，因为索引值是从0开始的
		   }
		 } 
	             return -1;//当我们输出的元素在数组中没有的时候我们返回一个值，可以是其他值
	      }
}

Test6

/*
冒泡排序
一组数据，从头重复地走访过要排序的元素列，依次比较两个相邻的元素，
如果顺序（从小到大）错误就把他们交换过来，直到没有相邻元素需要交换，每次都可以确定一个最大数*/
public  class Test6{
	public static void main(String []args){
		int []array={1,3,5,1};
		printArray(array);//方法的调用
		printArray1(array);
	}
   public static void printArray(int[]array){
	   for(int i=0;i<array.length-1;i++){//外循环控制次数，如果写成array.length,也是可以的，只不过多比一次
		   for(int j=0;j<array.length-1-i;j++){//内循环防止角标越界，所以是array.length-1，如果是array.length后面加一个1就越界了
			 if(array[j]>array[j+1]){//拿第一个元素与后面一个元素进行两两比较，如果大，就进行交换，每次都可以确定一个最大的数字，循环次数就少一次
				   int temp=array [j];
				   array[j]=array[j+1];
				   array[j+1]=temp;
				    }
			   }
	       }
	   }
	public static void printArray1(int[]array){//最后实行数组的遍历
		  System.out.print("[");
	   for(int x=0;x<array.length;x++){
			if(x==array.length-1){
				System.out.print(array[x]+"]");
			}else{
			System.out.print(array[x]+", ");
			}
		}
	  }
	
}

对于冒泡排序的演示

从上面的截图可以看出在i=2时就可以比较出来了，没有必要在执行一次，所以就是array.length-1,而内循环就更好理解了，当j=3时，j+1是4，就角标越界了

自我总结

​ 因为自己对数组的理解还是不够用深刻，所对数组做了总结，尤其是对于冒泡，两个for循环的嵌套的理解，所以自己就拿普通的数字进行了尝试，才搞明白，对于学习而言，要不断地总结，不断地去联系，才能理解更加深刻，可以先拿常量进行尝试在将变量附加进去就理解更加深刻了，可能图画的有点，菜鸟也有菜鸟的方法吗。