java2024/3/3

已于 2024-03-04 23:36:36 修改
阅读量643 收藏 14
点赞数 17
文章标签： python 开发语言
于 2024-03-04 00:31:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59037435/article/details/136432513
版权

1、列表和数组：

在Java中，列表（List）和数组（Array）是两种不同的数据类型，它们在使用和特性上有一些区别。下面是它们各自的基本用法和示例：

        数组（Array）

  • 声明和初始化：

    • 数组的声明和初始化是直接在声明时指定数组的长度和元素类型。
    • int[] nums = new int[5]; // 创建一个包含5个整数的数组

      访问元素：

    • 使用索引访问数组中的元素，索引从0开始。 
      nums[0] = 10;
int value = nums[2];

      固定长度：

    • 数组一旦创建，其长度是固定的，无法更改。
    • int[] nums = new int[5];
nums[5] = 20; // 这里会导致 ArrayIndexOutOfBoundsException，数组越界

      示例：

    • int[] nums = new int[5];
nums[0] = 10;
nums[1] = 20;
nums[2] = 30;
System.out.println(nums[1]); // 输出 20

      数组（Array）的元素设置

    • 使用方法：

      • 对数组的元素赋值，直接通过索引进行设置。
      • int[] nums = new int[5];
nums[0] = 10;
nums[1] = 20;
nums[2] = 30;

        示例：

      • int[] nums = new int[5];
nums[1] = 100; // 设置索引为1的元素为100
nums[3] = 50;  // 设置索引为3的元素为50

        注意事项：

      • 数组的大小是固定的，因此设置操作不能超出数组的长度范围。
      • int[] nums = new int[3];
nums[3] = 10; // 这里会导致 ArrayIndexOutOfBoundsException，数组越界

        列表（List）

      • 声明和初始化：

        • 列表是一个接口，常用的实现类有 ArrayList 和 LinkedList 等。
        • 声明时只指定接口类型，初始化时可以选择具体的实现类。
        • List<Integer> nums = new ArrayList<>();

          添加和访问元素：

        • 列表的大小是动态的，可以根据需要添加或移除元素。
        • nums.add(10);
nums.add(20);
nums.add(30);
int value = nums.get(1);

          动态调整大小：

        • 列表可以根据需要动态增加或减少元素的个数。 
          nums.add(40);
nums.remove(0);

          示例：

          List<Integer> nums = new ArrayList<>();
nums.add(10);
nums.add(20);
nums.add(30);
System.out.println(nums.get(1)); // 输出 20

          列表（List）的元素设置

        • 使用方法：

          • 对列表的元素赋值，使用 set(index, element) 方法，将指定索引位置的元素替换为新的元素。
          • List<Integer> nums = new ArrayList<>();
nums.add(10);
nums.add(20);
nums.add(30);

            示例：

            List<Integer> nums = new ArrayList<>();
nums.add(10);
nums.add(20);
nums.add(30);

nums.set(1, 100); // 将索引为1的元素设置为100
nums.set(2, 50);  // 将索引为2的元素设置为50

            注意事项：

          • 列表的大小是动态的，可以根据需要调整。
          • 可以设置的索引范围是 [0, size-1]，超出范围会抛出 IndexOutOfBoundsException 异常。
          • List<Integer> nums = new ArrayList<>();
nums.add(10);
nums.add(20);
nums.set(2, 30);  // 这里会抛出 IndexOutOfBoundsException，索引超出范围

            对比示例

          • 数组示例：

            int[] nums = new int[5];
nums[0] = 10;
nums[1] = 20;
nums[2] = 30;

nums[1] = 100; // 设置索引为1的元素为100
nums[2] = 50;  // 设置索引为2的元素为50

            列表示例：

            List<Integer> nums = new ArrayList<>();
nums.add(10);
nums.add(20);
nums.add(30);

