JAVA

有两大类核心技术:

  • javaSE:普通的桌面应用 控制台
  • javaEE:开发网站

0x00.基本认识

JDK vsJRE

JDK(Java Development Kit)

作用:JDK 是用于开发 Java 程序的工具包,它不仅包含 JRE,还包含编译和调试工具。

组成

  • JRE:包含执行 Java 应用程序所需的所有环境。
  • 编译器(javac):将 Java 源代码编译为字节码(.class 文件)。
  • 工具(如调试器、解释器):用于开发、编译、打包和调试 Java 程序的工具。
  • :提供用于开发应用程序的标准 Java 类库。

总结:JDK 是一个完整的开发工具包,适合开发人员使用,允许编写、编译、调试和运行 Java 程序。

JRE(Java Runtime Environment)

  • 作用:JRE 是运行 Java 程序所需的环境,它提供了执行 Java 应用程序的基础环境,但不包括编译器等开发工具。
  • 组成:
    • Java 虚拟机(JVM):用于执行 Java 字节码的虚拟机。
    • 类库:支持 Java 程序运行的核心库(标准类库,如 Java API)。
    • 其他资源:如支持图形界面的类等。

总结:JRE 是一个运行环境,只适合运行现有的 Java 应用程序,而不适合用于开发。

结构

project --> module --> package --> class

字节码文件

字节码文件(bytecode file)是源代码编译后生成的一种中间代码文件,它是一种低级的、与平台无关的代码表示形式。字节码文件通常无法直接由计算机硬件执行,但可以被特定的虚拟机(如 Java 虚拟机 JVM 或 Python 的解释器)读取和执行。

0x01.基础语法

输入输出

1
2
3
4
public static void main(String[] args){
System.out.println("first try");//打印完换行
System.out.print("first try"); //打印完不换行
}
1
2
3
4
5
6
Scanner input = new Scanner(System.in);//创建扫描仪对象
int num = input.nextInt();//接受int型输入
float f=input.nextFloat();//float

String res = String.format("%.2f",f);//格式化控制
System.out.printf("%.2f",f);

Scanner 是一个类,它位于 java.util 包中Scanner 类用于从各种输入源读取数据,比如从控制台、文件、字符串等读取用户输入或数据。

常用的 Scanner 方法

Scanner 类提供了多种方法来读取不同类型的数据,包括 next() 系列方法和 hasNext() 系列方法。以下是一些常用方法:

  1. nextLine()

    • 读取整行的字符串输入,直到检测到换行符(Enter)。
    • 示例:
      1
      2
      3
      Scanner scanner = new Scanner(System.in);
      String line = scanner.nextLine();
      System.out.println("You entered: " + line);
  2. next()

    • 读取一个字符串,以空格或换行符作为分隔符,读取到第一个空格前的数据。
    • 示例:
      1
      2
      3
      Scanner scanner = new Scanner(System.in);
      String word = scanner.next();
      System.out.println("First word: " + word);
  3. nextInt()

    • 读取一个整数类型的数据。
    • 示例:
      1
      2
      3
      Scanner scanner = new Scanner(System.in);
      int number = scanner.nextInt();
      System.out.println("You entered number: " + number);
  4. nextDouble()

    • 读取一个双精度浮点类型的数据。
    • 示例:
      1
      2
      3
      Scanner scanner = new Scanner(System.in);
      double num = scanner.nextDouble();
      System.out.println("You entered double: " + num);
  5. hasNext()

    • 判断是否还有下一个输入项(通常用于循环读取)。
    • 示例:
      1
      2
      3
      4
      Scanner scanner = new Scanner(System.in);
      while (scanner.hasNext()) {
      System.out.println(scanner.next());
      }
  6. hasNextInt()

    • 判断下一个输入项是否为整数类型。
    • 示例:
      1
      2
      3
      4
      5
      Scanner scanner = new Scanner(System.in);
      if (scanner.hasNextInt()) {
      int num = scanner.nextInt();
      System.out.println("You entered an integer: " + num);
      }
  7. hasNextDouble()

    • 判断下一个输入项是否为双精度浮点类型。
  8. useDelimiter(String pattern)

    • 设置扫描器的分隔符,默认是空格,可以通过这个方法来设置自定义的分隔符。
    • 示例:
      1
      2
      3
      4
      5
      Scanner scanner = new Scanner("apple,banana,orange");
      scanner.useDelimiter(",");
      while (scanner.hasNext()) {
      System.out.println(scanner.next());
      }

选择结构

if结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Scanner input = new Scanner(System.in);
int score = input.nextInt();
if(score>=60)
System.out.println("pass!");
else
System.out.println("fail!");
/*多重if-else*/
int score = input.nextInt();
if(score<60)
System.out.println("go out!");
else if(score<90)
System.out.println("good job!");
else
System.out.println("wonderful job!");

