JavaSE - 字符串

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量196 收藏
点赞数
分类专栏： 我的Java基础学习之路 文章标签： java 开发语言 后端 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29718835/article/details/121188838
版权

JavaSE - 字符串

本节学习目标：

  • 了解并掌握字符串对象的声明与初始化；
  • 了解并掌握字符串使用运算符操作；
  • 了解并掌握如何获取字符串信息；
  • 了解并掌握字符串操作的有关方法；
  • 了解并掌握字符串的格式化方法；
  • 了解并掌握两种字符串生成器。

1. String 类

字符串（String）是Java语言中的一个引用数据类型，String类位于java.lang包下。在Java中所有字符串字面量，如"ABCDEFG"、"1234567"等，
用两个双引号包括起来的一串字符，都是实现了String类的一个实例，所以在Java语言中，字符串被看做是一个String类的对象。

1.1 字符串的声明

字符串变量的声明方式：

String 标识符;

字符串字面量（常量）的声明方式：使用两个双引号包括：

"Hello World!"，"Java Programming Language"

1.2 字符串变量的初始化

String类提供了很多构造方法，常用的构造方法如下：

  • String(String original)：引用字符串字面量初始化一个字符串变量：
String str = new String("Hello");

// 上面的等价于
String str = "Hello";
  • String(char[] value)：使用char类型的数组初始化一个字符串变量：
char[] charArr = new char[] {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArr);

// 上面的等价于
String str = "Hello";
  • String(char[] value, int offset, int count)：使用char类型的数组中，将从索引为offset开始的count个元素拼接作为字符串：
char[] charArr = new char[] {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArr, 1, 4);

// 上面的等价于
String str = "ello";

1.3 String 类的细节

  • String类本身被final关键字修饰，也就是说String类本身不可被继承；
  • 查看源码我们会发现，字符串底层是用的字符型数组（char[]）实现的，这个字符型数组成员变量也被final关键字修饰，所以说字符串一旦确定就不能更改。
  • 直接使用相同的字符串字面量初始化的两个字符串引用，它们引用的是同一个字符串对象。使用new关键字通过构造方法的字符串引用，即使内容相同，引用的是不同的对象。
String str1 = "HelloWorld";
String str2 = "HelloWorld";
String str3 = new String("HelloWorld");
System.out.println(str1 == str2);
System.out.println(str1 == str3);

// 运行结果
true
false

2. 连接字符串

字符串与字符串之间可以使用+运算符进行拼接操作，将两个字符串首尾相连拼接在一起成为一个新的字符串：

String str1 = "Hello";
String str2 = "World!";
String str3 = str1 + " " + str2;

// 上面的等价于
String str3 = "Hello World!";

如果字符串字面量太长需要换行，在Java语言中不能直接换行，需要使用+运算符进行拼接：

// 错误的换行
String str = "Hello
         World!";

// 正确的换行
String str = "Hello" +
        " World!";

字符串也可以和其他数据类型之间使用+运算符进行运算，运算结果为字符串类型，实质是将其他数据类型转换为字符串类型进行拼接：

int i = 59;
String str = "Hello" + i;

// 上面的等价于
String str = "Hello59";

只要+运算符两侧有一个为字符串类型，则运算结果就为字符串类型，所以需要多个操作数进行运算时要注意先后顺序，以免出现错误的结果。

3. 获取字符串信息

String类提供了很多方法来获取字符串的信息。

3.1 获取字符串长度

int length()方法可以获取字符串对象的长度。

String str = "Hello World!";
System.out.println(str.length());

// 运行结果
12

3.2 查找子字符串

  • int indexOf(String str)方法与int indexOf(String str, int fromIndex)方法：

第一个方法用于返回字符串str在指定字符串中首次出现的索引位置，会从指定字符串的开始位置开始从前往后查找。如果没有查找到，返回-1；
第二个方法可以指定查找的开始位置fromIndex。

String str = "AAA123AAA123AAA";
System.out.println(str.indexOf("123"));
System.out.println(str.indexOf("123", 4));

// 运行结果
3
9
  • int lastIndexOf(String str)方法与int lastIndexOf(String str, int fromIndex)方法：

