狂神说java流程方法数组笔记

1.流程

1.Scanner对象

alt+enter补全语句

public static void main(String[] args) {
        //创建扫描器对象
        Scanner scanner = new Scanner(System.in);
        //判断是否有输入 空格结束
        if (scanner.hasNext()) {
            String str = scanner.next();
            System.out.println("input:"+str);
        }
        //判断是否有输入 回车结束
        if (scanner.hasNextLine()) {
            String str = scanner.nextLine();
            System.out.println("input:"+str);
        }
    
    	//scanner.hasNextInt()
        //IO流的类不关闭会占用资源，养成好习惯
        scanner.close();
    }

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

• next():
  • 一定要读取到有效字符后才可以结束输入。
  • 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
  • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • next() 不能得到带有空格的字符串。
• nextLine():
  • 以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
  • 可以获得空白。

2.switch

注意break;

3.增强for循环

for(int x:nums)针对数组和集合

5.for //快速循环语句，循环5次

4.break，continue

1. break在任何循环语句的主体部分，均可用break控制循环的流程。*break用于强行退出循环，不执行循环中剩余的语句*。(break语句也在switch语句中使用)
2. continue语句用在循环语句体中，*用于终止某次循环过程*，即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
3. 关于goto关键字 goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的- 个保留字，但并未在语言中得到正式使用; Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子——带标签的break和continue.
   • “标签” 是指后面跟一个冒号的标识符，例如: label:
   • 对Java来说唯一 用到标签的地方是在循环语句之前。 而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

2.方法

就是函数

1.参数

形参，用来占位，定义作用的

实参，实际调用时传递给方法的参数

值传递，不改变实参的值，c++用指针，引用传递

2.方法重载

一个类的两个方法拥有相同的名字，但是有不同的参数列表。重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。

Java编译器根据方法签名判断哪个方法应该被调用。

3.命令行传参数的使用

main方法传参

javac Demo01.java //编译class文件 跳转到java文件目录

java 包名.Demo01 参数my name is //执行 必须跳转到包目录的上一层

4.构造方法 == 默认构造函数

5.可变参数

1. JDK 1.5开始，Java支持传递同类型的可变参数（不定项）给一个方法。

2. 在方法声明中，在指定参数类型后加一个省略号(…)。

   public static void printMax(double... numbers) {
   public static double add(int a, double... nums){
       
   //调用可变参数的方法
   printMax(15,22.0,36,25.3);
   printMax(new double[]{1, 2, 3});//本质为数组
   add(2,2.2,3.3,4.4)
   

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

3.数组

c++中vector，c中arr[]

3.1声明数组

double[] myList;         // 首选的方法  或  
double myList[];         //  效果相同，但不是首选方法

3.2创建数组

arrayRefVar = new dataType[arraySize];
//一、使用 dataType[arraySize] 创建了一个数组。
//二、把新创建的数组的引用赋值给变量 arrayRefVar。

3.3声明和创建

dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};//方法2

3.4数组赋值

arrayRefVar[0]=1;

3.5初始化

静态初始化   
int[] a = {1,2,3};
Man[] mans = {new Man(1,1) , new Man(2,2)};
 
动态初始化  
int[] a = new int[2]; 
a[0]=1;
a[1]=2;
 
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

3.6数组的四个基本特点

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

3.7多维数组

type[][] typeName = new type[typeLength1][typeLength2];

从最高维开始，分别为每一维分配空间，例如：

String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

3.8Array类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

int[] nums = {1,2,3,5,4};
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));

3.9稀疏数组

1. 当一个数组中大部分元素为0,或者为同一-值的数组时，可以使用稀疏数组来保存该数组。
2. 稀疏数组的处理方式是:
   • 记录数组一共有几行几列，有多少个不同值
   • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

package scanner;

/**
 * @author UNCLE
 * @company IDEAL
 * @create 2021-04-20 20:13
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建一个元素的二维数组 11*11  0：没有棋子 1： 黑棋   2： 白棋
        int chessArry1[][] = new int[11][11];
        chessArry1[1][2] = 1;
        chessArry1[2][3] = 2;
        for (int [] row : chessArry1) {
            for ( int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        int[][] paraseArr =  transformSparseArr(chessArry1);
        transformArry(paraseArr);
    }
    //二维数组 转 稀疏数组
    public static int[][] transformSparseArr( int[][] arry) {
        int sum =0;  // 有效值的个数
        int rowSize = 0;
        //1、计算出有效的个数
        for (int[] row :arry) {
            for ( int data :row) {
                rowSize = row.length;
                if (data != 0) {
                    sum++;
                }
            }
        }
        //创建稀疏数组 并给稀疏数组赋值
        int [][] sparseArr= new int[sum+1][3];
        sparseArr [0][0] = arry.length;
        sparseArr [0][1] = rowSize;
        sparseArr [0][2] = sum;
        //count 计数器 计算放入的有效个数 即第几个非零数据
        int count = 0;
        for (int i = 0; i < arry.length; i++) {
            for (int j = 0; j < rowSize ; j++) {
                if (arry[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arry[i][j];
                }
            }
        }
        // 输出稀疏数组形式
        System.out.println("===========稀疏数组============");
        for (int i = 0; i < sparseArr.length; i++) {
            // %d 占位符 \t 制表符  \n 换行
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        System.out.println();
        return sparseArr;
    }
    // 稀疏数组 转化为 二维数组
    public static int[][] transformArry(int[][] parseArr) {
        int row = parseArr[0][0]; //得到行
        int col = parseArr[0][1]; //得到列
        //数组恢复 并赋值
        int[][] arry = new int[row][col];
        for (int i = 1 ; i < parseArr.length; i++) {
            arry[parseArr[i][0]][parseArr[i][1]] = parseArr[i][2];
        }
        // 输出
        System.out.println("============二维数组恢复==============");
        for (int [] rows: arry) {
            for (int data : rows) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        return arry;
    }

}