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 2
1 99
2 100
3 101
1 99
2 100
3 101 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的元素04. 队列（通过列表拓展）
队列的思想是先进先出。如果通过列表实现队列的话，那么，可以将列表的第一个元素定义为队头，最后一个元素定义为队尾。此时，入队操作为，向列表追加一个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 world3. 分割，例如按照空格" "分割，重点在于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.
1855
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