第一个方法用于返回字符串str在指定字符串中最后一次出现的索引位置，会从指定字符串的末尾位置开始从后往前查找，如果没有查找到，返回-1；
第二个方法可以指定查找的开始位置fromIndex。

String str = "AAA123AAA123AAA";
System.out.println(str.lastIndexOf("123"));
System.out.println(str.lastIndexOf("123", 8));

// 运行结果
9
3

3.3 返回指定索引处的字符

char charAt(int index)方法返回指定索引处的字符。

String str = "ABCDEFG";
System.out.println(str.charAt(4));

// 运行结果
E

4. 字符串的操作方法

String类提供了很多操作字符串的方法。

4.1 获取子字符串

String substring(int beginIndex)方法与String substring(int beginIndex, int endIndex)方法：

第一个方法返回从指定的索引位置beginIndex开始截取直到该字符串结尾的子字符串；
第二个方法返回从指定的索引位置beginIndex开始截取直到索引位置endIndex结尾的子字符串。

String str = "HelloWorld!";
System.out.println(str.substring(3));
System.out.println(str.substring(4, 8));

// 运行结果
loWorld!
oWor

4.2 去除空格

String trim()方法返回字符串的副本，忽略字符串开头与结尾的空格，字符与字符中间的空格不会被忽略。

String str = "   Hello World!   ";
System.out.println("原来的字符串：" + str + "，它的长度" + str.length())
System.out.println("trim后字符串：" + str.trim() + "，它的长度" + str.trim().length());

// 运行结果
原来的字符串：   Hello World!   ，它的长度18
trim后字符串：Hello World!，它的长度12

4.3 字符串替换

String replace(char oldChar, char newChar)方法与String replace(CharSequence target, CharSequence replacement)方法。

第一个方法返回将原字符串内的指定字符oldChar替换为新字符newChar之后的字符串；
第二个方法返回将原字符串内的指定字符序列target替换为新字符序列replacement之后的字符串（字符序列可以看做字符串）。
如果一个字符串中出现多次oldChar或target，则两者会全部进行替换。

String str = "Hello World!";
System.out.println(str.replace('l', 'A'));
System.out.println(str.replace("o", "OOO"));

// 运行结果
HeAAo WorAd!
HellOOO WOOOrld!

4.4 判断字符串的开头与结尾

boolean startsWith(String prefix)方法与boolean endsWith(String suffix)方法。

startsWith()方法判断字符串是否以指定的内容开始，endsWith()方法判断字符串是否以指定的内容结束。

String str = "Hello World";
System.out.println("字符串str是否以“He”开头？" + str.startsWith("He"));
System.out.println("字符串str是否以“d!”结尾？" + str.endsWith("d!"));

// 运行结果
字符串str是否以“He”开头？true
字符串str是否以“d!”结尾？false

4.5 判断字符串是否相等

由于字符串为引用数据类型，所以不能直接使用==运算符判断。

String类提供了两种方法比较字符串是否相等：

  • 重写Object类提供的boolean equals(Object obj)方法：

String类的equals()方法判断步骤：

①直接使用==运算符判断对象obj与本字符串对象的地址是否相同，如果是则返回true；

②使用instanceof关键字判断对象obj是否是String类的一个实例，如果不是则返回false；

③将对象obj转换为字符串，比较obj的字符串形式的长度与本字符串长度是否相同，如果不相同则返回false；

④将对象obj的字符串形式的每个字符和本字符串的每个字符一一比对，如果全都相同则返回true，否则返回false。

  • equalsIgnoreCase(String anotherString)方法：与equals()方法判断步骤一样，但是忽略了字母的大小写。
String str1 = "HelloWorld";
Object str2 = new String("helloworld");
System.out.println("equals()方法判断：" + str1.equals(str2));
System.out.println("equalsIgnoreCase()方法判断：" + str1.equalsIgnoreCase(str2.toString()));

// 运行结果
equals()方法判断：false
equalsIgnoreCase()方法判断：true

4.6 按字典顺序比较两个字符串

