黑马程序员__基础__数组



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

数组

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

1. int[] a = new int[10] 

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

1. int[] arr = new int[5];  
2.   arr[3] = 10; 

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
  当数组不在指向某个实体时，你还继续访问，就会发生空指针异常。

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

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

1. class ArrrayTest   
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int[] array = {432,354,243,2,3,554,543,3334,432,54,35,435,43,543,54,35,43543,5};  
6.   
7.     /*  int max = array[0];//先假定第一个数是最大的，max用来存储最大值的 
8.         for(int i = 0 ; i < array.length ; i++){ 
9.             max = max > array[i] ? max : array[i]; 
10.              
11.         } 
12.     */  
13.         int max = getMax(array);  
14.   
15.         System.out.println("最大值：" + max);  
16.     }  
17.   
18.     public static int getMax(int[] array){  
19.         //先假定第一个数是最大的，max用来存储最大值的  
20.         int max = array[0];  
21.         //遍历数组  
22.         for(int i = 0 ; i < array.length; i++){  
23.             max = max > array[i] ? max : array[i];  
24.         }  
25.         //遍历之后，max存储的就是最大值，直接返回这个最大值  
26.         return max;  
27.     }  
28. }  

     选择排序

1. int[] arr = {7,6,5,8,9,10,4,3,2,1}；  
2.       
3. for (int x = 0;x < arr.length - 1;x++){  
4.     for (int y = x + 1;y < arr.length;y++){  
5.         if (arr[x] > arr[y]){  
6.             int temp = arr[x];  
7.             arr[x] = arr[y];  
8.             arr[y] = temp;  
9.             }  
10.         }  
11. }  

 

  冒泡排序
 

1. for (int x = 0;x < arr.length - 1; x++){  
2.   
3.     for (int y = 0;y < arr.length - 1 - x;y++){//6  
4.     if (arr[y] > arr[y+1]){  
5.         int temp = arr[y];  
6.         arr[y] = arr[y+1];  
7.         arr[y+1] = temp;  
8.         }  
9.     }  
10. }  

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

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

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

1. class Demo2   
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int num1 = 10;  
6.         int num2 = 20;  
7.   
8.         int max = getMax(num1,num2);  
9.         System.out.println(num1);  
10.         System.out.println("---------------------");  
11.         int[] arr = {43,54,54,543};  
12.         System.out.println(arr[0]);//43  
13.         changeArray(arr);  
14.         System.out.println(arr[0]);//100  
15.           
16.         //数组的复制  
17.         int[] arr2 = arr;//这不代表复制一个数组，仅仅复制了一个引用  
18.         //复制一个数组  
19.         int[] arr3 = new int[arr.length];//先确定长度  
20.         //复制数据  
21.         for(int i = 0 ; i < arr3.length ; i++){  
22.             arr3[i] = arr[i];  
23.         }  
24.   
25.   
26.   
27.     }  
28.     //当方法参数是基本数据类型时，将原值复制一份，到方法体  
29.     //如果在方法体内将参数值修改，不会影响原值  
30.     public static int getMax(int a , int b){  
31.           
32.         return a > b ? a : b;  
33.     }  
34.   
35.     //当方法参数是"引用类型"时，将"引用"复制一份，到方法体  
36.     //如果在方法体内，通过这个引用修改堆空间的值，修改的就是原堆空间的值  
37.     public static void changeArray(int[] arr){  
38.         arr[0] = 100;  
39.     }  
40. }  

6.二维数组的查找：
 

1.     1.数组的每一维可以是另一个数组；  
2.     2.二维数组的声明方式：  
3.       方式1：  
4.         int[][] arr = new int[3][2];//3个2个长度的数组或者，3行2列的表格  
5.       方式2：  
6.         int[][] arr = {{32,54},  
7.                        {55,66},  
8.                        {67,45}};  
9.     3.二维数组的第二维，可以是不同长度的；  
10.         int[][] arr = new int[3][];  
11.         arr[0] = new int[3];  
12.         arr[1] = new int[1];  
13.         arr[2] = new int[2];  
14.   
15. */  
16. class  ArrayTest2  
17. {  
18.     public static void main(String[] args)   
19.     {  
20.         int[][] arr = new int[3][2];  
21.         System.out.println(arr);  
22.         System.out.println(arr[0]);   
23.         System.out.println(arr[1]);   
24.         System.out.println(arr[2]);   
25.   
26.         arr[0][0] = 100;  
27.         arr[0][1] = 50;  
28.         arr[1][0] = 67;  
29.         arr[1][1] = 80;  
30.         arr[2][0] = 88;  
31.         arr[2][1] = 90;  
32.           
33.         System.out.println(arr.length);       
34.         System.out.println(arr[0].length);    
35.         System.out.println(arr[1].length);  
36.         System.out.println(arr[2].length);    
37.         //遍历  
38.         for(int i = 0 ; i < arr.length ; i++){  
39.             for(int j = 0 ; j < arr[i].length ; j++){  
40.                 System.out.println(arr[i][j]);  
41.             }  
42.         }  
43.         System.out.println("-------------------------------");  
44.   
45.         int[][] arr2 = new int[3][];  
46.         arr2[0] = new int[3];  
47.         arr2[1] = new int[1];  
48.         arr2[2] = new int[2];  
49.   
50.         arr2[0][0] = 50;  
51.         arr2[0][1] = 60;  
52.         arr2[0][2] = 70;  
53.         arr2[1][0] = 80;  
54.         arr2[2][0] = 90;  
55.         arr2[2][1] = 100;  
56.         //遍历  
57.         for(int i = 0 ; i < arr2.length ; i++){  
58.             for(int j = 0 ; j < arr2[i].length ; j++){  
59.                 System.out.println(arr2[i][j]);  
60.             }  
61.         }  
62.   
63.   
64.     }  
65. }  

7.数组反转

1. public static void revArray(int[] arr) {  
2.     for (int start=0,end = arr.length-1;start<end ;start++, end--){  
3.         int temp = arr[start];  
4.         arr[start] = arr[end];  
5.         arr[end] = temp;  
6.             }  
7.           
8.         }  

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

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