nums.set(1, 100); // 将索引为1的元素设置为100
nums.set(2, 50);  // 将索引为2的元素设置为50

            总结

          • 数组：

            • 元素设置直接通过索引赋值。
            • 大小固定，设置操作不能超出数组长度。

          • 列表：

            • 使用 set(index, element) 方法来设置元素。
            • 大小动态调整，可以根据需要灵活设置元素。

          • 所以在对元素进行设置时，数组直接通过索引赋值，而列表则使用 set(index, element) 方法来实现，提供了更多的灵活性和动态性。

          • 2、java的字符串操作

          • Java提供了丰富的字符串操作方法，使得对字符串进行处理和操作变得非常方便。下面是一些常用的Java字符串操作：

          • 创建字符串

          • String str1 = "Hello"; // 直接赋值创建字符串
String str2 = new String("World"); // 使用构造函数创建字符串
String str3 = ""; // 创建一个空字符串
String str4 = null; // 创建一个空引用

            获取字符串长度

          • String str = "Hello, World!";
int length = str.length(); // 获取字符串的长度，结果为 13

            字符串连接

          • String str1 = "Hello";
String str2 = "World";
String result = str1 + " " + str2; // 使用加号进行字符串连接，结果为 "Hello World"

            检查字符串是否为空

          • String str = "";
boolean isEmpty = str.isEmpty(); // 检查字符串是否为空，结果为 true

            检查字符串是否为null或为空

          • String str = null;
boolean isNullOrEmpty = str == null || str.isEmpty(); // 检查字符串是否为null或为空，结果为 true

            检查字符串是否包含某个子字符串

          • String str = "Hello, World!";
boolean contains = str.contains("World"); // 检查字符串是否包含子字符串，结果为 true

            字符串分割

          • String str = "apple,orange,banana";
String[] fruits = str.split(","); // 使用指定的分隔符拆分字符串，结果为 ["apple", "orange", "banana"]
            字符串截取
          • String str = "Hello, World!";
String sub1 = str.substring(7); // 从索引为7的位置截取到末尾，结果为 "World!"
String sub2 = str.substring(7, 12); // 从索引为7的位置截取到索引为12的位置，结果为 "World"

            字符串替换

          • String str = "Hello, World!";
String newStr = str.replace("World", "Java"); // 将字符串中的 "World" 替换为 "Java"，结果为 "Hello, Java!"

            大小写转换

            String str = "Hello, World!";
String lowerCase = str.toLowerCase(); // 将字符串转换为小写，结果为 "hello, world!"
String upperCase = str.toUpperCase(); // 将字符串转换为大写，结果为 "HELLO, WORLD!"

            去除字符串两端的空白字符

          • String str = "   Hello, World!   ";
String trimmedStr = str.trim(); // 去除字符串两端的空白字符，结果为 "Hello, World!"

            比较字符串

            String str1 = "Hello";
String str2 = "Hello";
boolean isEqual = str1.equals(str2); // 比较两个字符串是否相等，结果为 true

            查找字符串位置

            String str = "Hello, World!";
int index = str.indexOf("World"); // 查找子字符串在父字符串中的位置，结果为 7

            格式化字符串

            String name = "Alice";
int age = 25;
String message = String.format("Hello, %s! You are %d years old.", name, age); // 格式化字符串，结果为 "Hello, Alice! You are 25 years old."

            StringBuilder 和 StringBuffer

            在频繁对字符串进行修改时，使用 StringBuilder（非线程安全）或 StringBuffer（线程安全）可以提高效率。

            StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(", ");
sb.append("World");
String result = sb.toString(); // 结果为 "Hello, World"

            这些只是Java中字符串操作的一些常用方法，还有很多其他方法可以用来处理和操作字符串。根据具体的需求，选择合适的方法来进行字符串操作。

          • 3、StringBuilder（非线程安全）或 StringBuffer（线程安全）是什么意思

          • StringBuilder 和 StringBuffer 都是用来进行字符串操作的类，它们提供了对字符串进行修改、拼接等操作的方法。这两个类的主要区别在于线程安全性。

            StringBuilder

          • StringBuilder 是一个可变的、非线程安全的字符串序列。
          • 它提供了对字符串进行修改、添加、删除等操作的方法。
          • 在单线程环境下使用 StringBuilder 是最佳选择，因为它的操作速度快，没有额外的线程同步开销。
          • 适用于单线程的情况下进行字符串操作。

          • StringBuffer

          • StringBuffer 也是一个可变的字符串序列，与 StringBuilder 类似。

          • 使用场景比较

          • 如果在单线程环境下进行字符串操作，并且不需要考虑线程安全问题，建议使用 StringBuilder。因为它的操作速度更快，没有额外的线程同步开销。
          • 如果在多线程环境下进行字符串操作，或者对线程安全性有要求，建议使用 StringBuffer。它虽然在性能上略逊于 StringBuilder，但可以确保线程安全。

          • 下面是一个简单的示例，演示了如何使用 StringBuilder 进行字符串拼接：

          • 与 StringBuilder 不同的是，StringBuffer 是线程安全的，支持多线程的并发操作。
          • 它的所有公共方法都是同步的，保证了多线程环境下的安全性。
          • 适用于在多线程环境下进行字符串操作时，或者对线程安全性要求较高的情况。
          • StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(", ");