int compareTo(String anotherString)方法按字典顺序比较两个字符串，该比较基于字符串中每个字符的Unicode值，
按字典顺序将本字符串与字符串anotherString进行比较，如果按字典顺序本字符串在anotherString之前，则返回一个负整数，
之后则返回一个正整数，如果本字符串使用equals()方法与anotherString字符串比较为true时，compareTo()方法返回0。

String str1 = "a";
String str2 = "b";
String str3 = "b";
String str4 = "c";
System.out.println("b与a比较" + str2.compareTo(str1));
System.out.println("b与b比较" + str2.compareTo(str3));
System.out.println("b与c比较" + str2.compareTo(str4));

// 运行结果
b与a比较1
b与b比较0
b与c比较-1

4.7 字母大小写转换

String toLowerCase()方法将本字符串中的大写字母转换为小写字母后返回该字符串；
String toUpperCase()方法将本字符串中的小写字母转换为大写字母后返回该字符串。

String str = "Hello World!";
System.out.println(str.toLowerCase());
System.out.println(str.toUpperCase());

// 运行结果
hello world!
HELLO WORLD!

4.8 字符串分割

String[] split(String regex)方法和String[] split(String regex, int limit)方法。

第一个方法可以使字符串按指定的字符，字符串或正则表达式分割成子字符串数组。第二个方法可以指定分割后的子字符串数组的元素个数。

String str = "HelloWorld!";
System.out.println(Arrays.toString(str.split("o")));
System.out.println(Arrays.toString(str.split("o", 2)));

// 运行结果
[Hell, W, rld!]
[Hell, World!]

5. 字符串的格式化

String类提供了静态方法format()用于格式化字符串，format()方法有两种重载形式：

  • String format(String format, Object... args)

    • format：格式化的字符串，使用格式化转换符；
    • args：格式化转换符引用的参数，参数的个数是可变的，如果参数个数多于格式化转换符个数，则剩下的参数个数将会被忽略，参数个数可以为0。

  • String format(Locale l, String format, Object... args)

    • l：格式化时使用的语言环境，指定为null时不进行本地化；
    • format：格式化的字符串，使用格式化转换符；
    • args：格式化转换符引用的参数，参数的个数是可变的，如果参数个数多于格式化转换符个数，则剩下的参数个数将会被忽略，参数个数可以为0。

5.1 日期字符串格式化

常用的日期格式化转换符：

日期格式化转换符说明示例
%te一个月中的某一天2
%tb指定语言环境的月份简称Feb、二月
%tB指定语言环境的月份全称February、二月
%tA指定语言环境的星期全称Monday、星期一
%ta指定语言环境的星期简称Mon、星期一
%tc全部日期和时间信息星期二 三月 25 13:37:22 CST 2017
%tY4位年份2017
%tj一年中的第几天076
%tm一年中的第几月07
%td一个月中的第一天15
%ty2位年份17

编写代码进行测试：

import java.util.Date;
import java.util.Locale;
public class TestDateFormat {
    public static void main(String[] args) {
        Locale.setDefault(Locale.ENGLISH); // 设置当前语言环境为英文环境
        Date date = new Date();            // 获取当前日期的对象
        System.out.println(String.format("%te", date));
        System.out.println(String.format("%tb", date));
        System.out.println(String.format("%tB", date));
        System.out.println(String.format("%tA", date));
        System.out.println(String.format("%ta", date));
        System.out.println(String.format("%tc", date));
        System.out.println(String.format("%tY", date));
        System.out.println(String.format("%tj", date));
        System.out.println(String.format("%tm", date));
        System.out.println(String.format("%td", date));
        System.out.println(String.format("%ty", date));
    }
}

运行结果：

2
Nov
November
Tuesday
Tue
Tue Nov 02 19:36:57 CST 2021
2021
306
11
02
21

5.2 时间字符串格式化

常用的时间格式化转换符：

