#看心情

Java入门（超级详细）（二）

Java 入门（超级详细）-CSDN博客

一、数组

1. 什么是数组

2. 声明数组的三种方式

3. 数组的遍历

4. 数组排序

1. 冒泡排序

2. 选择排序

3. 插入排序

5. 数组复制

1. 使用循环复制

2. 使用 System.arraycopy() 方法复制

3. 使用 Arrays.copyOf() 方法进行数组复制

6. 数组合并

1. 使用循环合并

2. 使用 System.arraycopy() 方法进行数组合并

3. 使用 Stream.concat() 方法（Java 8及以上版本）合并

7. 数组插入

8. 二维数组

二、类和对象

1. 什么是类，什么是对象

2. 类的定义

三、方法

1. 什么是方法

2. 方法的语法

3. 无参无返

4. 有参无返

5. 无参有返

6. 有参有返

7. 静态方法

四、字符串方法

1. 字符串长度，返回字符串长度 (length)

2. 字符串比较，返回Boolean值 (equals)

3. 字符串比较忽略大写，返回Boolean值 (equalsIgnoreCase)

4. 字符串转大写，返回大写字符串 (toUpperCase)

5. 字符串转小写，返回小写字符串 (toLowerCase)

6. 字符串查找 (indexOf) 从前往后查找，返回索引位置，未找到返回 -1

7. 字符串查找 (lastIndexOf) 从后往前查找，返回字符串所在索引，从0开始

8. 字符串截取，返回截取后的字符串 (subject)

9. 字符串切割，返回字符串数组 (split)

10. 字符串替换，返回替换后的字符串 (replace)

11. 字符串连接，返回连接后的字符串 (concat)

12. 字符串去除空格 (trim)

13. 字符串转换成字符数组 (toCharArray)

五、日期时间

1. 获取当前日期时间

2. 格式化日期时间

3. 日期时间解析

六、日历

七、printf 的用法

一、数组

1. 什么是数组

数组（Array）是具有相同数据类型的一组元素的集合，并以连续的内存空间存储。数组的长度是固定的，一旦创建就不能更改。

2. 声明数组的三种方式

1. 数组在声明时必须要确定长度(个数)
2. 数组的长度一旦确定，是不可以改变的
3. 数组在内存中开辟连续的空间

// 第一种
int[] ints1 = new int[5];
ints1[0] = 5;
ints1[1] = 2;
ints1[2] = 1;
ints1[3] = 3;
ints1[4] = 7;

// 第二种
int[] ints2 = new int[] {1, 2, 3, 4, 5, 6};

// 第三种
int[] ints3 = {1, 2, 3, 4, 5};

3. 数组的遍历

int[] ints = {1, 2, 3, 4, 5};

// while 循环遍历 (不推荐)
System.out.println("======== while ========");
int i = 0;
while(i < ints.length) {
System.out.println(ints[i]);
i++;
}

// for 循环遍历 (推荐)
System.out.println("======== for ========");
for (int j = 0; j < ints.length; j++) {
System.out.println(ints[j]);
}

// foreach 遍历 (推荐)
System.out.println("======== foreach ========");
for (int s : ints) {
System.out.println(s);
}

4. 数组排序

1. 冒泡排序

冒泡排序是一种简单的排序算法，它通过不断地比较相邻的元素，将较大的元素交换到数组的后面，从而实现排序。冒泡排序的算法：

1. 比较数组中的第一个和第二个元素，如果第一个元素大于第二个元素，则交换它们的位置。

2. 比较数组中的第二个和第三个元素，如果第二个元素大于第三个元素，则交换它们的位置。

3. 继续比较数组中的其他元素，直到比较到数组的最后一个元素。

4. 重复步骤 1-3，直到数组中的所有元素都被排序。

冒泡排序的时间复杂度为 O(n^2)，空间复杂度为 O(1)。

int[] ints = {8, 3, 2, 4, 5};

// 冒泡排序算法
for (int i = 0; i < ints.length - 1; i++) {
    for (int j = 0; j < ints.length - i - 1; j++) {
        // 比较相邻元素并交换位置
        if (ints[j] > ints[j + 1]) {
            int temp = ints[j];
            ints[j] = ints[j + 1];
            ints[j + 1] = temp;
        }
    }
}

// 打印排序后的数组
for (int s : ints) {
    System.out.println(s);
}

2. 选择排序

选择排序是一种简单的排序算法，它通过不断地选择数组中未排序的元素中最小的元素，并将其交换到数组的开头，从而实现排序。选择排序的算法：

1. 从数组中选择最小的元素，并将其交换到数组的开头。

