周末作业

      (1)数组的概念：数组是相同数据类型的数据按顺序组成的一种复合数据类型，通过数组名和数组下标使用数组元素，下标从0开始排序。

      (2)特点：数据使用方便。

数组的长度：通过for循环来调用。

      (3)定义格式

             A:数据类型[] 数组名=new数据类型[]{元素};

             B:数据类型[] 数组名=new数据类型[1];

                数组名[下标]=值;

          数组名[下标]=值;

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

      (4)一维数组的初始化

             A:静态初始化：数据类型[] 数组名=new数据类型[]{元素};

                    举例： int[]arr=new int[]{1,2,3}; 

                    简化版：数据类型[] 数组名={元素};

错误写法：数据类型[] 数组名=new数据类型[2]{元素};

             B:动态初始化：数据类型[] 数组名=new数据类型[1];

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

                 arr[0]=1;

                 arr[1]=2;

错误写法：数据类型[] 数组名=new数据类型[];

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

(5)如何引用数组元素:数组名[]=赋一个值;

(6)如何遍历？数组用for循环下标，然后输出这个数组。

      (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:栈内存和堆内存的区别

                           栈是缓存，堆是保留内存。

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

                                         Float:0.0,double:0.00，String:null,short、byte、long、int:0。

                       char：'\u0000'

                      boolean：false

                      引用类型（类、接口、数组）：null

                              垃圾回收器的回收机制

                   JVM回收， 数据使用完毕后，在垃圾回收器空闲的时候回收。

      (9)二维数组

A:声明并初始化int[] arr=new arr[]{1,2,3,4};

//一维：int[] arr=new arr[]{1,2,3,4};

//动态int[] arr=new arr[4];

         arr[0]=1;

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

 

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

//动态第一种int[][] arr=new int[4][3];

 

//动态第二种

 

String[][] str1 = new String[4][];

str1[0] = new String[3];

……

str1[3] = new String[5];

//静态初始化

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

 

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

 arr[0][0]=1；

C：二维数组的长度：

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

D:遍历二维数组

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

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.数组下标越界的异常的代码举例

                        in thread  main:Exception:Arrayslist.outofBround               

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

                 //第一种：

                    

                     boolean[] b = new boolean[3];

                    b = null;

                 //第二种：

                     

                 String[] str = new String[4];

                 str[3] = new String("AA");

                System.out.println(str[3].toString());

                 //第三种：

               

                      int[][] j = new int[3][];

                     j[2][0] = 12;

  

      (10)数组的常用算法

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

//最大值
		int max=arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (max<arr[i]) {
				max=arr[i];
			}
		}
		System.out.println("数组最大值是："+max);
		//最小值
		int min=arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (min>arr[i]) {
				min=arr[i];
			}
		}
		System.out.println("数组最小值是："+min);
		//总和
		int sum=0;
		for (int i = 0; i < arr.length; i++) {
			sum+=arr[i];
		}
		System.out.println("总和是："+sum);
		//平均数
		int avg=0;
		for (int j = 0; j < arr.length; j++) {
			avg=sum/arr.length;
		}
		System.out.println("平均数是："+avg);

B:数组的复制和反转：

//数组的复制
		int[] array3=new int[array1.length];
		for (int i = 0; i < array3.length; i++) {
			array3[i]=array1[i];
		System.out.print(array3[i]);
		}
		System.out.println();

//元素反转
		//第一种写法
		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 (int i = 0; i < array1.length; i++) {
			System.out.print(array1[i]+"\t");
		}
		//第二种写法
		for (int i = 0; j= array1.length-1;i<j;i++;j--) {
			int temp=array1[i];
			array1[i]=array[j];
			array1[i]=temp;
		}

画图：涉及值传递

int[] array1, array2;

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

array2 = array1;

 

画图：实现复制

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;

}

}

 

数组的反转：写出代码

 

拓展：String str = “abcdefg”;写出实现反转的思路

     对前一半的元素进行反转循环遍历，通过间接赋值，把后面对应的元素赋值到前面的下标元素，实现元素反转。

     

数组的排序：直接选择排序、冒泡排序，写出代码

   冒泡排序：每次比较相邻两数；小的交换到前面；每轮结束后最大的数交换到最后。

int[] arr={49,38,65,97,76,13,27,49};
		for (int k = 0; k < arr.length-1; k++) {
			for (int m = 0; m < arr.length-1-k; m++) {
				if (arr[k]>arr[m+1]) {
					int temp=arr[m];
					arr[m]=arr[m+1];
					arr[m+1]=temp;                             
					System.out.print(temp+" ");
				}
			}
		}

     直接选择排序：

      //从小到大排序

		for (int i = 0; i < arr.length-1; i++) {             
			for (int j = i; j < arr.length; j++) {
				if (arr[i]>arr[j]) {
					int temp=arr[i];               
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}*/
		//Arrays.sort(arr);
	/*String[] arr={"aa","bb"};
	for (String arr1 : arr) {
		System.out.println(arr[1]);
	}
	

                    还可以调用工具类排序：

          导入Arrays包，对数组元素进行升序，Arrays.sort(数组名)。