时间格式化转换符说明示例
%tH24小时制的2位小时数（有0占位，00~23）14
%tI12小时制的2位小时数（有0占位，01~12）06
%tk24小时制的2位小时数（无0占位，0~23）9
%tl12小时制的2位小时数（无0占位，1~12）7
%tM2位分钟数（00~59）10
%tS2位秒钟数（00~60）09
%tL3位毫秒数（000~999）457
%tN9位微秒数（000000000~999999999）062000000
%tp指定语言环境的上下午标记pm、下午
%tzGMT时区偏移量+0900
%tZ时区缩写形式的字符串CST
%tsUNIX时间戳秒钟数（从1970-01-01 00:00:00至今经过的秒钟数）1635853859
%tQUNIX时间戳毫秒数（从1970-01-01 00:00:00至今经过的毫秒数）1635853859077

编写代码进行测试：

import java.util.Date;
import java.util.Locale;
public class TestTimeFormat {
    public static void main(String[] args) {
        Locale.setDefault(Locale.SIMPLIFIED_CHINESE); // 指定当前语言环境为简体中文环境
        Date date = new Date();                       // 获取当前日期的对象
        System.out.println(String.format("%tH", date));
        System.out.println(String.format("%tI", date));
        System.out.println(String.format("%tk", date));
        System.out.println(String.format("%tl", date));
        System.out.println(String.format("%tM", date));
        System.out.println(String.format("%tS", date));
        System.out.println(String.format("%tL", date));
        System.out.println(String.format("%tN", date));
        System.out.println(String.format("%tp", date));
        System.out.println(String.format("%tz", date));
        System.out.println(String.format("%tZ", date));
        System.out.println(String.format("%ts", date));
        System.out.println(String.format("%tQ", date));
    }
}

运行结果：

19
07
19
7
50
59
077
077000000
下午
+0800
CST
1635853859
1635853859077

5.3 日期时间组合的格式化

常用的日期和时间组合的格式化转换符：

日期时间组合格式化转换符说明示例
%tF“年-月-日”格式（4位年份）2021-11-02
%tD“月/日/年”格式（2位年份）11/02/21
%tc全部日期和时间信息星期二 十一月 02 20:02:20 CST 2021
%tr“时:分:秒 上下午”格式（12小时制）08:02:20 下午
%tT“时:分:秒”格式（24小时制）20:02:20
%tR“时:分”（24小时制）20:02

编写代码进行测试：

import java.util.Date;
import java.util.Locale;
public class TestDateTimeFormat {
    public static void main(String[] args) {
        Locale.setDefault(Locale.ENGLISH); // 设置当前语言环境为英文环境
        Date date = new Date();            // 获取当前日期的对象
        System.out.println(String.format("%tF", date));
        System.out.println(String.format("%tD", date));
        System.out.println(String.format("%tc", date));
        System.out.println(String.format("%tr", date));
        System.out.println(String.format("%tT", date));
        System.out.println(String.format("%tR", date));
    }
}

运行结果：

2021-11-02
11/02/21
Tue Nov 02 20:02:20 CST 2021
08:02:20 PM
20:02:20
20:02

5.4 基本类型字符串格式化

基本类型的格式化可以应用于任何参数类型，格式化转换符一览：

格式化转换符说明示例
%b、%B结果被格式化为布尔类型false
%h、%H结果被格式化为散列码（Hash值）eada0001
%s、%S结果被格式化为字符串类型266.6666666666667
%c、%C结果被格式化为字符类型‘N’
%d结果被格式化为十进制整数266
%o结果被格式化为八进制整数412
%x、%X结果被格式化为十六进制整数10a
%e结果被格式化为科学计数法十进制数2.666667e+02
%a结果被格式化为带有有效位数和指数的十六进制浮点数266.666667
%n结果为换行符
%<n>.f结果被格式化为有n位小数的浮点数266.667
%%结果为字面值%%

编写代码进行测试：

