Day2（方法 内存 数组（冒泡排序和稀疏数组））

方法（类似于函数）

原子性：一个方法只实现一个功能，方便调用
return 的特殊用法：可用于终止方法（return 0；）

方法重载

方法名必须相同，参数列表必须不同

命令行传参

……有时间具体看。

可变参数

在方法声明中，在指定参数类型后加以一个省略号（…）
一个方法只能指定一个可变参数，它必须是方法的最后一个参数。所有普通参数必须在它之前声明。

 public static void main(String[] args) {
        text t=new text();
        t.test(1,2,3,4,5,6);
           }
public void test(int... i){
    System.out.println(i[0]);
    System.out.println(i[1]);
    System.out.println(i[2]);
}//输出 1  2  3

本质就是数组

递归 ！重点！

递归结构包括：

• 递归头：什么时候不调用自身方法。 如果没有头，将陷入死循环。
• 递归体：什么时候调用自身方法

例题递归求阶乘

public static void main(String[] args) {
    System.out.println(f(3));
    //输出3的阶乘     6
}

public static int  f(int n){
    if(n==1){
      return 1;
    }
    else {
        return n*f(n-1);
    }
}             

Java内存

Java内存分区	内容和特性
堆	new的对象和数组 ；所有线程共享；不存放别的对象的引用
栈	基本变量类型（含具体数值）；引用对象的变量（引用对象在堆中的地址）
方法区	所有class和static变量；所有线程共享
……	……

数组

数组特点：

• 长度确定，不可改。若越界，报错ArrayIndexOutofBounds
• 是相同数据类型的元素的有序集合
• 元素可以是任何类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组是一个对象，它的元素相当于对象的成员变量。
• 数组对象本身是在堆中的。

数组的使用

增强型for循环（for each）

int[] arrays={1,2,3,4,5};
//arrays.for  数组专属的增强型for循环
  for (int array : arrays) {
      System.out.println();    //输出 1 2 3 4 5
  }

Arrays类

常用功能熟练掌握

int[]  a={1,3,4,316,64,2,6235,6567,63425};
System.out.println(a);  //输出[I@7c30a502
System.out.println(Arrays.toString(a));  //输出[1, 3, 4, 316, 64, 2, 6235, 6567, 63425]

冒泡排序

普通排序方式

public static void main(String[] args) {
   int[] nums={1,4,6,2,4};
   sort(nums);
    System.out.println(Arrays.toString(nums));
}
/*冒泡排序
   1.比较数组中两个相邻元素的大小，若左大右小，则互换位置。
   2.每一次比较都会产生一个最大或最小的数字
   3.下一轮则可以减少一次排序
   4.依次循环直到结束   复杂度O（n2）
    */
public  static void sort(int[] a){
    int b=a[0];
    for (int i = 0; i < a.length-1; i++) {
        for (int j = 0; j < a.length-1; j++) {
            if (a[j]>a[j+1]){
                b=a[j];
                a[j]=a[j+1];
                a[j+1]=b；
  }  }
 }}

局部优化：减少遍历次数，对排序正确的对象不用再遍历。

boolean flag=false;//flag作为标识位减少没有意义的比较
int b=a[0];
for (int i = 0; i < a.length-1; i++) {
    for (int j = 0; j < a.length-1; j++) {
        if (a[j]>a[j+1]){
            b=a[j];
            a[j]=a[j+1];
            a[j+1]=b;
            flag=true;
        }
    }
    if(false==false){   //说明没有进入上面的if循环进行排序
        break;
    }

稀疏数组

• 数组的大部分元素为0或相等时，可用稀疏数组保存
• 稀疏数组的处理方式：
  记录数组共有几行几列，共有几个不同的值。
  把具有不同值的元素和行，列 及值记录在一个小规模数组里。

例题：记录五子棋的棋盘。

public static void main(String[] args) {
        //1.创建一个二维数组 11*11       0：没有棋子          1：黑棋       2：白棋
       int[][] array1=new int[11][11];
array1[1][2]=1;
array1[2][3]=2;
//输出原始数组
        System.out.println("输出原始数组：");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换稀疏数组
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }

            }
        }
        System.out.println("有效值个数："+sum);
        //2.创建一个稀疏数组的数组
        int[][] array2=new int[sum+1][3];   //3列 存储： 行 列 值
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;     //打印稀疏数组的头  行 列 值的个数

        //遍历二维数组 将非0值，存放在稀疏数组
        int count=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];

                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }
}

输出结果：