流程控制

用户交互Sanner

• 作用：通过Scanner类获取用户的输入

• 基本语法：

• 通过Scanner类的next（）和nextline()方法获取字符串；

• 读取之前可以用hasNext()和hasNextLine()判断是否还有输入的数据（可用于循环条件判断）

  Scanner s = new Scanner(System.in);
  //输入hello world
  String str = s.next();
  System.out.println("str为 "+str);   //不能得到带有空格的字符串,得到hello
  String str1 = s.nextLine();
  System.out.println("str1为 "+str1);  //以回车为结束符,得到hello world
  s.close();   //凡是I/O流的类，用完就要关闭
  
  

  while(s.hasNextDouble()){
              double x = s.nextDouble();
              account++;
              sum = sum + x;
          }
   System.out.println("共有"+account+"个数，总和为"+sum);
   s.close();
   System.out.println("当前输入第"+account+"个数");
  

  ​

顺序结构

选择结构

• if单选

• if双选择

• if多选择

• 嵌套的if

• switch多选（等值判断，可以匹配字符串）

  注意每写完一个case加break，不然会穿透

循环结构

• while循环
• do...while循环
• for循环----增强for

break & contine

• break可用于任何循环语句的主体部分，用于强行退出循环（也可在switch语句中使用）
• continue用于终止某次循环过程，跳过某次循环体中还未执行的语句，紧接着判断下一次

练习

打印三角形-等腰三角形-菱形

方法

方法的定义及调用

• 方法：语句的集合，执行一个功能（最好保持原子性，一个方法实现一个功能）

• 命名：首字母小写，驼峰命名

• 组成：修饰词（public） 返回值类型 方法名 参数类型 方法体

• 调用：对象名.方法名（实参列表）

  ​ ~当方法返回一个值的时候，方法调用通常被当作一个值 int larger = max(30,40);

  ​ ~若方法返回值是void,方法调用一定是一条语句 System.out.println("Hello,world");

方法重载

• 啥？ 重载就是在一个类里，函数名称相同，形参不同
• 方法重载就是方法名称相同，参数列表不同（个数不同或类型不同或参数排列顺序不同）

可变参数（不定项）

• 在方法声明中，在指定参数类型后加一个省略号...（可以传好几个）（int...i)
• 一个方法只能指定一个可变参数，且必须是方法的最后一个参数

递归--栈机制

• 啥？---A方法自己调用自己
• 结构：递归头（什么时候不调用，跑出牢笼）递归体（什么时候调用）

数组

声明创建

• 声明- dataType[] name;(首选) or dataType name[];（c和c++中用的）
• 创建-使用new操作符：dataType[] name = new dataType[size]
• 数组元素通过索引访问，数组索引从0开始
• 初始化：静态、动态
• 数组是引用类型，数组也可以看作对象，数组元素就是对象的成员变量；数组一经分配空间就会被隐式初始化（默认值为0）
• 一旦创建，大小不可改变。
• Java内存分析

​ 堆--存放new的对象和数组，不会存放别的对象引用

​ 栈--存放基本变量类型（数值型、字符型、布尔型；包含具体数值），引用对象的变量（存放 这个引用在堆里面的具体地址）（字符串不是基本数据类型！！！）

​ 注意：Java中==比较的是栈里的值，equals()比较堆里的值

​ 方法区--被所有线程共享，包含所有的class和static变量

使用

• for循环--打印数组元素

• for-each，增强for循环输入输出

  ​

• 数组作方法入参（额。。。）

• 数组作返回值--反转数组

多维数组

• 二维数组：数组的数组，数组嵌套数组：int a[][] [][] =new int [2]5

   //遍历输出
   for (int i = 0; i < array.length; i++) {
          for (int j = 0; j < array[i].length; j++) {
               System.out.print(array[i][j]+" ");
              }
              System.out.println();
    }
  
  

  ​

Arrays类

• 关于数组的一个工具类，使用时可以直接使用类名进行调用--Arrays.方法(详情可见jdk帮助文档)

int[] a = {1,2,3,4,236,650,895,0,7,5};
//打印数组元素
System.out.println(a);  //直接打印，(hashcode)结果：[I@76ed5528
System.out.println(Arrays.toString(a)); //Arrays类的方法，输出数组元素，很方便！！！
 Arrays.sort(a);  //对数组a进行排序，默认升序
 Arrays.fill(a,2,4,0); //数组填充，2到4之间用0填充

• 冒泡排序：可以通过加一个flag标识为优化，减少无意义的比较

  public static int[] sort(int[] array){
          int temp = 0;
          boolean flag = false; //通过flag标识位减少无意义的比较，可以优化
          //外层循环，判断要走多少次
          for (int i = 0; i < array.length-1; i++) {
               //内层循环，判断每次要干嘛，如果后一个比前一个小，交换位置
               for (int j = 0; j < array.length-1-i; j++) {
                   if(array[j+1] < array[j]){
                       temp = array[j+1];
                       array[j+1] = array[j];
                       array[j] = temp;
                       flag = true;
                        }
                  if(!flag){
                      break;
                  }
                   
               }
               }
          return array;
      }
  

  ​

稀疏数组

• 一个数组中大部分元素为0，或为同一值，可用稀疏数组来保存

• 处理方式：

  1）记录以共几行几列，有多少个不同的值（不包含0）；

  2）把不同值元素的行列及值记录在一个数组中，可缩小程序规模；

• 代码：稀疏数组固定为3列，分别为：行，列，值；有sum个不同的值，那么就有sum+1行（第一行保存总共几行几列几个值）

  //转换为稀疏数组
         //遍历获取有效值个数
          int sum = 0;
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  if (array[i][j] != 0) {
                      sum++;
                  }
              }
          }
          System.out.println("有效值个数为" + sum);
          //创建一个稀疏数组
          int[][] array2 = new int[sum + 1][3];
          //赋值--给第一行赋值（初始数组有几行几列，几个有效值）
          array2[0][0] = 11;
          array2[0][1] = 11;
          array2[0][2] = sum;
          //遍历二维数组，将非0的值存入稀疏数组中
          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) {
                      count++;    //第几个数不为0，他就在系数矩阵的第几行
                      array2[count][0] = i;   //该行第0列存放在原始数组中的行数
                      array2[count][1] = j;   //该行第1列存放在原始数组中的列数
                      array2[count][2] = array[i][j]; //该行第2列存放在原始数组中的值
                  }
              }
  
          }
          //输出稀疏数组
          for (int i = 0; i < sum + 1; i++) {
  //            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
              for (int j = 0; j <3 ; j++) {
                  System.out.print(array2[i][j]+"\t");
  
              }
              System.out.println();
          }
  

  ​

  ​