图灵日记之java奇妙历险记--输入输出&&方法&&数组

输入输出

输出到控制台

基本语法:
System.out.println(msg); // 输出一个字符串, 带换行
System.out.print(msg); // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出
栗子:

    public static void main(String[] args) {
        System.out.println("2");
        System.out.print("2");
        System.out.printf("%d",2);
    }

转换符 类型
d 十进制整数
x 十六进制整数
o 八进制整数
f 定点浮点数
e 指数浮点数
g 通用浮点数
a 十六进制浮点数
s 字符串
c 字符
b 布尔值
h 散列码
% 百分号

从键盘输入

使用 Scanner 读取字符串/整数/浮点数

    public static void main(String[] args) {
        Scanner Bu = new Scanner(System.in);
        System.out.println("输入字符串");
        String a = Bu.nextLine();
        System.out.println(a);

        System.out.println("输入整数");
        int b = Bu.nextInt();
        System.out.println(b);

        System.out.println("输入小数");
        double c = Bu.nextDouble();
        System.out.println(c);
    }

如上,此处代码可正常运行,但是如果调换顺序的话如何捏

    public static void main(String[] args) {
        Scanner Bu = new Scanner(System.in);
        System.out.println("输入整数");
        int b = Bu.nextInt();
        System.out.println(b);

        System.out.println("输入字符串");
        String a = Bu.nextLine();
        System.out.println(a);

        System.out.println("输入小数");
        double c = Bu.nextDouble();
        System.out.println(c);
    }

类似这样,我们运行会发现字符串根本没有输入,直接跳过,进行下一步操作

问题在于，当你在执行 nextInt() 之后，按下 Enter 键时，输入缓冲区中仍然留有一个换行符（\n）。这会导致在接下来读取字符串时，nextLine() 会读取到这个换行符，并且不会等待用户输入，直接跳过了等待输入字符串的步骤。
为了解决这个问题，你可以在读取整数后添加一个额外的 Bu.nextLine() 来消耗掉那个换行符，然后才读取字符串。

修改如下:

    public static void main(String[] args) {
        Scanner Bu = new Scanner(System.in);
        System.out.println("输入整数");
        int b = Bu.nextInt();
        System.out.println(b);

        Bu.nextLine();
        System.out.println("输入字符串");
        String a = Bu.nextLine();
        System.out.println(a);

        System.out.println("输入小数");
        double c = Bu.nextDouble();
        System.out.println(c);
    }

使用 Scanner 循环读取

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

        while(con.hasNextInt())
        {
            System.out.println(con.nextInt());
        }
    }

持续地读取输入流中的整数，直到输入流结束或者遇到非整数输入为止

猜数字

    public static void main(String[] args) {
    //生成随机数
        Random rondom = new Random();
     	
        Scanner scanner = new Scanner(System.in);

        int rand = rondom.nextInt(100);
        System.out.println("输入数字");
        while(true) {
            int bear = scanner.nextInt();
            if(bear>rand) {
                System.out.println("大了");
            } else if(bear==rand) {
                System.out.println("对了");
                break;
            } else {
                System.out.println("小了");
            }
        }
    }

方法

方法类似于c语言中的函数

方法定义

修饰符 返回值类型 方法名称(参数类型 形参...){
	方法体代码;
	[return 返回值];
}

注意:
1.修饰符:现阶段直接使用public static固定搭配
2. 返回值类型: 如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
3.方法命名: 采用小驼峰命名
3. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
4. 方法体：方法内部要执行的语句
5. 在java当中，方法必须写在类当中
6. 在java当中，方法不能嵌套定义
7. 在java当中，没有方法声明一说

方法调用的执行过程

调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下执行

实参和形参的关系(重要)

Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。形参的名字可以随意
取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。

在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体
注意：对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用

方法重载

类似于c++的函数重载
在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了

注意:
1. 方法名必须相同
2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
3. 与返回值类型是否相同无关
4. 注意:
方法签名：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。

数组

数组的创建

	int[] arr = new int[10];

元素类型[] 数组名 = new 元素类型[长度]

数组的初始化

数组的初始化主要分为动态初始化以及静态初始化。

动态初始化

在创建数组时，直接指定数组中元素的个数

	int[] arr = new int[10];

静态初始化

在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

        int[] arr2 = new int[]{1,2,3};

