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

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

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

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

            1. 输入必需要使用的包

    import java.util.Scanner;

            2. 输入一个整型数值

    1. import java.util.Scanner;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);
    5.         int a = sc.nextInt();
    6.         System.out.println(a);
    7.     }
    8. }

            3. 输入一组整型数值

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

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

    1. import java.util.Scanner;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);
    5.         float a = sc.nextFloat();
    6.         System.out.println(a);
    7.     }
    8. }

            5. 输入一个字符串

    1. import java.util.Scanner;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);
    5.         String a = sc.nextLine();
    6.         System.out.println(a);
    7.     }
    8. }

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

    二、输出

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

            整型数据的输出，

            浮点型数据的输出，

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

            以及字符串的输出

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

            程序输出

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

    三、动态数组/列表

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

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

    1. import java.util.Scanner;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);    // 设置一个Scanner对象
    5.         int m = sc.nextInt();                   // 输入数组长度m
    6.         int []array = new int[m];               // 分配一个长度为m的动态数组
    7.         for(int i=0; i// 输入m个数字
    8.             array[i] = sc.nextInt();
    9.         }
    10.         for(int i=0; i// 输出
    11.             System.out.printf("%d ", array[i]);
    12.         }
    13.     }
    14. }

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

    1. 3
    2. 1 2 3
    3. 1 2 3

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

    1. import java.util.Scanner;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         Scanner sc = new Scanner(System.in);    // 设置一个Scanner对象
    5.         int m = sc.nextInt();                   // 输入行数m
    6.         int n = sc.nextInt();                   // 输入列数n
    7.         int [][]array = new int[m][n];          // 分配一个行数为m、列数为n的动态数组
    8.         for(int i=0; i// 输入m行n列个数字
    9.             for (int j=0; j
    10.                 array[i][j] = sc.nextInt();
    11.             }
    12.         }
    13.         for(int i=0; i// 输出
    14.             for (int j=0; j
    15.                 System.out.printf("%d ", array[i][j]);
    16.             }
    17.             System.out.printf("\n");
    18.         }
    19.     }
    20. }

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

    1. 3 2
    2. 1 99
    3. 2 100
    4. 3 101
    5. 1 99 
    6. 2 100 
    7. 3 101

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

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

    import java.util.ArrayList;

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

    1. import java.util.ArrayList;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         ArrayList list = new ArrayList<>();
    5.         // 增加item(分别追加0、1、2、3)
    6.         list.add(0);                         // 传入的参数为Integer对象
    7.         list.add(1);
    8.         list.add(2);
    9.         list.add(3);
    10.         output_list(list);
    11.         // 删除item(即删除最后一个item)
    12.         list.remove(list.size()-1);          // 传入的参数为index
    13.         output_list(list);
    14.         // 改变item(改变最后一个元素的值为999)
    15.         list.set(list.size()-1, 999);        // 传入的参数分别为index、new value
    16.         output_list(list);
    17.         // 查询item：一种是通过下标，另外一种是自己遍历匹配查询，这里用的是前者
    18.         System.out.printf("%d", list.get(0));// 查询index为0的元素
    19.     }
    20.  
    21.     // 遍历list
    22.     public static void output_list(ArrayList list){
    23.         int n = list.size();
    24.         for (int i=0; i
    25.             System.out.printf("%d ", list.get(i));
    26.         }
    27.         System.out.printf("\n");
    28.     }
    29. }

            程序输出

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

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

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

            入队、出队示例

    1. import java.util.ArrayList;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         ArrayList queue = new ArrayList<>();
    5.         // 689、999、9999依次入队
    6.         queue.add(689);
    7.         queue.add(999);
    8.         queue.add(9999);
    9.         output_list(queue); // 输出一下queue(实际上queue不能这样输出，因为它是队列)
    10.         // 出队
    11.         queue.remove(0);
    12.         output_list(queue); // 输出一下queue(实际上queue不能这样输出，因为它是队列)
    13.     }
    14.  
    15.     // 遍历list
    16.     public static void output_list(ArrayList list){
    17.         int n = list.size();
    18.         for (int i=0; i
    19.             System.out.printf("%d ", list.get(i));
    20.         }
    21.         System.out.printf("\n");
    22.     }
    23. }

            程序输出

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

            5. 栈（通过列表拓展）

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

            入栈、出栈示例

    1. import java.util.ArrayList;
    2. public class Enter {
    3.     public static void main(String[] args) {
    4.         ArrayList stack = new ArrayList<>();
    5.         // 689、999、9999依次入栈
    6.         stack.add(689);
    7.         stack.add(999);
    8.         stack.add(9999);
    9.         output_list(stack); // 输出一下stack(实际上stack不能这样输出，因为它是栈)
    10.         // 出栈
    11.         stack.remove(stack.size()-1);
    12.         output_list(stack); // 输出一下stack(实际上stack不能这样输出，因为它是栈)
    13.     }
    14.  
    15.     // 遍历list
    16.     public static void output_list(ArrayList list){
    17.         int n = list.size();
    18.         for (int i=0; i
    19.             System.out.printf("%d ", list.get(i));
    20.         }
    21.         System.out.printf("\n");
    22.     }
    23. }

            输出

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

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

            三者之间的相互转换

    1. public class Enter {
    2.     public static void main(String[] args) {
    3.         // int转float
    4.         int int_a = 100;
    5.         float float_a = (float) int_a;
    6.         System.out.printf("int转float：a=%d，转换后，a=%f\n", int_a, float_a);
    7.  
    8.         // float转int
    9.         float float_b = 2.34f;
    10.         int int_b = (int) float_b;
    11.         System.out.printf("float转int：b=%f，转换后，b=%d\n", float_b, int_b);
    12.  
    13.         // int转String
    14.         int int_c = 1099;
    15.         String string_c = String.valueOf(int_c);
    16.         System.out.printf("int转String：c=%d，转换后，c=%s\n", int_c, string_c);
    17.  
    18.         // String转int
    19.         String string_d = "2048";
    20.         int int_d = Integer.valueOf(string_d);
    21.         System.out.printf("String转int：d=%s，转换后，d=%d\n", string_d, int_d);
    22.  
    23.         // float转String
    24.         float float_e = 88.88f;
    25.         String string_e = String.valueOf(float_e);
    26.         System.out.printf("float转String：e=%f，转换后，e=%s\n", float_e, string_e);
    27.  
    28.         // String转float
    29.         String string_f = "99.99";
    30.         float float_f = Float.valueOf(string_f);
    31.         System.out.printf("String转float：f=%s，转换后，f=%f\n", string_f, float_f);
    32.     }
    33. }

            程序输出

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

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

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

    1. public class Enter {
    2.     public static void main(String[] args) {
    3.         String a_str = "Hello world!";
    4.         int n = a_str.length();
    5.         for (int i=0; i
    6.             System.out.printf("%c", a_str.charAt(i));
    7.         }
    8.     }
    9. }

            程序输出

    Hello world!

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

    1. public class Enter {
    2.     public static void main(String[] args) {
    3.         String a = "Hello";
    4.         String b = " world";
    5.         String c = a + b;
    6.         System.out.printf("a=%s, b=%s, c=%s", a, b, c);
    7.     }
    8. }

            程序输出

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

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

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

            程序输出

    1. Hello,
    2. I
    3. am
    4. a
    5. student.

  • 相关阅读:
    RabbitMQ如何确保消息发送和消息接收
    音视频学习 - windows10 + vs2019环境编译ffmpeg
    低版本浏览器使用最新渲染模式以免IE不支持CSS3属性
    C/C++陷阱——临时变量的产生和特性
    【Python学习笔记】Python中的heapq
    【mysql】ssl_choose_client_version:unsupported protocol
    C++贪心算法之乘船问题
    带刹车死区的互补输出与捕获实验
    bson数据通过BulkOperations批量入库mongo表报重复ID处理
    如何使用Solidity和Hardhat构建你自己的NFT以及NFT交易市场
  • 原文地址：https://blog.csdn.net/qq_36158230/article/details/126714746