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

一、数组

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);
    }
}

 

6. 有参有返 

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

public class Test {

    // 有参有返方法
    public int compute(int a, int b) {
        return a + b;
    }

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

7. 静态方法

静态方法是在Java中定义的一种特殊类型的方法。它们属于类而不是对象，并且可以通过类名直接调用，而无需创建类的实例。 静态方法的特点：

1. 静态方法使用 static 关键字进行声明。

2. 静态方法可以直接从类中访问静态变量，并且只能访问静态变量。

3. 静态方法不能直接访问非静态变量和非静态方法，因为它们是与类的实例相关联的。

4. 静态方法可以从其他静态方法中调用，也可以从非静态方法中调用，但在非静态方法中调用静态方法时需要使用类名作为前缀。

5. 静态方法可以在没有创建类的实例的情况下被调用。

public class Test {

    // 静态变量
    private static int count = 0;

    // 静态方法
    public static void incrementCount() {
        count++;
    }

    // 静态方法
    public static int getCount() {
        return count;
    }

    public static void main(String[] args) {
        // 静态方法调用
        Test.incrementCount();
        int currentCount = Test.getCount();
        System.out.println("Current count: " + currentCount);
    }
}

四、字符串方法

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

String str = "hello world";
System.out.println("字符长度: " + str.length());

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

String str1 = "hello";
String str2 = "hello";
System.out.println("字符串比较: " + str1.equals(str2));

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

String str1 = "hello";
String str2 = "Hello";
System.out.println("字符串比较: " + str1.equalsIgnoreCase(str2));

 

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

String str = "hello";
System.out.println("字符串转大写: " + str.toUpperCase());

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

String str = "HELLO";
System.out.println("字符串转小写: " + str.toLowerCase());

 

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

String str = "hello";
System.out.println("字符串转查找: " + str.indexOf('2'));

 

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

String str = "hello";
System.out.println("字符串转查找: " + str.lastIndexOf('o'));

 

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

String str = "hello";
System.out.println("字符串转截取: " + str.substring(2));

 

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

String str = "hello,world";
String[] arr = str.split(",");
for (String s : arr) {
    System.out.println(s);
}

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

String str = "hello,world";
System.out.println(str.replace(","," "));

 

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

String str1 = "hello";
String str2 = " world";
System.out.println(str1.concat(str2));

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

String str = " hello    ";
System.out.println(str.trim());

 

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

String str = "hello";
char[] chars = str.toCharArray();
for (char c : chars) {
    System.out.println(c);
}

五、日期时间

1. 获取当前日期时间

// 获取当前日期
LocalDate date = LocalDate.now();
System.out.println("当前日期: " + date);

// 获取时间
LocalTime time = LocalTime.now();
System.out.println("当前时间: " + time);

// 获取当前日期时间
LocalDateTime dateTime = LocalDateTime.now();
System.out.println("当前日期时间: " + dateTime);

// 获取当前年份
System.out.println("当前年份: " + dateTime.getYear());

// 获取当前月份
System.out.println("当前月份: "+dateTime.getMonthValue());

// 获取当前月份的天数
System.out.println("当前月份的天数: "+dateTime.getDayOfMonth());

// 获取小时
System.out.println("当前小时: " + dateTime.getHour());

// 获取分钟
System.out.println("当前分钟: " + dateTime.getMinute());

// 获取秒
System.out.println("当前秒: " + dateTime.getSecond());

// 获取毫秒
System.out.println("当前毫秒: "+dateTime.getNano());

// 获取星期
System.out.println("周："+dateTime.getDayOfWeek());

2. 格式化日期时间

// 当前时间
LocalDateTime dateTime = LocalDateTime.now();

// 格式化时间 yyyy-MM-dd HH:mm:ss
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println(dateTime.format(formatter1));

// 格式化时间 yyyy/MM/dd HH:mm:ss
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
System.out.println(dateTime.format(formatter2));

// 格式化时间 yyyy年MM月dd日 HH时mm分ss秒
DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
System.out.println(dateTime.format(formatter3));

 

3. 日期时间解析

// 日期字符串转日期类
String date = "2020-10-11";
LocalDate localDate = LocalDate.parse(date);
System.out.println(localDate);

// 时间字符串转时间类
String time = "11:10:12";
LocalTime localTime = LocalTime.parse(time);
System.out.println(localTime);

// 日期时间字符串转日期时间类
String dateTime = "2020-10-11T11:10:12";
LocalDateTime localDateTime = LocalDateTime.parse(dateTime);
System.out.println(localDateTime);

// 特定的日期时间
LocalDateTime specificDateTime = LocalDateTime.of(2022, 1, 1, 12, 0, 0);
System.out.println("特定日期和时间：" + specificDateTime);

六、日历

// 日历
Calendar calendar = Calendar.getInstance();

// 获取当前时间
Date time = calendar.getTime();
System.out.println("当前时间: " + time);

// 获取当前年份
int year = calendar.get(Calendar.YEAR);
System.out.println("年份: " + year);

// 获取当前月份
int month = calendar.get(Calendar.MONTH) + 1;
System.out.println("月份: " + month);

// 获取当前日期
int day = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println("日期: " + day);

// 获取当前星期
int weekOfYear = calendar.get(Calendar.WEEK_OF_YEAR);
System.out.println("星期: " + weekOfYear);

// 获取当前小时
int hour = calendar.get(Calendar.HOUR);
System.out.println("小时: " + hour);

// 获取当前分钟
int minute = calendar.get(Calendar.MINUTE);
System.out.println("分钟: " + minute);

// 获取当前秒
int second = calendar.get(Calendar.SECOND);
System.out.println("秒: " + second);

// 获取当前毫秒
long millis = calendar.getTimeInMillis();
System.out.println("毫秒: " + millis);

七、printf 的用法

System.out.printf() 方法用于格式化输出。它可以接受一个格式字符串和一个可变数量的参数。格式字符串包含一个或多个占位符，每个占位符对应一个参数。占位符由百分号 (%) 和一个字母组成。

符号 描述 示例 结果
s 输出字符串

String str = "hello";

System.out.printf("%s world", str);

