Java程序输入、输出、动态数组、列表、类型转换、字符串遍历

Java介绍（这里可以跳过不看，写这部分的原因主要是避免CSDN那不聪明的发文助手）：Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

在平时，我们也经常会用到Java，有时我们可能会用它来写一个动态Web应用，或者移动端APP应用，又或者是在Leecode上面刷题。然而，在入门Java时，我们会经常遇到下面的问题，因此，我这里做一个简单的小总结。

一、输入（经测试代码复制可直接运行，可根据需求自行修改）

1. 输入必需要使用的包

import java.util.Scanner;

2. 输入一个整型数值

import java.util.Scanner;
public class Enter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        System.out.println(a);
    }
}

3. 输入一组整型数值

import java.util.Scanner;
public class Enter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = 3;
        int []a = new int[m];       // 定义长度为m的一维数组
        for (int i=0; i<m; i++){    // 循环输入m个数
            a[i] = sc.nextInt();
        }
        System.out.printf("%d %d %d\n", a[0], a[1], a[2]);
    }
}

4. 输入一个浮点数值（输入一组浮点数值的做法请参考上面int类型的数据）

import java.util.Scanner;
public class Enter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        float a = sc.nextFloat();
        System.out.println(a);
    }
}

5. 输入一个字符串

import java.util.Scanner;
public class Enter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine();
        System.out.println(a);
    }
}

注意事项：Scanner对象接收字符串。我建议，在接收数值型数据的时候，用同一个Scanner对象来接收。在需要接收字符串的时候，再new一个Scanner对象，用来专门接收字符串。否则，输入的时候可能会遇到奇奇怪怪的问题。

二、输出

1. 格式化输出（我这里强烈建议，掌握下面这个即可），下面的代码包括了

整型数据的输出，

浮点型数据的输出，

自定义小数位浮点型数据的输入，

以及字符串的输出

public class Enter {
    public static void main(String[] args) {
        int a = 10;
        float b = 1.0f;
        String c = "Hello world!";
        System.out.printf("a=%d, b=%f, b=%.3f, c=%s", a, b, b, c);
    }
}

程序输出

a=10, b=1.000000, b=1.000, c=Hello world!

三、动态数组/列表

1. 一维动态数组，以及它的输入方法

需求来自：例如我输入一个数值m，希望分配给我一个长度为m的动态数组。

import java.util.Scanner;
public class Enter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);    // 设置一个Scanner对象
        int m = sc.nextInt();                   // 输入数组长度m
        int []array = new int[m];               // 分配一个长度为m的动态数组
        for(int i=0; i<m; i++){                 // 输入m个数字
            array[i] = sc.nextInt();
        }
        for(int i=0; i<m; i++){                 // 输出
            System.out.printf("%d ", array[i]);
        }
    }
}

程序输出(前两行是输入，最后一行是输出)

3
1 2 3
1 2 3

2. 二维动态数组，以及它的输入方法

import java.util.Scanner;
public class Enter {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);    // 设置一个Scanner对象
        int m = sc.nextInt();                   // 输入行数m
        int n = sc.nextInt();                   // 输入列数n
        int [][]array = new int[m][n];          // 分配一个行数为m、列数为n的动态数组
        for(int i=0; i<m; i++){                 // 输入m行n列个数字
            for (int j=0; j<n; j++){
                array[i][j] = sc.nextInt();
            }
        }
        for(int i=0; i<m; i++){                 // 输出
            for (int j=0; j<n; j++){
                System.out.printf("%d ", array[i][j]);
            }
            System.out.printf("\n");
        }
    }
}

程序输出(前面四行是输入，最后三行是输出)

3. 列表（可视为一种动态数组）

必需要使用的包（会用一种即可，我推荐使用ArrayList）

import java.util.ArrayList;

追加、删除、改变、查找一个item，以及list的遍历

import java.util.ArrayList;
public class Enter {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        // 增加item(分别追加0、1、2、3)
        list.add(0);                         // 传入的参数为Integer对象
        list.add(1);
        list.add(2);
        list.add(3);
        output_list(list);
        // 删除item(即删除最后一个item)
        list.remove(list.size()-1);          // 传入的参数为index
        output_list(list);
        // 改变item(改变最后一个元素的值为999)
        list.set(list.size()-1, 999);        // 传入的参数分别为index、new value
        output_list(list);
        // 查询item：一种是通过下标，另外一种是自己遍历匹配查询，这里用的是前者
        System.out.printf("%d", list.get(0));// 查询index为0的元素
    }

    // 遍历list
    public static void output_list(ArrayList<Integer> list){
        int n = list.size();
        for (int i=0; i<n; i++){
            System.out.printf("%d ", list.get(i));
        }
        System.out.printf("\n");
    }
}

程序输出

0 1 2 3 // 分别追加 0、1、2、3
0 1 2   // 删除最后一个元素3
0 1 999 // 更新最后一个元素2的值更新为999
0       // 查询index=0的元素0