可以省略后面的new int[]

        int[] arr2 = {1,2,3};

注意:
定义和初始化分成两步

        int[] arr1;
        arr1 = new int[10];
        int[] arr2;
        arr2 = new int[]{1,2,3};

注意:

int[] arr2 = {1,2,3};

省略格式不能分成两步

未对数组初始化,数组元素有默认值
类型 默认值
byte 0
short 0
int 0
long 0
float 0.0f
double 0.0
char /u0000
boolean false
如果数组中存储元素类型为引用类型，默认值为null

数组的使用

元素访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。

        int[] arr = {1,2,3};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //修改
        arr[0] = 100;
        System.out.println(arr[0]);

遍历数组

所谓 “遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作

注意：在数组中可以通过 数组对象.length 来获取数组的长度
循环遍历

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

使用 for-each 遍历数组

        for (int x:arr) {
            System.out.println(x);
        }

数组是引用类型

        int[] arr1 = {1,2,3};
        int[] arr2 = {100};
        arr2 = arr1;
        for (int x:arr2) {
            System.out.println(x);
        }

引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址,通过该
地址，引用变量便可以去操作对象,这是在arr2=arr1未进行时的状态

这是arr2=arr1之后的样子,arr2的引用指向了arr1引用指向的对象,而未被引用指向的原来的arr2的那一块空间,就是如图值是100的那一块区域会被自动释放

null

        int[] arr = null;
        System.out.println(arr.length);

null就是一个不指向任何对象的引用–空引用,类似于c语言的NULL(空指针),但是java并未明确规定null与0号地址有关系,他只是一个不执行任何对象的内存位置,无效的内存位置

注意:
一个引用可以同时指向多个对象?
不能,就好比int a = 0;a=10;a=20;a能存放这三个值吗,显然不可以,同为变量,引用也不可以
指向多个对象
对象能不能指向对象?
哒唛,这也是不可以的,只有引用才能指向对象

数组应用

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        revise1(arr);
        for (int x: arr) {
            System.out.println(x);
        }
        revise2(arr);
        for (int x: arr) {
            System.out.println(x);
        }
    }
    public static void revise1(int[] arr) {
        arr[0] = 100;
    }
    public static void revise2(int[] arr) {
        arr = new int[] {4,5,6};
    }

调用revise1函数,形参引用指向arr对象,通过引用来找到arr对象,修改arr[0]的值

调用revise2函数,new int[] {4,5,6}创建一个数组,是改变形参引用的指向,所以并不会对原数组造成影响

总结: 所谓的 “引用” 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大)

刚才revise2函数未对arr进行修改,大家可以以数组为返回值,接收修改之后的数组

public static void main(String[] args) {
        int[] arr = {1,2,3};
        arr = revise2(arr);
        for (int x: arr) {
            System.out.println(x);
        }
    }
    
    public static int[] revise2(int[] arr) {
        arr = new int[] {4,5,6};
        return arr;
    }

通过接收修改之后的数组,类似于arr2=arr1

数组转字符串

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

Java 中提供了 java.util.Arrays 包,方便打印数组,先将数组转化为字符串类型,然后打印

数组拷贝

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        int[] arr1 = Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(arr1));
    }

copyOf的源码里可以看出,就是把第一个参数是原数组,第二个是长度,用新数组来接收返回值,如果长度大于原数组,int默认初识化为0

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        int[] arr1 = Arrays.copyOf(arr,arr.length+1);
        System.out.println(Arrays.toString(arr1));
    }

        int[] arr = {1,2,3,4,5};
        int[] arr1 = Arrays.copyOfRange(arr,0,arr.length);
        System.out.println(Arrays.toString(arr1));

copyOfRange是赋值某个区间,java表示区间,如上述代码的0,arr.length就是前闭后开,[0,arr.length)

        int[] arr = {1,2,3,4,5};
        int[] arr1 = new int[arr.length];
        System.arraycopy(arr,0,arr1,0,arr.length);
        System.out.println(Arrays.toString(arr1));

`

arraycopy方法的参数,原数组,原数组的起始位置,目标数组,目标数组的起始位置,长度

二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

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

    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6}};
        for (int[] x: arr) {
            for (int y: x) {
                System.out.print(y+" ");
            }
            System.out.println();
        }
    }

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

也可以使用Arrays包里的方法来专门打印二维数组