2. 从剩余的元素中选择最小的元素，并将其交换到数组的第二个位置。

3. 继续选择最小的元素，并将其交换到数组的第三个位置，直到所有元素都被排序。

选择排序的时间复杂度为 O(n^2)，空间复杂度为 O(1)。

int[] ints = {8, 3, 2, 4, 5};

// 选择排序算法
for (int i = 0; i < ints.length - 1; i++) {
    int minIndex = i;
    for (int j = i + 1; j < ints.length; j++) {
        // 查找最小元素的索引
        if (ints[j] < ints[minIndex]) {
            minIndex = j;
        }
    }
    // 将最小元素与当前位置元素交换
    int tmp = ints[minIndex];
    ints[minIndex] = ints[i];
    ints[i] = tmp;
}

// 打印排序后的数组
for (int s : ints) {
    System.out.println(s);
}

3. 插入排序

插入排序是一种简单的排序算法，它通过不断地将未排序的元素插入到已排序的元素序列中，从而实现排序。插入排序算法：

1. 从数组的第二个元素开始，将该元素与前面的元素进行比较。

2. 如果该元素小于前面的元素，则将该元素插入到前面的元素之前。

3. 继续比较该元素与前面的元素，直到找到一个比它小的元素。

4. 将该元素插入到该元素之前。

5. 重复步骤 1-4，直到所有元素都被排序。

插入排序的时间复杂度为 O(n^2)，空间复杂度为 O(1)。

int[] ints = {8, 3, 2, 4, 5};

// 插入排序算法
for (int i = 0; i < ints.length; i++) {
    int key = ints[i];
    int j = i - 1;
    while (j >= 0 && ints[j] > key) {
        // 将大于 key 的元素向后移动
        ints[j + 1] = ints[j];
        j--;
    }
    // 将 key 插入到正确的位置
    ints[j + 1] = key;
}

// 打印排序后的数组
for (int s : ints) {
    System.out.println(s);
}

还有希尔排序，归并排序，快速排序等等，这里就不一一介绍了。

5. 数组复制

将一个数组的值复制到另一个数组中

1. 使用循环复制

int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];

// 复制源数组到目标数组
for (int i = 0; i < sourceArray.length; i++) {
    targetArray[i] = sourceArray[i];
}

// 打印目标数组
for (int num : targetArray) {
    System.out.print(num + " ");
}

2. 使用 `System.arraycopy()` 方法复制

int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];

System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);

// 打印目标数组
for (int num : targetArray) {
    System.out.print(num + " ");
}

3. 使用 `Arrays.copyOf()` 方法进行数组复制

int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = Arrays.copyOf(sourceArray, sourceArray.length);

// 打印目标数组
for (int num : targetArray) {
    System.out.print(num + " ");
}

6. 数组合并

将相同类型的两个数组合并

1. 使用循环合并

int[] arr1 = {1, 2, 3};
int[] arr2 = {4, 5, 6};

int[] mergedArray = new int[arr1.length + arr2.length];

// 合并arr1和arr2
int index = 0;
for (int i = 0; i < arr1.length; i++) {
    mergedArray[index] = arr1[i];
    index++;
}

for (int i = 0; i < arr2.length; i++) {
    mergedArray[index] = arr2[i];
    index++;
}

// 打印合并后的数组
for (int num : mergedArray) {
    System.out.print(num + " ");
}

2. 使用 `System.arraycopy()` 方法进行数组合并

int[] arr1 = {1, 2, 3};
int[] arr2 = {4, 5, 6};

int[] mergedArray = new int[arr1.length + arr2.length];

// 复制arr1到mergedArray
System.arraycopy(arr1, 0, mergedArray, 0, arr1.length);

// 复制arr2到mergedArray
System.arraycopy(arr2, 0, mergedArray, arr1.length, arr2.length);

// 打印合并后的数组
for (int num : mergedArray) {
    System.out.print(num + " ");
}

3. 使用 `Stream.concat()` 方法（Java 8及以上版本）合并

int[] arr1 = {1, 2, 3};
int[] arr2 = {4, 5, 6};

int[] mergedArray = Stream.concat(Arrays.stream(arr1), Arrays.stream(arr2))
                          .toArray();

// 打印合并后的数组
for (int num : mergedArray) {
    System.out.print(num + " ");
}

7. 数组插入

向数组指定位置插入元素

int[] originalArray = {1, 2, 3, 4, 5};
// 插入的元素
int insertElement = 6;
// 插入的索引
int insertIndex = 2;

// 创建新数组
int[] newArray = new int[originalArray.length + 1];