switch选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Main {
public static void main(String[] args) {
int day = 3;
switch (day) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("Thursday");
break;
case 5:
System.out.println("Friday");
break;
default:
System.out.println("Weekend");
}
}
}

switch 语句的条件只能是整数、枚举、字符或字符串等有限的数据类型,无法处理更复杂的条件表达式

循环结构

for循环

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("i = " + i);
}
}
}

while循环

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args) {
int i = 0;
while (i < 5) {
System.out.println("i = " + i);
i++;
}
}
}

do-while循环

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args) {
int i = 0;
do {
System.out.println("i = " + i);
i++;
} while (i < 5);
}
}

break:立即退出整个循环,跳到循环后面的代码继续执行。

continue:跳过当前循环的剩余部分,直接进行下一次循环判断

tips:随机数 Random

1
2
3
4
import java.util.Random;
------------------------------------
Random r =new Random();
int score = r.nextInt(100);//[0,100)

java Random

0x02.数据结构

数组

Java 中的数组是用于存储固定大小的相同类型元素的集合。数组中的每个元素都通过索引访问,并且索引从 0 开始。

数组声明

在 Java 中,声明一个数组的方式如下:

1
2
3
4
5
// 语法1:数据类型[] 数组名;
int[] array1;

// 语法2:数据类型 数组名[];
int array2[];

两种方式都可以声明数组,不过第一种更常见。

数组初始化

数组声明后可以通过两种方式初始化:静态初始化动态初始化

  1. 静态初始化:在声明时直接给定数组的初始值。

    1
    2
    int[] array = new int[]{1, 2, 3, 4, 5};
    int[] array = {1, 2, 3, 4, 5}; // 静态初始化,长度为5
  2. 动态初始化:先指定数组的长度,再赋值。

    1
    2
    3
    int[] array = new int[5];  // 动态初始化,创建长度为5的数组
    array[0] = 1; // 为第一个元素赋值
    array[1] = 2; // 为第二个元素赋值

访问数组元素

数组中的每个元素通过索引来访问,索引从 0 开始。例如:

1
2
3
int[] array = {10, 20, 30, 40, 50};
System.out.println(array[0]); // 输出:10
System.out.println(array[4]); // 输出:50

注意:访问越界的索引会抛出 ArrayIndexOutOfBoundsException 异常。

1
System.out.println(array[5]);  // 抛出异常:ArrayIndexOutOfBoundsException

数组的长度

可以通过 .length 属性获取数组的长度(即数组中元素的个数),这是数组的一个固定属性,不会改变。

1
2
int[] array = {10, 20, 30};
System.out.println("Array length: " + array.length); // 输出:3

多维数组

Java 中支持多维数组,最常用的是二维数组,它可以看作是一个数组的数组。二维数组的声明和初始化方式如下:

声明二维数组

1
int[][] matrix;  // 声明一个二维数组

初始化二维数组

  1. 动态初始化二维数组

    1
    int[][] matrix = new int[3][4];  // 创建一个3行4列的二维数组
  2. 静态初始化二维数组

    1
    2
    3
    4
    5
    int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
    };

访问二维数组的元素

二维数组的元素通过两次索引访问:

1
2
System.out.println(matrix[0][0]);  // 输出:1
System.out.println(matrix[2][3]); // 输出:12

非规则数组(稀疏数组)

在 Java 中,可以创建“非规则”的二维数组,即每一行的列数不同:

1
2
3
4
int[][] irregularArray = new int[3][];
irregularArray[0] = new int[2]; // 第一行有2个元素
irregularArray[1] = new int[4]; // 第二行有4个元素
irregularArray[2] = new int[3]; // 第三行有3个元素

拷贝

** System.arraycopy()**

Java 提供了 System.arraycopy() 方法来复制数组的元素:

1
2
3
4
5
6
7
int[] sourceArray = {1, 2, 3, 4, 5};
int[] destArray = new int[5];
System.arraycopy(sourceArray, 0, destArray, 0, sourceArray.length);

for (int i : destArray) {
System.out.println(i); // 输出:1 2 3 4 5
}

**Arrays.copyOf()**

java.util.Arrays 类提供了 copyOf 方法来复制数组。

1
int[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);

排序

Java 提供了内置的 Arrays.sort() 方法,可以快速对数组进行排序。

1
2
3
4
5
6
int[] array = {3, 5, 1, 4, 2};
Arrays.sort(array);

for (int i : array) {
System.out.println(i); // 输出:1 2 3 4 5
}

遍历

使用 for 循环遍历

1
2
3
4
int[] array = {10, 20, 30, 40, 50};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}

使用 for-each 循环遍历

1
2
3
for (int value : array) {
System.out.println(value);
}