sb.append("World");
String result = sb.toString(); // 结果为 "Hello, World"

            对于简单的字符串拼接操作，StringBuilder 提供了很方便的方法，并且在性能上比直接使用 + 连接字符串更高效。但如果在多线程环境下，应该考虑使用 StringBuffer 来保证线程安全。

          • 4、s.charAt(index)是啥意思

          • s.charAt(index) 是 Java 中用来获取字符串 s 中指定位置 index 处字符的方法。

          • s：表示要操作的字符串。
          • index：表示要获取字符的索引位置，从 0 开始，即第一个字符的索引为 0，第二个字符的索引为 1，以此类推。

          • 例如，如果有一个字符串 str = "Hello"，我们可以使用 charAt 方法来获取字符串中的字符。示例如下：

          • String str = "Hello";
char ch1 = str.charAt(0); // 获取索引为 0 处的字符，即 'H'
char ch2 = str.charAt(1); // 获取索引为 1 处的字符，即 'e'
char ch3 = str.charAt(4); // 获取索引为 4 处的字符，即 'o'

            在这个例子中，charAt(0) 获取了字符串 str 中索引为 0 的字符，即字符串的第一个字符 'H'。同理，charAt(1) 获取了字符串的第二个字符 'e'，charAt(4) 获取了字符串的第五个字符 'o'。

            如果指定的索引超出了字符串的长度范围，将会抛出 IndexOutOfBoundsException 异常。所以在使用 charAt 方法时，要确保索引值在字符串的有效范围内。

          • 5、s.trim()的源码是啥

          • String.trim() 方法是用来去除字符串两端的空白字符（whitespace）的，包括空格、制表符、换行符等。下面是 String.trim() 方法的简化版源码示例：

            public String trim() {
    int len = value.length;
    int st = 0;
    char[] val = value;    // 获取字符串的字符数组
    while ((st < len) && (val[st] <= ' ')) {
        st++;    // 移动到第一个非空白字符的位置
    }
    while ((st < len) && (val[len - 1] <= ' ')) {
        len--;    // 移动到最后一个非空白字符的位置
    }
    return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}

private String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}

            这里是 String.trim() 方法的简化版本源码解释：

          • trim() 方法首先获取字符串的长度 len 和字符数组 val。
          • 然后使用两个 while 循环，分别从字符串的开头和末尾开始检查字符是否为空白字符（<= ' '）：
            • 第一个 while 循环（st）移动到第一个非空白字符的位置。
            • 第二个 while 循环（len）移动到最后一个非空白字符的位置。
          • 最后返回截取出的子字符串，如果没有去除任何空白字符，则返回原始字符串。
            • 如果存在需要截取的部分，使用 substring() 方法来截取出对应的子字符串。
            • 如果没有需要截取的部分，则直接返回原始字符串。

          • 这样，trim() 方法就可以实现去除字符串两端的空白字符，并返回新的字符串。

            需要注意的是，上述是简化版的源码示例，并非完整的 String.trim() 源码。在实际的 Java 源码中，trim() 方法可能会包含更多的边界条件检查、优化等内容。

          • 6、在 Java 中，你可以将 String 类型的字符串转换为字符数组（char[]）使用以下方法：

          • 方法一：使用 toCharArray() 方法

            String 类中提供了一个 toCharArray() 方法，可以将字符串转换为字符数组。示例如下：

            String str = "Hello, World!";
char[] charArray = str.toCharArray();

