2.java基本语法(二)

java过程控制

1.Scanner对象

一般输入

import java.util.Scanner;

Scanner类可以用来获取用户输入

Scanner  in=new Scanner(System.in)

public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
    
        System.out.println("使用next方式接收");
        String str=scanner.nextLine();   //也可以使用next()
        System.out.println("输出的内容为"+str);

        scanner.close();
    }

next():

1. 一定要读取到有效字符后才可以结束输入
2. 对输入有效字符之前遇到的空包，next()方法会自动将其去掉
3. 只有输入有效字符后才会把其后面输入的空白符作为分隔符或者结束符
4. next()不能获取带空格的字符串

nextLine():

1. 以Enter作为结束符，返回的是输入回车之前的所有字符
2. 可以获取带空格的字符串

例如：同样输入"hello world"。next()返回"hello"，nextLine()返回"hello world"

可参考博客：https://blog.csdn.net/gao_zhennan/article/details/80562548?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.opensearchhbase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.opensearchhbase

个人感觉方法名里的"next"是当前指针所指的位置，而不是这个指针的下一个位置。

带判断的输入

public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        int i=0;
        float f=0.0f;
        System.out.println("请输入一个数：");

        if(scanner.hasNextInt()){
            i= scanner.nextInt();
            System.out.println("整数数据："+i);
        }
        else System.out.println("输入的不是一个整数");

        //假如上一个输入不是整数，那么i不会被赋值，scanner中的内容不会被取出，会留到接下来的分支中
        System.out.println("请输入一个小数：");
        if(scanner.hasNextFloat()) {
            f= scanner.nextFloat();
            System.out.println("小数数据："+f);
        }
        else System.out.println("输入的不是一个小数");
        scanner.close();
    }

• hasNext（） 是检测 还有没有下一个输入，没有则会等待输入
• next（）是指针移动到当前下标，并取出下一个输入
• nextLine（） 把指针移动到下一行 让然后取出当前这一行的输入
• hasNextLine（） 是检测下一行有没有输入，没有则会等待输入

hasNextInt()等方法与上述方法类似。

2.顺序、循环、分支

大部分和C++无区别

值得注意的是 对于while语句，C++可以这样写

int m=10;
while(m--){
    //statements
}//C++会默认把m的值转成bool类型，m==0返回true

但是java中不能这样写，必须严格返回一个boolean值。

同样，C++中可以用while(1)表示死循环，java必须用while(true)。

java的switch用法跟C++相同，不过java的switch中的case可以判断String类型

java的for还有另一种用法（C++其实也有）

int[] nums={1,2,3,4,5};
for(int x:nums){
	//statements
}

java方法

方法即函数。定义、用法和C++大体相同。

参数传递	方式
值传递	传入函数的参数是一个备份
引用传递	传入函数的参数是一个引用地址

关于参数传递更详细的解释可以参考https://www.zhihu.com/question/385114001

1.重载

重载规则：

1. 方法名相同
2. 参数列表必须不同(个数不同、或类型不同、或参数排列顺序不同等)
3. 不区分返回类型

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去诸葛匹配，以选择对应的方法，如果匹配失败，则编译器报错。

2.可变参数

又称不定项参数，目的是使一个函数可以灵活处理不确定数量的参数。

函数声明时，在指定参数类型后加一个省略号(…)

public static void printMax(double... numbers)
    
//numbers使用时可以当成数组用，可以通过numbers.length获取参数的数量

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

数组

1.1.声明

一维数组

以下两种声明方式等价

int[] a;
int a[];

使用new操作符创建数组

dataType[] arrayRefvar=new dataType[arrRefvar];
    
int[] a=new int[10];  //定长声明

静态初始化

int[] a={1,2,3,4,5};
Animal x={new Animal(),new Animal};

动态初始化

int[] b=new int[10];  //b的元素会有默认值

1.2.多维数组

int[][] a=new int[r][c];  //int[行数][列数]

int[][] array={{1,2},{2,3},{3,4},{4,5}};

2.java内存初步

堆：

1. 存放new的对象和数组
2. 可以被所有的线程共享，不会被别的对象引用

栈：

1. 存放基本变量类型(会包含这个基本类型的具体数值)
2. 引用对象的变量(会存放这个引用在堆里面的具体地址)

方法区：

1. 可以被所有的线程共享
2. 包含了所有的class和static变量

3.传参

public int function(int[] array);

4.Arrays类

java.util.Arrays

例

public static void main(String[] args) {
        int a[]={1,2,3,4,5};
        System.out.println(Arrays.toString(a));
}

输出如下

public static void main(String[] args) {
        int a[]={5,2,9,4,5};
    	Arrays.sort(a);    //升序排序
        System.out.println(Arrays.toString(a));
}

更多具体方法见官方文档，也可以直接进入Arrays类查看具体实现

5.稀疏数组(数组练习)

如果一个大型数组中0元素过多，称之为稀疏数组，此时没有必要存储它的所有制，只用存储非0值的相关信息即可。

public static void main(String[] args) {
        //创建二维数组11*11    0：没有棋子   1：黑子   2：白子
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=1;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                System.out.print(array1[i][j]+" ");
            }
            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++;
            }
        }

        //创建一个稀疏数组的数组
        /*
        * array[0][0]存储行数，array[0][1]存储列数，array[0][2]存储非0元素的个数，
        * 另外，对于array2除了第0行的每一行array2[i]
        * array[i][0]存储非0元素所在的行
        * array[i][1]存储非0元素所在的列
        * array[i][2]存储非0元素的值
        */
        int[][] array2=new int[sum+1][3];
        array2[0][0]=array2[0][1]=11;
        array2[0][2]=sum;

        int count=0;

        for(int i=0;i<array1.length;i++){
            for(int j=0;j<array1.length;j++){
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for(int i=0;i<array2.length;i++){
            System.out.println(Arrays.toString(array2[i]));
        }
        //=========================//
        System.out.println("================================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];

        //2.还原值
        for(int i=1;i<array2.length;i++){
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }

        System.out.println("输出还原的数组");
        for(int i=0;i<11;i++){
            System.out.println(Arrays.toString(array3[i]));
        }
    }

输出如下