作业

(1)数组的概念：

数组是一个变量，存储相同数据类型的一组数据的集合

 数组是相同类型的数据按顺序组成的一种复合数据类型。通过数组名加数组下标，来使用数组中的数据。下标从 0 开始排序。

       (2)特点：

              数组一旦定义好就不可以修改长度，如果要修改就必须重新定义一个新数组或者引用其他的数组，因此数组的灵活性较差     

. length来调用

       (3)定义格式

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

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

              推荐是用A方式，B方法要能看懂

       (4)一维数组的初始化

              A:静态初始化：

                     举例：int arr[]=new int []

arr[]=new int []{1,2,3}

                     简化版：int arr[]= new int []{1,2,3}

错误写法：

              B:动态初始化：

                     举例：           

                            int[] arr= new int[5];

                                   arr[0]=a;   arr[1]=b;

                                   arr[2]=c;   arr[3]=d;

                                   arr[4]=e;            

 

错误写法：int arr[] = new int[5]

                 arr[1]=a; arr[2]=b;

         arr[3]=c; arr[4]=d

         arr[5]=e;

C:无论动态、还是静态初始化数组，一定在创建的时候，就指明了数组的长度

(5)如何引用数组元素：

数组的长度：通过 数组名[下标] 来调用

(6)如何遍历数组

int arr[]=newint[]{1,2,3,45,65,48,78,75,18};

for(int i=0;i<arr.length;i++){

              System.out.println(arr[i]);

          }

       (7)Java的内存分配

              A: 栈区

              B: 堆区 

              C: 方法区          

D: 静态域

画图：内存的基本结构

             

      

       (8)数组内存图

              一维数组的内存结构：画图，下面三段代码在内存中的结构

int[] scores = newint[4];

scores[0] = 89;

scores[3] = 90;

 

String[] strs1 =new String[]{“AA”,”BB”};

 

String[] strs =new String[4];

strs[0] ="AA";

strs[1] ="BB";

 

              注意：

                     a:局部变量的概念：

                     b:栈内存和堆内存的区别

                           

                                分别写出各类型变量的默认值

                                         

                                垃圾回收器的回收机制

 

       (9)二维数组

A:声明并初始化

//一维：int arr[];

 

//动态int[] arr = newint[5];

                                   arr[0]=a;

                                   arr[1]=b;

                                   arr[2]=c;

                                   arr[3]=d;

                  arr[4]=e;      

 

//静态int arr[]= new int []{1,2,3}

 

//二维：//4行3列，数组长度为4，每个元素是一维数组，长度为3

//动态第一种

int arr[][] = {{1,2},{3,4,5},{7,8,9},{15,45}};

//动态第二种

int arr[][]=new int [4][3];

//静态初始化

int[ ][ ] score =new int[ ][ ] { {89, 79},{76,86},{59,68} };

 

 

B:如何引用二维数组的元素

用数组名[下标][下标]调用 

C：二维数组的长度：

数组名.length  行长度

数组名[下标].length  列长度

D:遍历二维数组

              int[][] a=newint [][]{{1,2,3},{1,5,7},{4,8,9}};

       for(int i=0;i<a.length;i++){

           for(int j=0;j<a[i].length;j++){

              System.out.print(a[i][j]);

           }

           System.out.println();

       }

        

E：

String[][] names;

names = newString[6][5];

 

String[][] names;

names = newString[2][];

names[0] = newString[5];

names[1] = newString[3];

 

int[][] i = new int[3][];

i[0] = new int[3];

i[1] = new int[2];

i[2] = new int[4];

i[1][0] = 90;

i[2][1] = 100;

 

 

 

 

数组的常见异常：

                  //1.数组下标越界的异常的代码举例

int a[]=new int[5];

a[0]=1;

                                   a[1]=2;

                                   a[2]=3;

                                   a[3]=4;

                                   a[4]=5; 

System.out.println(a[6]);

                  //2.空指针的异常的代码举例

                  //第一种：

         int a[]=new int[5];

a[0]=1;

                                   a[1]=2;

                                   a[2]=3;

                                    

System.out.println(a[4]);

                                      

                  //第二种：

boolean a[]=new boolean[5];

System.out.println(a[4]);

                         

                  //第三种：

String a[]=new String[5];

System.out.println(a[4]);

       (10)数组的常用算法

              A:求数组元素的最大值、最小值、和、平均数，写出代码

             

B:数组的复制和反转：

A:                  int[] array1, array2;

array1 = new int[] { 2, 3, 5, 7, 11, 13,17, 19 };

array2 = array1;

 

B:                int[]array1;

int[] array2;

array1 = new int[] { 2, 3, 5, 7, 11, 13,17, 19 };

array2 = new int[array1.length];

for (int i = 0; i < array2.length; i++){

array2[i] = array1[i];

}

for (int i = 0; i < array2.length; i++){

if (i % 2 == 0) {

array2[i] = i;

}

}

 

数组的反转：写出代码

int []array1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };

for(int i=0;i<array1.length/2;i++){

           int temp =array1 [i];

           array1 [i]=array1 [array1.length-1-i];

           array1 [array1.length-1-i]=temp;

       }

       for(inti=0;i< array1.length;i++){

          

              System.out.println(array1 [i]+”,”);

           }