// 打印字符数组
for (char ch : charArray) {
    System.out.print(ch + " ");
}
System.out.println();

            在这个示例中，toCharArray() 方法会返回一个 char[] 数组，其中包含了 str 字符串的所有字符。你可以直接使用这个字符数组进行操作。

            方法二：逐个访问字符并创建数组

            你也可以使用循环逐个访问字符串的字符，并创建一个 char[] 数组。示例如下：

            String str = "Hello, World!";
int length = str.length();
char[] charArray = new char[length];

for (int i = 0; i < length; i++) {
    charArray[i] = str.charAt(i);
}

// 打印字符数组
for (char ch : charArray) {
    System.out.print(ch + " ");
}
System.out.println();

            在这个示例中，我们先获取了字符串的长度，然后创建了一个相同长度的 char[] 数组，并通过循环逐个赋值。

            这两种方法都可以将 String 类型的字符串转换为 char[] 类型的字符数组，你可以根据实际需求选择合适的方法。

          • 7、字符数组转换为string

          • 在 Java 中，你可以将字符数组（char[]）转换为 String 类型的字符串。有几种常见的方法可以实现这个转换：

            方法一：使用 String 的构造函数

            String 类有一个构造函数可以接受一个字符数组作为参数，将其转换为字符串。示例如下：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArray);

System.out.println(str);  // 输出 "Hello"

            在这个示例中，我们通过 new String(charArray) 创建了一个新的 String 对象，它包含了 charArray 中的字符。

            方法二：使用 String 的静态方法 valueOf()

            String 类还提供了一个静态方法 valueOf()，可以将字符数组转换为字符串。示例如下：

          • char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str = String.valueOf(charArray);

System.out.println(str);  // 输出 "Hello"

            这个方法和前面的方法效果是一样的，它会创建一个包含 charArray 中字符的新的 String 对象。

            方法三：使用 StringBuilder 类

            你也可以使用 StringBuilder 类来构建字符串。示例如下：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};
StringBuilder sb = new StringBuilder();

for (char ch : charArray) {
    sb.append(ch);
}

String str = sb.toString();

System.out.println(str);  // 输出 "Hello"

            在这个示例中，我们通过循环逐个将字符添加到 StringBuilder 中，然后使用 toString() 方法将其转换为 String 类型的字符串。

            以上三种方法都可以将 char[] 类型的字符数组转换为 String 类型的字符串。你可以根据实际情况和喜好选择合适的方法。

          • 这三种方法的时间复杂度都是一样的，都是 O(n)，其中 n 是字符数组的长度。它们在时间复杂度上是相同的，因此你可以根据实际情况和喜好选择任何一种方法。

          • 在 Java 中，将字符数组（char[]）转换为 String 类型的字符串时，三种方法的性能是不同的，但是它们之间的差异可能并不显著，因为它们的时间复杂度都是 O(n)，其中 n 是字符数组的长度。

            然而，就相对速度而言，一般来说，直接使用 String 的构造函数或者静态方法 valueOf() 是比较快的。这是因为这两种方法内部实现是通过直接复制字符数组的方式来创建新的字符串对象，不需要额外的操作。

            相比之下，使用 StringBuilder 类来构建字符串可能会稍微慢一些。因为 StringBuilder 是一个可变的字符序列，它在循环中逐个添加字符，并在最后调用 toString() 方法时才将其转换为字符串。这可能会导致一些额外的操作和内存分配。

            因此，如果你关心性能，并且可以直接使用 String 的构造函数或者静态方法 valueOf() 来实现字符数组到字符串的转换，那么这两种方法会相对更快一些。

            综上所述，从性能角度来看，直接使用 String 的构造函数或者静态方法 valueOf() 是较快的选择。但需要注意的是，对于一般的应用程序，这些性能差异可能并不明显，并不会对程序的整体性能产生重大影响。因此，你可以根据实际情况和需求选择合适的方法。

          • 8、字符数组的基本操作

          • 在 Java 中，字符数组（char[]）是一种基本的数据类型，它用于存储字符序列。下面是一些常见的字符数组的基本操作：

          • 1. 创建字符数组

            你可以使用以下方式创建一个字符数组：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};

            这里我们创建了一个包含字符 'H', 'e', 'l', 'l', 'o' 的字符数组 charArray。

            2. 访问字符数组元素

            你可以使用索引来访问字符数组中的元素。字符数组的索引从 0 开始，直到 数组长度 - 1。示例如下：

          • char[] charArray = {'H', 'e', 'l', 'l', 'o'};