4. 队列（通过列表拓展）

队列的思想是先进先出。如果通过列表实现队列的话，那么，可以将列表的第一个元素定义为队头，最后一个元素定义为队尾。此时，入队操作为，向列表追加一个item；出队操作为，删除列表的第一个item。

入队、出队示例

import java.util.ArrayList;
public class Enter {
    public static void main(String[] args) {
        ArrayList<Integer> queue = new ArrayList<>();
        // 689、999、9999依次入队
        queue.add(689);
        queue.add(999);
        queue.add(9999);
        output_list(queue); // 输出一下queue(实际上queue不能这样输出，因为它是队列)
        // 出队
        queue.remove(0);
        output_list(queue); // 输出一下queue(实际上queue不能这样输出，因为它是队列)
    }

    // 遍历list
    public static void output_list(ArrayList<Integer> list){
        int n = list.size();
        for (int i=0; i<n; i++){
            System.out.printf("%d ", list.get(i));
        }
        System.out.printf("\n");
    }
}

程序输出

689 999 9999 // 顺序执行3次入队
999 9999     // 执行1次出队

5. 栈（通过列表拓展）

栈的思想是先进后出。如果通过列表实现栈的话，那么，可以将列表的最后一个元素定义为栈顶。此时，入栈操作为，向列表追加一个item；入栈操作为，删除列表的最后一个item。

入栈、出栈示例

import java.util.ArrayList;
public class Enter {
    public static void main(String[] args) {
        ArrayList<Integer> stack = new ArrayList<>();
        // 689、999、9999依次入栈
        stack.add(689);
        stack.add(999);
        stack.add(9999);
        output_list(stack); // 输出一下stack(实际上stack不能这样输出，因为它是栈)
        // 出栈
        stack.remove(stack.size()-1);
        output_list(stack); // 输出一下stack(实际上stack不能这样输出，因为它是栈)
    }

    // 遍历list
    public static void output_list(ArrayList<Integer> list){
        int n = list.size();
        for (int i=0; i<n; i++){
            System.out.printf("%d ", list.get(i));
        }
        System.out.printf("\n");
    }
}

输出

689 999 9999 // 顺序执行3次入栈
689 999      // 执行1次出栈

四、强制类型转换int、float、String

三者之间的相互转换

public class Enter {
    public static void main(String[] args) {
        // int转float
        int int_a = 100;
        float float_a = (float) int_a;
        System.out.printf("int转float：a=%d，转换后，a=%f\n", int_a, float_a);

        // float转int
        float float_b = 2.34f;
        int int_b = (int) float_b;
        System.out.printf("float转int：b=%f，转换后，b=%d\n", float_b, int_b);

        // int转String
        int int_c = 1099;
        String string_c = String.valueOf(int_c);
        System.out.printf("int转String：c=%d，转换后，c=%s\n", int_c, string_c);

        // String转int
        String string_d = "2048";
        int int_d = Integer.valueOf(string_d);
        System.out.printf("String转int：d=%s，转换后，d=%d\n", string_d, int_d);

        // float转String
        float float_e = 88.88f;
        String string_e = String.valueOf(float_e);
        System.out.printf("float转String：e=%f，转换后，e=%s\n", float_e, string_e);

        // String转float
        String string_f = "99.99";
        float float_f = Float.valueOf(string_f);
        System.out.printf("String转float：f=%s，转换后，f=%f\n", string_f, float_f);
    }
}

程序输出

int转float：a=100，转换后，a=100.000000
float转int：b=2.340000，转换后，b=2 // 如果b=-2.34，转int后，b=-2
int转String：c=1099，转换后，c=1099
String转int：d=2048，转换后，d=2048
float转String：e=88.879997，转换后，e=88.88
String转float：f=99.99，转换后，f=99.989998

五、字符串：遍历、拼接、分割

1. 字符串是Leecode经常遇到的考察内容，遍历重点在于charAt()方法和length()方法

public class Enter {
    public static void main(String[] args) {
        String a_str = "Hello world!";
        int n = a_str.length();
        for (int i=0; i<n; i++){
            System.out.printf("%c", a_str.charAt(i));
        }
    }
}

程序输出

Hello world!

2. 拼接，例如"hello"和"world"拼接在一起得到"hello world"。会一种即可，直接使用“+”操作。

public class Enter {
    public static void main(String[] args) {
        String a = "Hello";
        String b = " world";
        String c = a + b;
        System.out.printf("a=%s, b=%s, c=%s", a, b, c);
    }
}

程序输出

a=Hello, b= world, c=Hello world

3. 分割，例如按照空格" "分割，重点在于split()方法和数组的length属性。

public class Enter {
    public static void main(String[] args) {
        String a = "Hello, I am a student.";
        String[] split_result = a.split(" ");
        int n_part = split_result.length;
        for (int i=0; i< n_part; i++){
            System.out.printf("%s\n", split_result[i]);
        }
    }
}

程序输出

Hello,
I
am
a
student.