 hello world
S 输出大写字符串

String str = "hello";

System.out.printf("%S", str);

 HELLO
d 输出十进制整数

int i = 10;

System.out.printf("%d", i);

 10
o 输出八进制整数

int i = 10;

System.out.printf("%o", i);

 12
x 输出十六进制整数

int i = 10;

System.out.printf("%x", i);

 a
X 输出大写十六进制整数

int i = 10;

System.out.printf("%X", i);

 A
f 输出浮点数

float i = 10;

System.out.printf("%f", i);

 10.000000
e 输出科学计数法表示的浮点数(小写e)

float i = 10;

System.out.printf("%e", i);

 1.000000e+01
E 输出科学计数法表示的浮点数(大写E)

float i = 10;

System.out.printf("%E", i);

 1.000000E+01
.nf 控制小数点后的位数，n为数字

float i = 10.123456f;

System.out.printf("%.2f", i);

 10.12
b 输出布尔值

boolean b = true;

System.out.printf("%b", b);

 true
c 输出字符

char s = 'h';

System.out.printf("%c", s);

 h
n 换行符 System.out.printf("hello%nworld");

hello

world
% 输出一个百分号

System.out.printf("10%%");

 10%
h，H 散列码，分别使用十六进制和十六进制大写字母表示

String s = "hello";

System.out.printf("%h", s);

 5e918d2
tY，TY 四位数的年份 System.out.print("%tY", LocalDateTime.now()); 2023
ty，Ty 两位数的年份 System.out.print("%tY", LocalDateTime.now()); 23
tB，TB 本地化月份全名 System.out.print("%tB", LocalDateTime.now()); 十一月
tb，Tb，th，Th 本地化月份缩写 System.out.print("%tY", LocalDateTime.now()); 11月
tm，Tm 两位数的月份 System.out.print("%tm", LocalDateTime.now()); 11
td，Td 两位数的日期 System.out.print("%td", LocalDateTime.now()); 29
te，Te 一位数或者两位数的日期 System.out.print("%te", LocalDateTime.now()); 29
tA，TA 本地化星期的全名 System.out.print("%tA", LocalDateTime.now()); 星期三
ta，Ta 本地化星期的缩写 System.out.print("%ta", LocalDateTime.now()); 周三
tH，TH 24小时制的小时数 System.out.print("%tH", LocalDateTime.now()); 21
tl，Tl 12小时制的小时数 System.out.print("%tl", LocalDateTime.now()); 9
tm，Tm 分钟数 System.out.print("%tm", LocalDateTime.now()); 23
tS，TS 秒数 System.out.print("%ts", LocalDateTime.now()); 22
tp，Tp 上午或下午 System.out.print("%tp", LocalDateTime.now()); 下午 
// 格式输出当前时间
System.out.printf("当前时间：%1$tY-%1$tm-%1$td %1$tA %1$tH:%1$tM:%1$tS:%1$tL", LocalDateTime.now());

# java
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

软考中级-软件设计师 UML图详解（ 类图，对象图，用例图，序列图，通信图，状态图，活动图，构件图，部署图）

avatar 2048 AI社区
cover

机器学习 决策树-分类

avatar 2048 AI社区
cover

【SD教程】超详细AI绘画提示词语法讲解！

avatar 2048 AI社区