char firstChar = charArray[0];  // 访问第一个元素 'H'
char lastChar = charArray[charArray.length - 1];  // 访问最后一个元素 'o'

            3. 修改字符数组元素

            字符数组中的元素是可变的，你可以通过索引来修改其中的元素。示例如下：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};
charArray[0] = 'h';  // 将第一个元素修改为 'h'
charArray[3] = 'p';  // 将第四个元素修改为 'p'

            4. 获取字符数组的长度

            你可以使用 length 属性来获取字符数组的长度。示例如下：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};
int length = charArray.length;  // 获取字符数组的长度，这里 length 的值为 5

            5. 遍历字符数组

            你可以使用循环来遍历字符数组中的所有元素。示例如下：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};
for (int i = 0; i < charArray.length; i++) {
    System.out.print(charArray[i] + " ");  // 输出所有元素，这里输出 "H e l l o "
}
System.out.println();

            6. 将字符数组转换为字符串

            你可以使用 String 类的构造函数或者静态方法 valueOf() 将字符数组转换为字符串。示例如下：

            使用构造函数：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str1 = new String(charArray);
System.out.println(str1);  // 输出 "Hello"

            使用静态方法 valueOf()：

          • char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str2 = String.valueOf(charArray);
System.out.println(str2);  // 输出 "Hello"

            1. 切割字符数组

            你可以使用 Arrays 类的 copyOfRange 方法来切割字符数组，从而创建一个新的字符数组。示例如下：

            import java.util.Arrays;

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
char[] subArray = Arrays.copyOfRange(charArray, 1, 4);
System.out.println(Arrays.toString(subArray));  // 输出 "[e, l, l]"

            在这个示例中，copyOfRange 方法会返回一个从索引 1 到 4 之间的子数组，不包括索引 4 处的元素。

          • 2. 排序字符数组

            你可以使用 Arrays 类的 sort 方法对字符数组进行排序。示例如下：

            import java.util.Arrays;

char[] charArray = {'z', 'a', 'b', 'c', 'f'};
Arrays.sort(charArray);
System.out.println(Arrays.toString(charArray));  // 输出 "[a, b, c, f, z]"

            3. 比较两个字符数组

            你可以使用 Arrays 类的 equals 方法来比较两个字符数组是否相等。示例如下：

          • import java.util.Arrays;

char[] charArray1 = {'H', 'e', 'l', 'l', 'o'};
char[] charArray2 = {'H', 'e', 'l', 'l', 'o'};
char[] charArray3 = {'W', 'o', 'r', 'l', 'd'};

boolean isEqual1 = Arrays.equals(charArray1, charArray2);  // true
boolean isEqual2 = Arrays.equals(charArray1, charArray3);  // false

System.out.println(isEqual1);
System.out.println(isEqual2);

            4. 查找字符数组中的元素

            你可以使用循环来查找字符数组中的特定元素。示例如下：

            char[] charArray = {'H', 'e', 'l', 'l', 'o'};
char target = 'l';
int index = -1;

for (int i = 0; i < charArray.length; i++) {
    if (charArray[i] == target) {
        index = i;
        break;
    }
}

System.out.println("Index of '" + target + "': " + index);  // 输出 "Index of 'l': 2"

            在这个示例中，我们查找字符数组中第一次出现 'l' 的索引。

            5. 复制字符数组

            你可以使用 Arrays 类的 copyOf 方法复制一个字符数组。示例如下：

            import java.util.Arrays;

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
char[] copyArray = Arrays.copyOf(charArray, charArray.length);
System.out.println(Arrays.toString(copyArray));  // 输出 "[H, e, l, l, o]"

            6. 填充字符数组

            你可以使用 Arrays 类的 fill 方法来填充字符数组中的所有元素。示例如下：

            import java.util.Arrays;

