Java学习笔记

最新推荐文章于 2024-07-24 17:27:32 发布

熊猫不睡教

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量16

点赞数

文章标签： java 学习笔记

本文链接：https://blog.csdn.net/m0_59824216/article/details/133145753

版权

字符串概述

字符串是一系列字符组成的序列；

// 字符
char str1 = '中';
char str2 = '1';
char str3 = 'A';
// 字符串
String str4 = "中国";
String str5 = "asdfgh";

计算字符串长度

// 数组长度
int[] nums = {1,2,3,4,5};
// 数组 length 属性
System.out.println(nums.length);  // 5

// 字符串长度
// 字符串和数组一样都是下标为0开始
String str = "hello,java!";
// 字符串 length() 方法
System.out.println(str.length());  // 11

比较字符串是否相等

== 比较方式是比较变量在内存中的地址是否相同，如果两个变量指向了统一内存地址则 == 为true
equals() 专门用来比较两个字符串的值

在 Java 中，== 和 equals() 都可以用于比较两个对象，但它们的比较方式不同。
== 操作符实际上比较的是两个对象的引用是否相同，即两个对象是否指向同一个内存地址。如果两个对象的引用相同，即它们指向同一个内存地址，则 == 操作返回 true。这个操作符适用于比较基本类型数据和对象的地址，但对于比较字符串这样的复杂类型，则不能使用 == 操作符。
equals() 方法用于比较两个对象的内容是否相同。具体来说，equals()方法是判断两个对象所包含的值是否相等。如果两个对象的内容相等，则equals()方法返回 true。在 Java 中，很多类都实现了equals()` 方法，例如 String、Integer 等。
为什么不能使用 == 比较两个字符串？这是因为在 Java 中，字符串是一种特殊的对象，存在于堆中。当我们创建一个字符串时，Java 会在堆中创建一个新的对象并将字符串存储在该对象中。如果我们再创建一个相同的字符串，Java 会在堆中再次创建一个新的对象，我们就得到了两个具有不同引用的字符串对象，即使它们包含的内容相同。因此，如果使用 == 操作符来比较两个字符串，将会比较它们的引用而不是它们的内容，结果通常是 false。
如果需要比较两个字符串的内容是否相等，应该使用 equals() 方法。例如：

String str1 = "hello";
String str2 = "hello";
if (str1.equals(str2)) {
  System.out.println("字符串相等");
}
// 在上述代码中，我们使用 `equals()` 方法来比较两个字符串对象的内容是否相等。如果相等，则输出字符串相等。

基本数据类型

在 Java 中，基本数据类型（Primitive Data Types）是可以使用==操作符进行比较的。Java 的基本数据类型包括以下 8 种：

byte	short
int	long
float	double
char	boolean

由于基本类型是用来存储具体值的，它们之间的比较是 ‘值’ 的比较，因此使用==操作符比较两个基本类型变量时，比较的是它们的值是否相等。当两个变量的值相同时，操作符==返回true，否则返回false。
例如：

int a = 5;
int b = 5;
if (a == b) {
    System.out.println("a == b");
}

在上述代码中，我们使用==操作符比较了两个基本类型变量a和b的值。由于它们的值相等，因此==操作符返回true，输出a == b。
需要注意的是，对于基本数据类型的包装类（Wrapper Class），例如Integer、Double等，它们是对象类型而不是基本类型，因此在比较它们的值时不能直接使用==操作符，而应该使用它们的equals()方法。例如：

Integer x = 5;
Integer y = 5;
if (x.equals(y)) {
    System.out.println("x equals y");
}

在上述代码中，我们使用equals()方法比较了两个Integer对象x和y的值。由于它们的值相等，因此equals()方法返回true，输出x equals y。如果使用==操作符比较x和y，则比较的是它们的引用，而不是它们的值，结果不一定是我们预期的值。

字符串大小写转换

//        字符串大小写转换
        String str1 = "abc";
        String str2 = "ABC";

//        toUpperCase(); 转换为大写
//        toLowerCase(); 转换为小写
        System.out.println(str1.toUpperCase());
        System.out.println(str2.toLowerCase());
    }

字符串拼接

jdk给String定义为 public final类型(final类型的类，在初始化后就不能在改变) 即String类型的对象的值是不变的，即内存中中的值不变；导致字符串在拼接时被拼接的字符串str1和str2在内存中的值不变依然会占用内存空间，拼接后的新字符串str3会在内存中重新开辟一块空间存放新字符串，导致内存空间的浪费；

//多次使用'+' 或 concat() 方法来拼接字符串，它们会创建大量的临时字符串对象，这可能会导致存储空间浪费和性能下降的问题。
//        拼接字符串两种方式
        String str1 = "abc";
        String str2 = "qwe";
// 	'+'拼接
        System.out.println( str1 + str2 );
// concat() 拼接
        System.out.println( str1.concat(str2));

String是一组不可变的字符序列，调用String类中的方法会产生新的字符序列，而原来的字符序列没有改变；

// 解决方式：在拼接时提供一个中间类： StringBuffer类(安全，效率低) 或 StringBuilder类(效率高，不安全)
// 拼接时不是字符串，拼接完成后才是字符串

StringBuffer类

常见方法：

方法	说明
StringBuffer.toString	将StringBuffer转换为字符串类型
StringBuffer.append(字符串)	在StringBuffer后面追加字符串
StringBuffer.insert(位置 , 参数)	将参数添加到StringBuffer的指定位置
StringBuffer.length()	获取StringBuffer的长度

//  拼接字符串 解决String类型变量占据内存空间问题
//  创建sb对象：类名 对象名 = new 类名();
        StringBuffer sb = new StringBuffer();
//  对象使用类中的方法
        sb.append("b");
        sb.append("c");
        sb.append("d");
//  和数组一样下标从0开始,指定位置添加
        sb.insert(0,"a");
//  将拼接的字符转换为String字符串类型
        String str = sb.toString();
        int len = sb.length();
        System.out.println(str);
        System.out.println(len);

截取字符串

截取 “青春无悔，无悔青春” 中第一个 “青春”

//        截取字符串
        String str = "青春无悔，无悔青春";
//        indexOf() 方法是 String 类中的一个方法，
//        用来查找指定字符串在另一个字符串中第一次出现的位置。
//        该方法返回第一次出现的指定字符串在调用该方法的字符串中的位置，如果没有出现则返回-1。
        int index = str.indexOf("无");
//        从后向前查找第一个出现的字符位置(下标位置)
        int lastIndex = str.lastIndexOf("无");
//        字符串下标为0开始，计算字符位置
        System.out.println("第一个'无'索引位置："+index);
        System.out.println("最后一个'无'索引位置："+lastIndex);
//        截取第一个‘无’前的‘青春’
//        substring(开始下标位置（包含）,结束下标位置（不包含）); 截取区间内的字符
        String newStr = str.substring(0,str.indexOf("无"));
        System.out.println(newStr);

indexOf()

在 Java 中，indexOf() 方法是 String 类中的一个方法，它用来查找指定字符串在另一个字符串中第一次出现的位置。该方法返回第一次出现的指定字符串在调用该方法的字符串中的位置，如果没有出现则返回-1。

lastIndexOf()

从后向前查找第一个出现的字符位置(下标位置)

substring()

在 Java 中，substring() 是 String 类中用于获取子字符串的方法。该方法有几种不同的形式，它们的参数和功能略有不同。
其中，最常用的形式是：String substring(int beginIndex, int endIndex)，该方法用于获取从 beginIndex（包括）开始到 endIndex（不包括）所指定位置之间的子字符串。
例如：

String str = "Hello World!";
String subStr = str.substring(0, 5);
System.out.println(subStr); // 输出 "Hello"

在上面的例子中，我们使用了 substring() 方法获取了从索引 0（即首字符）开始，到索引 5（即 “o” 所在的位置，不包括 “o”）为止的子字符串，即 “Hello”。
需要注意的是，Java 中的字符串是不可变的（immutable），因此子字符串也是不可变的。例如：

String str = "Hello World!";
String subStr = str.substring(6);
System.out.println(subStr); // 输出 "World!"
subStr = "Bye";
System.out.println(str);    // 输出 "Hello World!"

在上面的例子中，我们首先使用了 substring() 方法获取了从索引 6 开始到字符串的末尾为止的子字符串 “World!”，然后将该子字符串重新赋值为 “Bye”。但是，我们发现原始字符串 “Hello World!” 并没有改变，这是因为子字符串是不可变的。
此外，在使用 substring() 方法时，需要注意边界问题，例如要获取从字符串的开始位置开始的子字符串，可以将 beginIndex 的值设置为0。而要获取从字符串结尾处开始的子字符串，则可以将 endIndex 的值设置为字符串的 length()。
例如，以下代码分别获取了字符串的前3个字符和最后4个字符：

String str = "Hello World!";
String subStr1 = str.substring(0, 3);         // 获取第1个到第3个字符，即 "Hel"
String subStr2 = str.substring(str.length() - 4); // 获取倒数 4 个字符，即 "rld!"

总之，substring() 方法可以用于获取主字符串中的子字符串，并可以通过指定 beginIndex 和 endIndex 来控制子字符串的范围，但是需要注意边界问题和子字符串是不可变的。

检查字符串

检查邮件地址和文件后缀是否符合要求：
邮箱：aaa@126.com
文件：bbb.png

        String str = "aaa@126.com";
        String str1 = "bbb.jpg";
//        startsWith()、endsWith()判断字符串前缀或后缀（区分大小写） 返回布尔类型
        boolean con = str.endsWith(".com");
        System.out.println(con);
        boolean con1 = str.startsWith("a");
        System.out.println(con1);
        boolean con2 = str1.endsWith(".png") || str1.endsWith(".jpg");
        System.out.println(con2);

在 Java 中，endsWith() 和 startsWith() 方法都是 String 类中用于判断字符串前缀或后缀的方法，它们的功能分别为测试调用该方法的字符串是否以指定的后缀或前缀结束或开始。
startsWith() 方法的常用形式有两种：
boolean startsWith(String prefix)：测试调用该方法的字符串是否以指定的前缀（即 prefix 参数）开始；
boolean startsWith(String prefix, int toffset)：测试调用该方法的字符串从指定的偏移量（即 toffset 参数）开始是否以指定的前缀（即 prefix 参数）开始。
以下是 startsWith() 方法的使用示例：

String str = "Hello World!";
boolean startsWith = str.startsWith("Hello");
System.out.println(startsWith);  // 输出 true

在以上示例中，我们使用 startsWith() 方法判断字符串 “Hello World!” 是否以前缀 “Hello” 开始，并将结果存储在布尔类型的变量 startsWith 中。
endsWith() 方法的也有两种形式：
- boolean endsWith(String suffix)：测试调用该方法的字符串是否以指定的后缀（即 suffix 参数）结束；
- boolean endsWith(String suffix, int length)：测试调用该方法的字符串在指定的长度（即 length 参数）内是否以指定的后缀（即 suffix 参数）结束。
以下是 endsWith() 方法的使用示例：

String str = "Hello World!";
boolean endsWith = str.endsWith("World!");
System.out.println(endsWith);  // 输出 true

在以上示例中，我们使用 endsWith() 方法判断字符串 “Hello World!” 是否以后缀 “World!” 结束，并将结果存储在布尔类型的变量 endsWith 中。
注意：startsWith() 和 endsWith() 方法都是区分大小写的。
总之，startsWith() 和 endsWith() 方法都可以用于对字符串前缀或后缀进行判断，它们都返回一个布尔类型的值，表示字符串是否以指定的前缀或后缀开始或结束。

分割字符串

分割字符串首先需要有分割标志（即截取依据）；
根据 ‘ ， ’ 分隔 ”你好，小米，hello world“；

 String str = "你好，小米，hello world";
//  String[] strs 定义一个String类型的数组
//  split("，") : 根据 ， 分割字符串
        String[] strs = str.split("，");
        System.out.println(strs.length);
        for (int i=0; i< strs.length; i++){
            System.out.println(strs[i]);
        }
// 3
// 你好
// 小米
// hello world

split()

[split:分割、切分]
在 Java 中，split() 方法是 String 类中用于将字符串分割成一个字符串数组的方法。该方法会将一个字符串按照指定的分隔符分割成多个子字符串，并将这些子字符串存储在一个字符串数组中，最终返回该数组。

split() 方法有两种常用形式：
- String[] split(String regex)：按照正则表达式（即 regex 参数）将字符串分割成多个子字符串；
- String[] split(String regex, int limit)：按照正则表达式将字符串分割成多个子字符串，并指定分割的次数上限。
- 以下是 split() 方法的使用示例：
```
String str = "apple,banana,pear,orange";
String[] fruits = str.split(",");
for (String fruit: fruits) {
    System.out.println(fruit);
}
```
- 在以上示例中，我们使用 split() 方法按照逗号将字符串 “apple,banana,pear,orange” 分割成多个子字符串，并将它们存储在一个字符串数组中，最后通过 for 循环遍历输出。
- 注意，如果在分隔符之间有多个连续的空格，split() 方法会将其看成一个分隔符处理。例如：
```
String str = "apple, banana,  pear,   orange";
String[] fruits = str.split(",");
for (String fruit: fruits) {
    System.out.println(fruit);
}
```
- 在以上示例中，我们同样按照逗号分割字符串 “apple, banana, pear, orange”，但是注意到在分隔符之间有多个连续的空格，这些空格会被当成一个空格处理。
- 同时，如果分割次数已经到达了指定的上限，则不会继续进行分割。例如：
```
String str = "apple,banana,pear,orange";
String[] fruits = str.split(",", 2);
for (String fruit: fruits) {
    System.out.println(fruit);
}
```
- 在以上示例中，我们将分割次数上限设置为2，即最多只分割成两个子字符串。结果输出为：
```
apple
banana,pear,orange
```
- 总之，split() 方法是 String 类中的一个重要方法，可以将一个字符串按照指定的分隔符分割成多个子字符串，并将这些子字符串存储在一个字符串数组中返回。它通常被广泛应用于文本处理和数据分析等领域。

String常用方法

字符串的长度：int length()
获取指定位置的字符：char charAt(int index)
获取指定范围的字符子串：String substring(int beginIndex, int endIndex)
将字符串中的某个字符替换成另一个字符：String replace(char oldChar, char newChar)
将字符串中的某个子字符串替换成另一个字符串：String replace(CharSequence target, CharSequence replacement)
将字符串中的某个子字符串删除：String replaceAll(String regex, String replacement)
将一个字符串连接到另一个字符串结尾：String concat(String str)
将字符串全部转换为大写或小写：String toUpperCase() / String toLowerCase()
以指定的字符串为分隔符将字符串分割成数组：String[] split(String regex)
判断字符串是否包含某个子字符串：boolean contains(CharSequence s)
判断字符串是否以指定的前缀或后缀开始或结束：boolean startsWith(String prefix) / boolean endsWith(String suffix)
将字符串转换为字节数组或字符数组：byte[] getBytes(Charset charset) / char[] toCharArray()
将字符串中的空白字符删除或裁剪：String trim()