Java 基础语法2

包管理

• 略

---

JavaDoc

• 自定义参数信息

  @author

  @version

  @since

  @param

  @return

  @throws

• 生成java帮助文档

  #加入字符集编码参数
  javadoc -encoding UTF-8 -charset UTF-8 类名.java
  

---

Scanner类

• 定义：从键盘接收数据的一个i/o对象

• 常用方法：

  • new Scanner(System.in).next()

    备注：会省略掉空格才开始读取输入，也会以空格为读取的结束，所以只会读取到无空格的内容

  • new Scanner(System.in).nextline()

    备注：整行读取，包括空格在内

---

逻辑结构

• if 、if else 、多重if elseif else 结构

• switch 结构

• 循环结构

  • while 语句

  • do while 语句 备注：至少可以执行一次方法体

  • for(;😉 语句

  • for 增强型循环

  • 练习题：输出一个等边三角形

    • 思路：化难为易，拆分成各简单部分

    • //定义三角形高度
      int h = 5;
      //外循环控制高度
      for(int n = 0 ; n < h ; n++){
          //控制输出空格
          for(int m = 0 ; m < h - n -1 ; m++){
              System.out.print(" ");
          }
         	//控制输出*
          for (int m = 0; m < 2*n + 1; m++) {
              System.out.print("*");
          }
          System.out.println();
      }
      

---

方法

• 方法重载

  • 参数数量、类型、排序不同 方法名返回类型相同
  • 可变参数 ：数据类型... 变量名
  • 可变参数一定要放到方法参数的最后一位，且只有一个

• 递归

  • 定义：自身调用自身的方法，如没有递归头，将会陷入死循环导致栈内存溢出

  • 组成：递归头 + 递归体

  • 例子：

    • //阶乘方法 n!= ?
      public static int method(int n){
          //递归头
          if(n==1){
              return 1;
          //递归体
          }else{
              return n*method((n-1));
          }
      }
      

  • 弊端：因为每调用一次自身方法，在栈内存上会存在一个方法内存，直到递归头返回数据，原路返回，方法内存才一个接一个释放内存，调用自身的方法越多，会占用更多的栈内存会导致栈内存溢出情况，所以建议不使用递归方法

    

---

数组

• 数组创建

  • 数据类型[] 变量名 = new 数据类型[数组长度] (推荐)
  • 数据类型 变量名[] = new 数据类型[数组长度]
  • 数据类型[] 变量名 =

• 二维数组

  • 数据类型[] [] 变量名 = new 数据类型[数组长度] [数组长度]

• 数组排序

  • 冒泡排序 （算法一种）

  • int[] intArray = {24,23,25,45,21,45,67,34};
    int temp = 0;
    //外重循环控制次数
    for(int n = 0;n < intArray.length-1;n++){
        //内重循环控制数据比较
        for(int m = 0;m < intArray.length-n-1;m++){
            if(intArray[m] > intArray[m+1]){
                temp = intArray[m];
                intArray[m] = intArray[m+1];
                intArray[m+1] = temp;
            }
        }
    }
    

  • 冒泡排序优化方案（之一）

    • 如果数组本来就是有序的

    • int[] intArray = {24,23,25,45,21,45,67,34};
      int temp = 0;
      boolean flag = false;
      //外重循环控制次数
      for(int n = 0;n < intArray.length-1;n++){
          //内重循环控制数据比较
          for(int m = 0;m < intArray.length-n-1;m++){
              if(intArray[m] > intArray[m+1]){
                  //如果进入了该判断，数组是无序的
                  flag = true;
                  temp = intArray[m];
                  intArray[m] = intArray[m+1];
                  intArray[m+1] = temp;
              }
          }
          //利用flag来判断是否继续循环
          if(!flag){
              break;
          }
      }
      

  • Arrays.sort(数组变量名)

• 稀疏数组

  • 将重复无实际意义的0或代表数字压缩掉，只剩下其有意义的数字，与其数字的坐标

  • 如：以下二维数组，一维数组同理

    • 0	0	0	0	0	0
      0	0	0	64	0	0
      0	45	0	0	0	0
      0	0	0	0	0	0
      0	0	0	0	0	0
      0	0	0	0	0	0

    • 行	列	数值
      1	3	64
      2	1	45

      public class Test {
          public static void main(String[] args) {
              int[][] array = new int[6][6];
              array[1][3] = 64;
              array[2][1] = 45;
              printArray(array);
      
              int[][] ints = compress(array);
      
              printArray(ints);
          }
      
          public static void printArray(int[][] array){
              for (int i = 0; i < array.length; i++) {
                  for (int j = 0; j < array[i].length; j++) {
                      System.out.print(array[i][j]+"\t");
                  }
                  System.out.println();
              }
          }
      
          public static int[][] compress(int[][] array){
              int sum = 0;
              for (int i = 0; i < array.length; i++) {
                  for (int j = 0; j < array[i].length; j++) {
                      if( array[i][j] != 0){
                          sum++;
                      }
                  }
              }
              int[][] result = new int[sum][3];
      
              int count = 0;
              for (int i = 0; i < array.length; i++) {
                  for (int j = 0; j < array[i].length; j++) {
                      if( array[i][j] != 0){
                          result[count][0] = i;
                          result[count][1] = j;
                          result[count][2] = array[i][j];
                          count++;
                      }
                  }
              }
              return result;
          }
      }
      

---