char[] charArray = new char[5];
Arrays.fill(charArray, 'X');
System.out.println(Arrays.toString(charArray));  // 输出 "[X, X, X, X, X]"

            9、List 接口的列表对象的一下常见操作

          • List 接口是 Java 中集合框架中的一种，它表示一个有序的集合，可以存储重复元素。List 接口提供了许多常用的操作，让我们来看一些常见的操作：

            1. 添加元素

            使用 add 方法向列表中添加元素：

            List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

            2. 获取元素

            使用 get 方法获取指定位置的元素：

            String firstElement = list.get(0);  // 获取第一个元素 "Apple"
String lastElement = list.get(list.size() - 1);  // 获取最后一个元素 "Cherry"

            3. 修改元素

            使用 set 方法修改指定位置的元素：

            list.set(1, "Grapes");  // 将第二个元素修改为 "Grapes"

            4. 删除元素

            使用 remove 方法删除指定位置或指定元素的元素：

            list.remove(0);  // 删除第一个元素 "Apple"
list.remove("Cherry");  // 删除指定元素 "Cherry"

            5. 检查元素是否存在

            使用 contains 方法检查列表中是否包含指定元素：

            boolean containsBanana = list.contains("Banana");  // 检查是否包含 "Banana"

            6. 获取列表长度

            使用 size 方法获取列表的长度（元素个数）：

            int size = list.size();  // 获取列表的长度

            7. 遍历列表

            使用 for 循环或迭代器遍历列表中的所有元素：

            使用 for循环：
            for (String element : list) {
    System.out.println(element);
}
            使用迭代器：
            Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

            8. 清空列表

            使用 clear 方法清空列表中的所有元素：

          • list.clear();  // 清空列表

            这些是 List 接口中一些常见的操作。List 接口还提供了许多其他方法，例如排序、查找等，你可以根据需要选择使用。注意，这些方法是在 java.util.List 接口中定义的，你可以使用 ArrayList、LinkedList 等实现了 List 接口的类来创建列表对象并进行操作。

          • 10、将一个 List 中的元素合并为一个字符串

          • 要将一个 List 中的元素合并为一个字符串，你可以使用 StringBuilder 或 String.join() 方法。下面是两种方法的示例：

            方法一：使用 StringBuilder

          • import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("Hello", "World", "Java");

        StringBuilder sb = new StringBuilder();
        for (String str : list) {
            sb.append(str);
        }

        String mergedString = sb.toString();
        System.out.println(mergedString);  // 输出 "HelloWorldJava"
    }
}

            在这个示例中，我们遍历 List 中的所有元素，并使用 StringBuilder 的 append() 方法将它们逐个添加到 StringBuilder 中。最后，我们使用 toString() 方法将 StringBuilder 转换为字符串。

            方法二：使用 String.join()

            import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("Hello", "World", "Java");

        String mergedString = String.join("", list);
        System.out.println(mergedString);  // 输出 "HelloWorldJava"
    }
}

            在这个示例中，我们使用 String.join() 方法将 List 中的元素连接起来。第一个参数是连接的分隔符，这里我们传入空字符串 ""，表示不使用任何分隔符。

            无论使用哪种方法，最终的 mergedString 将会是 List 中所有元素合并而成的一个字符串。