// 复制原数组中插入位置之前的元素到新数组
for (int i = 0; i < insertIndex; i++) {
    newArray[i] = originalArray[i];
}

// 插入元素到新数组的指定位置
newArray[insertIndex] = insertElement;

// 复制原数组中插入位置之后的元素到新数组
for (int i = insertIndex + 1; i < newArray.length; i++) {
    newArray[i] = originalArray[i - 1];
}

// 打印插入元素后的数组
for (int num : newArray) {
    System.out.print(num + " ");
}

8. 二维数组

// 第一种
System.out.println("===== 第一种 =====");
int[][] arr = new int[2][2];
arr[0][0] = 1;
arr[0][1] = 1;
arr[1][0] = 1;
arr[1][1] = 1;

for (int[] ints : arr) {
    for (int i : ints) {
        System.out.print(i + " ");
    }
    System.out.println();
}

// 第二种
System.out.println("===== 第二种 =====");
int[][] brr = new int[][]{{2, 4}, {6, 8}};
for (int[] ints : brr) {
    for (int i : ints) {
        System.out.print(i + " ");
    }
    System.out.println();
}

// 第三种
System.out.println("===== 第三种 =====");
int[][] hrr = {{0, 0, 2, 0}, {3, 2, 0, 1}, {1, 3, 1, 2}, {2, 3, 0, 0}};
for (int[] ints: hrr) {
    for (int i: ints) {
        System.out.print(i+" ");
    }
    System.out.println();
}

二、类和对象

1. 什么是类，什么是对象

万物皆对象。看得见，摸得着，客观存在的物体都是对象。

将不同的对象进行分类，归纳的统称。类是不真实存在的，将具有共同属性和方法的对象归纳为一类。

2. 类的定义

普通类

public class Person {
    // 类的成员变量和方法
}

内部类：在一个类的内部定义另一个类，这个被定义的类称为内部类。内部类可以访问外部类的成员。

public class OuterClass {
    // 外部类的成员变量和方法

    public class InnerClass {
        // 内部类的成员变量和方法
    }
}

匿名类：在使用接口或抽象类时，可以直接创建一个没有类名的匿名类。

interface MyInterface {
    // 接口的方法
}

MyInterface obj = new MyInterface() {
    // 匿名类的实现
};

枚举类：使用关键字 enum 定义一个枚举类，枚举类表示一组固定的常量。

public enum DayOfWeek {
    MONDAY,
    TUESDAY,
    // ...
}

抽象类：使用关键字 abstract 定义一个抽象类，抽象类不能直接实例化，只能被继承。

public abstract class AbstractClass {
    // 抽象类的成员变量和方法
}

三、方法

1. 什么是方法

方法（Method）是一段具有特定功能的代码块，用于执行特定的任务或操作。在Java中，方法用于将一系列的语句组织在一起，形成一个可重复使用的代码单元。方法可以接收输入参数（也称为参数或参数列表），并可以返回一个值。

2. 方法的语法

1. 方法签名（Method Signature）：方法的名称和参数列表组成方法的签名。方法签名用于唯一标识一个方法。

2. 参数（Parameters）：方法可以接收零个或多个参数，用于向方法传递数据。

3. 返回类型（Return Type）：方法可以返回一个值，也可以不返回任何值。返回类型指定了方法执行完毕后返回值的类型。

4. 方法体（Method Body）：方法体是方法的具体实现，包含了一系列的语句，用于完成方法的功能。

[访问修饰符] [返回类型] 方法名([参数列表]) {
    // 方法体
    // 执行特定的任务或操作
    [return 返回值;] // 可选，用于返回值
}

3. 无参无返

这种方法不接受任何参数，并且没有返回值。它执行一些操作或完成特定的任务，但不返回结果。

public class Test {

    // 无参无返方法
    public void show() {
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        // 方法调用
        Test t = new Test();
        t.show();
    }
}

4. 有参无返

这种方法接受一个或多个参数，但没有返回值。它执行一些操作或完成特定的任务，但不返回结果。

public class Test {
    
    // 有参无返方法
    public void show(String name) {
        System.out.println("传入的姓名是：" + name);
    }
    
    public static void main(String[] args) {
        // 方法调用
        Test t = new Test();
        t.show("张三");
    }
}

5. 无参有返

这种方法不接受任何参数，但返回一个值。它执行一些操作，并将结果作为返回值返回。

public class Test {

    // 无参有返方法
    public int show() {
        return 100;
    }

    public static void main(String[] args) {
        // 方法调用
        Test t = new Test();
        int i = t.show();
        System.out.println(i);
    }
}