public class TestBaseFormat {
    public static void main(String[] args) {
        System.out.println("3>5 格式化 %b 为 " + String.format("%b", 3>5));
        System.out.println("1 格式化 %b 为 " + String.format("%b", 1));
        System.out.println("800/3.0 格式化 %h 为 " + String.format("%h", 800/3.0));
        System.out.println("800/3.0 格式化 %s 为 " + String.format("%s", 800/3.0));
        System.out.println("78 格式化 %c 为 " + String.format("%c", 78));
        System.out.println("800/3 格式化 %d 为 " + String.format("%d", 800/3));
        System.out.println("800/3 格式化 %o 为 " + String.format("%o", 800/3));
        System.out.println("800/3 格式化 %b 为 " + String.format("%x", 800/3));
        System.out.println("800/3.0 格式化 %b 为 " + String.format("%e", 800/3.0));
        System.out.println("800/3.0 格式化 %.3f 为 " + String.format("%.3f", 800/3.0));
        System.out.println("800/3.0 格式化 %.6f 为 " + String.format("%.6f", 800/3.0));
        System.out.println("%n 为 " + String.format("%n"));
        System.out.println("%% 为 " + String.format("%%"));
    }
}

运行结果：

3>5 格式化 %b 为 false
1 格式化 %b 为 true
800/3.0 格式化 %h 为 eada0001
800/3.0 格式化 %s 为 266.6666666666667
78 格式化 %c 为 N
800/3 格式化 %d 为 266
800/3 格式化 %o 为 412
800/3 格式化 %b 为 10a
800/3.0 格式化 %b 为 2.666667e+02
800/3.0 格式化 %.3f 为 266.667
800/3.0 格式化 %.6f 为 266.666667
%n 为 

%% 为 %

6. 字符串生成器

查看源码我们了解到String类底层使用了字符型数组来存储字符串，但是用来存储字符串的字符型数组成员变量被final关键字修饰，
也就意味着字符串对象一旦完成初始化，它的长度就被固定了，并且内容不能被改变。
在Java中虽然可以使用+运算符进行字符串的拼接，但是这种方法会产生一个新的String实例，会在内存中创建新的String对象，
如果重复的使用+运算符对字符串进行修改，将会极大地增加系统资源开销。

为了解决这个问题，Java提供了两种可变的字符串序列类StringBuffer和StringBuilder，它们也被称为字符串生成器，可以对字符串进行多次修改且不会增加新的对象，
大大提高了频繁修改字符串的效率。

6.1 StringBuffer 类与 StringBuilder 类的区别

AbstractStringBuilder抽象类位于java.lang包下，它是StringBuffer类和StringBuilder类的父类。

String类，StringBuffer类与StringBuilder类的继承树：

String类，StringBuffer类与StringBuilder类的继承树

AbstractStringBuilder抽象类已经定义好了绝大多数字符串生成器使用的方法，唯一的抽象方法为toString()。

  • StringBuffer的方法都被synchronized关键字修饰，因此StringBuffer是线程安全的，但执行效率要比StringBuilder低；
  • StringBuilder的方法没有被synchronized关键字修饰，因此StringBuffer是非线程安全的，所以执行效率要比StringBuffer高；
  • StringBuilder和StringBuffer都继承于AbstractStringBuilder抽象类，所以绝大多数方法的使用方式相同；
  • 在大多数情况下建议使用StringBuilder，因为它执行效率高。但是在多线程环境下必须使用StringBuffer，因为它是线程安全的。

6.2 字符串生成器变量的初始化

以StringBuilder为例，常用的构造方法如下：

  • StringBuilder()：初始化一个空内容的生成器，默认设置生成器的容量为16。
  • StringBuilder(int capacity)：初始化一个空内容的生成器，可以指定生成器的容量；
  • StringBuilder(String str)：使用字符串str初始化一个生成器，此生成器的容量为str的长度+16；
  • StringBuilder(CharSequence seq)：使用字符序列seq初始化一个生成器，此生成器的容量为seq的长度+16；

6.3 字符串生成器的容量

字符串生成器是可变长度的，所以它们的容量（Capacity）可以改变。

使用无参构造方法初始化的生成器的默认容量为16个字符：

StringBuilder sb = new StringBuilder();
System.out.println(sb.capacity());

// 运行结果
16

