markdown

可变参数

• 在方法声明中，在指定参数类型后加一个省略号（…）。

• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在他之前声明。

  public class Test1 {
      public static void main(String[] args) {
          Test1 test1=new Test1();
          test1.test(1,2,3,5,26,213);
      }
      public void test(int...i,){
          System.out.println(i[0]);
          System.out.println(i[1]);
          System.out.println(i[2]);
          System.out.println(i[3]);
          System.out.println(i[4]);
          System.out.println(i[5]);
      }
  }
  

递归

• 递归就是：a方法调用a方法！就是自己调用自己
• 利用递归可以用简单的程序来解决一些复杂的我呢提。它通常把一个大型的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描叙出解题过程所需要的多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
• 递归结构包括两个部分：
  • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
  • 递归体：什么时候需要调用自身方法。

public class Test2 {
    public static void main(String[] args) {
        //阶乘
        System.out.println(f(6));
    }
    public static int f(int n){
        if(n==1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

数组的定义

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组的声明创建

• 首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的语法：

  data Type[] arrayRefVar;//首选的方法
  或
  data Type arrayRefVar[];//效果相同，但不是首选方法
  

• java语言使用new操作符来创建数组，语法如下：

  data Type[] arrayRefVar = new dataType[arraySize];
  

• 数组的元素是通过索引访问的，数组索引从0开始

• 获取数组长度：

  array.length
  

  public class Test3 {
      public static void main(String[] args) {
          //变量的类型 变量的名字=变量的值；
          //数组类型
          int[] nums;//1.定义
          nums=new int[10];//2.创建一个数组
          int[] nums2=new int[10];
          //3.给数组元素中赋值
          nums[0]=1;
          nums[1]=2;
          nums[2]=3;
          nums[3]=4;
          nums[4]=5;
          nums[5]=6;
          nums[6]=7;
          nums[7]=8;
          nums[8]=9;
          nums[9]=10;
          //计算所有元素的和
          int sum=0;
          //获取数组长度：arrays.length
          for (int i=0;i<nums.length;i++){
              sum=sum+nums[i];
          }
          System.out.println(sum);
      }
  }
  

内存分析

• java内存分析
  1. 堆：(1)存放new的对象和数组(2)可以被所有的线程共享，不会存放别的对象引用
  2. 栈：(1)存放基本变量类型(2)引用对象的变量
  3. 方法区：(1)可以被所有的线程共享(2)包含了所有的class和static变量

三种初始化

public class Test3 {
    public static void main(String[] args) {
        //静态初始化
        int[] a={1,2,3,4,5,6,7};
        System.out.println(a[0]);
        //动态初始化:包含默认初始化
        int[] b=new int[10];
        b[0]=10;
        System.out.println(b[0]);
        //默认初始化
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
    }
}

数组的四个基本特点

• 其长度是确定的，数组一旦被创建，它的大小就是不可改变的
• 其元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组的变量属引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型

数组边界

• 下标的合法区间：[0，length-1]，如果越界就会报错；
• ArrayIndexOutOfBoundsException：数组下标越界异常！

数组的使用

• for-each循环

  public class Test4 {
      public static void main(String[] args) {
          int[] arrays={1,2,3,4,5};
          //没有下标
          for (int array : arrays) {
              System.out.println(array);
          }
      }
  }
  

• 数组作方法入参

  public class Test4 {
      public static void main(String[] args) {
          int[] arrays={1,2,3,4,5};
          printArray(arrays);
          }
      //打印数组元素
      public static  void printArray(int[] arrays){
          for(int i=0; i<arrays.length;i++){
              System.out.println(arrays[i]+"");
          }
      }
  }
  

• 数组作返回值

  public class Test4 {
      public static void main(String[] args) {
          int[] arrays={1,2,3,4,5};
          int[] reverse=reverse(arrays);
          printArray(reverse);
          }
      //打印数组元素
      public static  void printArray(int[] arrays) {
          for (int i = 0; i < arrays.length; i++) {
              System.out.println(arrays[i] + "");
          }
      }
      //反转数组
      public static int[] reverse(int[] arrays){
              int[] result = new int[arrays.length];
              //反转的操作
              for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
                  result[j]=arrays[i];
              }
              return result;
      }
  }
  

例题：

public class Test4 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        //打印全部的数组元素
        for (int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
        //计算所有元素的和
        int sum=0;
        for (int i=0;i<arrays.length;i++){
            sum=sum+arrays[i];
        }
        System.out.println("sum="+sum);
        //查找最大元素
        int max=arrays[0];
        for (int i=1;i<arrays.length;i++){
            if(max<arrays[i]){
                max=arrays[i];
            }
        }
        System.out.println(max);
    }
}

多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一堆数组，其每一个元素都是一个一维数组。

• 二维数组

  int a[][]=new int[2][5];	
  

public class Test5 {
    public static void main(String[] args) {
        int [][] array={{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array.length);
        System.out.println(array[0].length);
        for (int i=0;i< array.length;i++){
            for (int j=0;j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
        }
    }
}