qq_59037435
关注
华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）
shen198899的博客
05-02 8万+
华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）
Java最新2024学习路线+Java自学全套免费网盘资料
04-01
Java作为一门成熟的编程语言，在2024年依旧是企业级应用开发的热门选择。对于想要学习Java的初学者而言，本学习路线旨在覆盖从基础到高级，甚至是架构师级别的知识体系。以下是对所提供的文件内容的详细知识点解析：...
2024/3/23 蓝桥杯
一路生花
03-24 1390
2024/3/23 蓝桥杯
2024/3/24 蓝桥杯
一路生花
03-24 1695
2024/3/24 蓝桥杯
java学习基础2024/3/11
qq_59037435的博客
03-12 1528
在 Java 中，有多种方式可以从用户获取输入。
Java 的下载安装教程
热门推荐
暗诺星刻的博客
12-21 25万+
Java 17 的下载安装教程 说明： 本文介绍的是 Windows 下安装 Java 的方法。对于 Linux 下 Java 的安装，可见笔者的另一篇博客： 在 Linux 操作系统中安装 Java：https://blog.csdn.net/wangpaiblog/article/details/120093325 笔者的安装环境： JDK 17 Windows 10 教育版 安装 Java 就是安装 JDK。Java 有三大分支，这里选择的是 Java SE。关于
Java 2024年面试总结（持续更新）
m0_69857933的博客
03-21 2782
2024 java后端开发面试总结
/usr/java/packages/lib/amd64_上找不到基于APR的Apache Tomcat本机库java.library.path
weixin_29635155的博客
02-26 2720
循序渐进地遵循本教程：在这里我发现了下一个提示：Sep 15, 2013 3:40:39 PM org.apache.catalina.core.AprLifecycleListener initINFO: The APR based Apache Tomcat Native library which allows optimal performance in production enviro...
2024/8/22最新Ubuntu24.04系统下手动激活idea/clion教程
qq_43118243的博客
08-22 1909
修改Clion或idea安装目录下的vmoptions结尾的文件。最后一行填写ja-netfilter.jar你实际解压到的位置。然后我们解压移动到同一文件夹,方便操作。首先解压文章末尾获取到的压缩包。时间只是显示,实际上是永久。
20240724-然后用idea创建一个Java项目/配置maven环境/本地仓储配置
zsysingapore的博客
07-24 1332
（1）新建一个文件夹，名称为“mvn-repository”，路径为：C:\Users\zzz\Desktop\java\mvn-repository。（3）下载后解压，将Maven的压缩包解压到：C:\Users\zzz\Desktop\apache-maven-3.9.8。1）添加系统变量MAVEN_HOME，变量值为C:\Users\zzz\Desktop\apache-maven-3.9.8。配置完成，win+R运行cmd，输入mvn help:system测试，配置成功则本地仓库的一些信息。
2024年的Java版本选择？java 17 安装
西京刀客
04-29 4048
现如今，到了2024年，市场java主流版本选择是什么呢？
Java面试八股文2024最新版
12-19
3. **数据类型**：Java有8种基本数据类型，对应的封装类如`Integer`、`Double`等。 4. **标识符命名规则**：遵循驼峰命名法，不能以数字开头，且避免使用Java关键字。 5. **instanceof**：用于检查对象是否是某个类...
2024nity3D/UE4/UE5引擎/iOS和Android原生开发
09-30
novel 是一套基于时下最新 Java 技术栈 Spring Boot 3 + Vue 3 开发的前后端分离学习型小说项目，配备保姆级教程手把手教你从零开始开发上线一套生产级别的 Java 系统，由小说门户系统、作家后台管理系统、平台后台...
2024 Java面试宝典合集
05-20
3. **JAVA核心面试知识整理**：这部分内容可能涵盖Java基础，如内存模型、垃圾收集、类加载机制、多态、封装、继承、接口、异常处理、集合框架（List、Set、Map的区别和使用）、IO流、NIO、反射、枚举、注解等。...
python中zip()与zip(*)的用法解析
最新发布
m0_51579041的博客
10-08 101
zip()与zip(*)的用法解析
Python3 解释器
Java_fenxiang的博客
10-05 509
Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在/usr/local/python3目录中。安装完成后，我们可以将路径/usr/local/python3/bin添加到您的 Linux/Unix 操作系统的环境变量中，这样您就可以通过 shell 终端输...
gligen安装部署笔记
jacke121的专栏
10-08 110
gligen安装部署笔记
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 524
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
遥感影像-实例分割数据集：iSAID 从切图到YOLO格式数据集制作详细介绍
GIS潮流
09-30 1496
开源数据集isaid标注包含实例分割，但是原始影像太大，很吃显存，一般显卡无法用原始影像直接训练，所以需要对影像进行裁剪，并生成对应的标签，因为想用yolo系列跑模型，所以将标签需要转为txt格式。
java: 读取/E:/小白做毕设/克隆代码/honey2024/springboot/src/main/java/com/example/springboot/controller/UserController.java时出错; utf-8。
01-20
String filePath = "E:/小白做毕设/克隆代码/honey2024/springboot/src/main/java/com/example/springboot/controller/UserController.java"; try { File file = new File(filePath); FileInputStream fis = ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_59037435

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值