当生成器的容量不足时，会自动扩容当前容量，扩容规则：

  • 每次新增或插入新字符序列时会对当前容量进行判断；
  • 确定需要的最小容量（已经存储的字符串的长度加上准备存储的字符串的长度）是否大于当前容量，如果大于就扩容；
  • 容量扩充至当前容量的两倍+2，再次判断需要的最小容量是否大于当前容量，如果小于就扩容完成，如果大于则扩容至需要的最小容量；
  • 检测扩容后的容量（即char数组的长度）是否超过允许的最大值（Integer.MAX_VALUE - 8），如果超过则抛出异常（OutOfMemoryError）。
StringBuilder sb = new StringBuilder();
System.out.println(sb.capacity());
sb.append("ABCDEFGHIJKLMNOPQ");
// 添加17个字符，按照扩容规则16*2+2=34 > 17，所以扩容至当前容量的两倍
System.out.println(sb.capacity());
sb.append("ABCDEFGHIJKLMNOPQABCDEFGHIJKLMNOPQABCDEFGHIJKLMNOPQABC");
// 再添加54个字符，按照扩容规则34*2+2=70 < 17+54=71，所以扩容至最小容量

// 运行结果
16
34
71

6.4 字符串生成器的常用方法

以StringBuilder为例，常用的方法如下：

  • length()：获取生成器中当前字符串的长度。

  • capacity()：获取生成器的当前容量。

  • trimToSize()：将生成器的当前容量缩小至当前字符串的长度。

StringBuilder sb = new StringBuilder();
sb.append("HelloWorld!");
System.out.println(sb.capacity());
sb.trimToSize();
System.out.println(sb.capacity());

// 运行结果
16
11
  • append(Object obj)：新增方法有很多重载形式，几乎支持所有数据类型的新增操作，此方法直接把任何对象的字符串形式增加到当前字符串的尾部。
StringBuilder sb = new StringBuilder("Hello");
sb.append(1);
sb.append(false);
sb.append("World");
System.out.println(sb.toString());

// 运行结果
Hello1falseWorld
  • insert(int offset, Object obj)：插入方法也有很多重载形式，此方法将对象的字符串形式插入至索引offset位置。
StringBuilder sb = new StringBuilder("Hello");
sb.insert(3, "123");
System.out.println(sb.toString());

// 运行结果
Hel123lo
  • delete(int start, int end)：删除方法，删除索引start到索引end之间的字符串；
  • deleteChatAt(int index)：删除指定位置方法：删除索引index位置的字符。
StringBuilder sb = new StringBuilder("HelloWorld!");
sb.delete(1, 5);
System.out.println(sb.toString());
sb.deleteCharAt(5);
System.out.println(sb.toString());

// 运行结果
HWorld!
HWorl!
  • replace(int start, int end, String str)：替换方法：将索引start到索引end之间的字符串替换为指定字符串。
StringBuilder sb = new StringBuilder("HelloWorld!");
sb.replace(1, 5, "0");
System.out.println(sb.toString());

// 运行结果
H0World!
  • reverse()：反转方法：将当前字符串反转。
StringBuilder sb = new StringBuilder("HelloWorld!");
sb.reverse();
System.out.println(sb.toString());

