黑马程序员——数组



------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

数组

1.数组可以想象的理解为存储同一类型的一个容器。eg：

<span style="font-size:18px;">int[] a = new int[10]</span>

数组是一个很重要的概念。可以自动给数组中的元素从0开始编号，方便操作这些元素。当要操作的同种数据类型的数据是多个的时，通常先把这些数据用数组进行存储。

<span style="font-size:18px;">int[] arr = new int[5];
  arr[3] = 10;</span>

2.数组的定义格式
 当不明确数组中的元素时，可以将数组定义为 int[] arr = new int[数组长度]；，动态初始为：'\u0000'。当明确数组中的元素时，可以定义为 int[] arr = new int[]{1,2,3,4,5};
3.内存图

  1）.栈里存储的是局部变量(在函数中定义的变量)。 变量被使用完后，立即自动释放。
  2）.堆里存储的是实体(数组和对象)。实体是new出来的东西，可以存放很多数据的东西。
        堆内存数据的特点
            每个实体都有内存地址
            堆内存中的变量都有默认初始化为int 类型初始化为 0，double类型初始化为0.0，boolean类型初始化false，char 类型初始化为'\u0000'。当实体为引用时通过java垃圾回收机制使其自动释放。

3).数组初始化过程
 <1> 主函数进栈,然后在main()中有一个数组的引用arr
 <2> 在堆内存中开辟空间，分配内存地址值
 <3> 在堆内存中建立数组对象，并进行默认初始化
 <4> 如果有显示初始化值的,对它进行显示初始化
 <5> 将内存地址赋给栈内存中的arr变量
 4.操作数组最常见的问题
  当访问到数组中的最后一个元素时，还想继续访问，这个时候，会发生角标越界异常。
   ArrayIndexOutOfBoundsException
  当数组不在指向某个实体时，你还继续访问，就会发生空指针异常。

                               int[] arr = new int[3];
			       arr = null;
			       System.out.println(arr[1]);

                会出现NullPointerException。
 5.常见的数组的操作
     获取最大值

class ArrrayTest 
{
	public static void main(String[] args) 
	{
		int[] array = {432,354,243,2,3,554,543,3334,432,54,35,435,43,543,54,35,43543,5};

	/*	int max = array[0];//先假定第一个数是最大的，max用来存储最大值的
		for(int i = 0 ; i < array.length ; i++){
			max = max > array[i] ? max : array[i];
			
		}
	*/
		int max = getMax(array);

		System.out.println("最大值：" + max);
	}

	public static int getMax(int[] array){
		//先假定第一个数是最大的，max用来存储最大值的
		int max = array[0];
		//遍历数组
		for(int i = 0 ; i < array.length; i++){
			max = max > array[i] ? max : array[i];
		}
		//遍历之后，max存储的就是最大值，直接返回这个最大值
		return max;
	}
}

     选择排序

 int[] arr = {7,6,5,8,9,10,4,3,2,1}；
		
	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;
				}
			}
	}

<span style="font-size:18px;">
</span>

 

**冒泡排序
 

for (int x = 0;x < arr.length - 1; x++){

    for (int y = 0;y < arr.length - 1 - x;y++){//6
	if (arr[y] > arr[y+1]){
		int temp = arr[y];
		arr[y] = arr[y+1];
		arr[y+1] = temp;
		}
	}
}

6.方法的按值传递和按引用传递

 1).按值传递：
  当方法参数是基本数据类型时，将原值复制一份，到方法体
  如果在方法体内将参数值修改，不会影响原值

 2).按引用传递：
  当方法参数是"引用类型"时，将"引用"复制一份，到方法体
  如果在方法体内，通过这个引用修改堆空间的值，修改的就是原堆空间的值

class Demo2 
{
	public static void main(String[] args) 
	{
		int num1 = 10;
		int num2 = 20;

		int max = getMax(num1,num2);
		System.out.println(num1);
		System.out.println("---------------------");
		int[] arr = {43,54,54,543};
		System.out.println(arr[0]);//43
		changeArray(arr);
		System.out.println(arr[0]);//100
		
		//数组的复制
		int[] arr2 = arr;//这不代表复制一个数组，仅仅复制了一个引用
		//复制一个数组
		int[] arr3 = new int[arr.length];//先确定长度
		//复制数据
		for(int i = 0 ; i < arr3.length ; i++){
			arr3[i] = arr[i];
		}



	}
	//当方法参数是基本数据类型时，将原值复制一份，到方法体
	//如果在方法体内将参数值修改，不会影响原值
	public static int getMax(int a , int b){
		
		return a > b ? a : b;
	}

	//当方法参数是"引用类型"时，将"引用"复制一份，到方法体
	//如果在方法体内，通过这个引用修改堆空间的值，修改的就是原堆空间的值
	public static void changeArray(int[] arr){
		arr[0] = 100;
	}
}

6.二维数组的查找：
 

	1.数组的每一维可以是另一个数组；
	2.二维数组的声明方式：
	  方式1：
		int[][] arr = new int[3][2];//3个2个长度的数组或者，3行2列的表格
	  方式2：
		int[][] arr = {{32,54},
					   {55,66},
					   {67,45}};
	3.二维数组的第二维，可以是不同长度的；
		int[][] arr = new int[3][];
		arr[0] = new int[3];
		arr[1] = new int[1];
		arr[2] = new int[2];

*/
class  ArrayTest2
{
	public static void main(String[] args) 
	{
		int[][] arr = new int[3][2];
		System.out.println(arr);
		System.out.println(arr[0]);	
		System.out.println(arr[1]);	
		System.out.println(arr[2]);	

		arr[0][0] = 100;
		arr[0][1] = 50;
		arr[1][0] = 67;
		arr[1][1] = 80;
		arr[2][0] = 88;
		arr[2][1] = 90;
		
		System.out.println(arr.length);		
		System.out.println(arr[0].length);	
		System.out.println(arr[1].length);
		System.out.println(arr[2].length);	
		//遍历
		for(int i = 0 ; i < arr.length ; i++){
			for(int j = 0 ; j < arr[i].length ; j++){
				System.out.println(arr[i][j]);
			}
		}
		System.out.println("-------------------------------");

		int[][] arr2 = new int[3][];
		arr2[0] = new int[3];
		arr2[1] = new int[1];
		arr2[2] = new int[2];

		arr2[0][0] = 50;
		arr2[0][1] = 60;
		arr2[0][2] = 70;
		arr2[1][0] = 80;
		arr2[2][0] = 90;
		arr2[2][1] = 100;
		//遍历
		for(int i = 0 ; i < arr2.length ; i++){
			for(int j = 0 ; j < arr2[i].length ; j++){
				System.out.println(arr2[i][j]);
			}
		}


	}
}

7.数组反转

public static void revArray(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;
		 	}
		
		}

1). 把数组转换成字符串输出,因为任何数据类型与字符串用+想连接都会产生新的字符串
 

int [] arr = {6,5,4,3,2,1};
	public static String arrToString(int[] arr) {
		String str = "[";
		for (int x = 0; x < arr.length; x++){
			if (x != arr.length - 1) {
				str = str + arr[x] + ", ";//[6, 5, 
			}else {
				str = str + arr[x] +"]";
			}
		}
		return str;
	}