周末作业

      (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

f171
                              垃圾回收器的回收机制
                   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(数组名)。