// 运行结果
!dlroWolleH
「已注销」
关注
专栏目录
JavaSE 字符串的总结
12-22
JavaSE中的字符串是编程中非常基础且重要的概念，主要用于存储和操作文本数据。字符串在Java中是不可变的，这意味着一旦创建了一个字符串对象，就不能更改它的内容。它们被表示为`String`类型，并且属于核心库`java....
Java连接字符串
jijiangpeng的博客
07-03 2119
对于已经定义的字符串，可以对其进行各种操作。连接多个字符串是字符串操作中最简单的一种。通过字符串连接，可以将两个或多个字符串、字符、整数和浮点数等类型的数据连成一个更大的字符串。 使用连接运算符 “+”运算符是最简单、最快捷，也是使用最多的字符串连接方式。在使用“+”运算符连接字符串和 int 型（或 double 型）数据时，“+”将 int（或 double）型数据自动转换成 String...
java字符串循环移位函数_字符串循环移位
weixin_34036075的博客
02-27 1046
再看面试题时 出现了一个字符串左右移动循环的问题，看了一遍还没有弄懂，就发了点时间来看了一下字符数组与字符指针的问题，最终还是得到解决，呵呵，只要肯发功夫，还是会有收获的例如：有一组char的字符串：abcdefghijk 。你要循环左移3位变成ijkabcdefgh(也有写出ijkabcdefghi)；或右移三位变成defghijkabc(也有写成cdefghijkabc)；首先我们来解决字符串...
java:字符串变换
Claire的博客
02-25 718
java:字符串变换 题目 问题描述 　　相信经过这个学期的编程训练，大家对于字符串的操作已经掌握的相当熟练了。今天，徐老师想测试一下大家对于字符串操作的掌握情况。徐老师自己定义了1,2,3,4,5这5个参数分别指代不同的5种字符串操作，你需要根据传入的参数，按照徐老师的规定，对输入字符串进行格式转化。 　　徐老师指定的操作如下： 　　1 表示全部转化为大写字母输出，如abC 变成 ABC 　　2...
关于字符串拼接的几种方法
热门推荐
学而时习
05-24 1万+
字符串拼接方式 1、String中的 + 一，使用+拼接字符串 在Java中，拼接字符串最简单的方式就是直接使用符号+来拼接。如： String s1 = "hello"; String s2 = "world"; String s3 = s1 + "," + s2; 这里要特别说明一点，有人把Java中使用+拼接字符串的功能理解为运算符重载。其实并不是，Java是不支持运算符重载的。这其实只是Java提供的一个语法糖。后面再详细介绍。 概念普及： 运算符重载：在计算机程序设计中，运算符重载（英
java中的位移_JAVA中的位移运算
weixin_30269201的博客
02-15 3568
移位运算符就是在二进制的基础上对数字进行平移。我们知道，Java中byte、short和char类型在进行计算时都是先将其转换为int类型，同样在进行移位运算时也不例外。它们移位后的结果也都会变成int类型。由于int类型为32位的(1)，所以对于byte、short、char和int进行移位时，规定实际移动的次数最多是31位，如果超过31，则按n = n % 32来计算，也就是说移位33次和移位...
JavaSE--思维导图解析
07-26
+ 字符串 常量 * 利用 `final` 关键字进行定义 * `final` 关键字作用： + 修饰变量，定义一个常量，不能被修改 + 修饰方法，标识该方法不能被重写 + 修饰类，标识该类不能被继承 类型转换 * 强制类型转换 * ...
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
03-03
- **String对象的不可变性**：理解字符串常量池和字符串拼接的效率问题。 - **StringBuilder与StringBuffer**：在多线程环境下的适用性。 - **正则表达式**：如何使用正则进行字符串匹配和替换。 6. **方法与...
javase-file.zip
05-15
- `getPath()`：返回文件或目录的路径字符串。 - `getParent()`：获取当前文件的父路径。 - `getName()`：返回文件或目录的基本名称（不包括路径）。 7. **文件链接** - `toURI()` 和 `toURL()`：将文件转换为...
javaSE-java-core.pdf
11-05
在Java中，`String`类提供了对正则表达式的支持，如`matches()`用于验证字符串是否符合某个模式，`split()`用于根据正则表达式拆分字符串，以及`replaceAll()`用于替换匹配模式的部分。 在正则表达式中，有一些特殊...
java 字符串 移位_java中移位操作
weixin_31885977的博客
02-16 542
/**** @author SunRain*2013-10-14 8:09:50*在最后一个移位运算中，结果没有直接付给b，而是直接打印出来，所以结果是正确的，*其他的是会被先转换成int型，再进行右移操作，然后被截断，付给原来的类型，得到的结果可能不是正确的。*/public class URShift {public static void main(String[] args){int i ...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 452
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 945
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 990
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1008
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
spring循环依赖解决方式
qq_36400213的博客
11-04 489
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 335
默认对常规Session的理解和使用，如何使用Set-Cookie。
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 329
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 168
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
JavaSE入门：字符串搜索与程序类型解析
"JavaSE核心编程，包括字符串搜索示例，以及Java语言的基本介绍和程序类型解析" 在JavaSE核心编程中，字符串处理是至关重要的一个环节。在给出的示例代码中，我们看到如何使用Java对字符串进行搜索操作。`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值