java核心类库（二） String类

最新推荐文章于 2024-07-20 07:51:53 发布
最新推荐文章于 2024-07-20 07:51:53 发布
阅读量129 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43835305/article/details/108216717
版权

二、String类的概述和使用

2.1 String类的概念（重点）

  • java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描
    述，如：“abc”。
  • 该类由 final 关键字修饰，表示该类不能被继承
  • 从 jdk1.9 开始该类的底层不使用 char[ ] 来存储数据，而是改成 byte[ ] 加上编码标记，从而节约了一
    些空间
  • 该类描述的字符串内容是个常量（final修饰不可改变，byte[ ]数组长度不可改变）不可更改，因此可以被共享使用
    注：常量存储在方法区
String str1 = "abc"; // 其中"abc"这个字符串是个常量不可改变
String str1 = "123"; // 将"123"字符串的地址赋值给str1
                     // 改变str1的指向，并没有改变所指向的内容

String引用类型的指向

2.2 常量池的概念（原理）

由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，从而提高了性能。

public class StringPoolTest {
    public static void main(String[] args) {
        // 1.验证一下常量池的存在
        // 到目前为止，只有String这个特殊类除了new的方式外还可以直接字符串赋值（包装类除外）
        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1 == str2); // 比较地址 true
    }
}

2.3 常用的构造方法（练熟、记住)

方法声明功能介绍
String()使用无参方式构造对象得到空字符序列
String(byte[] bytes, int offset, int length)使用bytes数组中下标从offset位置开始的length个字节来构造对象
String(byte[] bytes)使用bytes数组中的所有内容构造对象
String(char[] value, int offset, int count)使用value数组中下标从offset位置开始的count个字符来构造对象
String(char[] value)使用value数组中的所有内容构造对象
String(String original)根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本
public class StringConstuctorTest{
    public static void main(String[] args){
        // 1.使用无参方式构造对象使用
        String str1 = new String();
        // ""表示空字符串对象，有对象只是内部内有内容
        // null表示空，连对象都没有
        System.out.pringln("str1="+str1); // ""
        
         // 2.使用参数指定的byte数组来构造对象并打印
        //byte[] bArr = new byte[] {65, 66, 67, 68, 69};
        byte[] bArr = {65, 66, 67, 68, 69};
        // 使用字节数组中的一部分来构造对象，表示使用数组bArr中下标从1开始的3个字节构造字符串对象
        // 66-'B' 67-'C' 68-'D' => BCD
        String str2 = new String(bArr, 1, 3);
        System.out.println("str2 = " + str2); // BCD

        // 使用整个字节数组来构造字符串对象
        String str3 = new String(bArr);
        System.out.println("str3 = " + str3); // ABCDE

        // 3.使用字符数组来构造对象并打印
        //char[] cArr = new char[]{'h', 'e', 'l', 'l', 'o'};
        char[] cArr = {'h', 'e', 'l', 'l', 'o'};
        // 使用字符数组中的一部分来构造对象，表示使用数组cArr中下标从1开始的3个字符串构造字符串对象
        String str4 = new String(cArr, 1, 3);
        System.out.println("str4 = " + str4); // ell
        // 使用整个字符数组来构造字符串对象
        String str5 = new String(cArr);
        System.out.println("str5 = " + str5); // hello

        // 4.使用字符串来构造字符串对象
        String str6 = new String("world");
        System.out.println("str6 = " + str6); // world
        
    }
}

笔试考点

**注意：**new String(String original)构造方法，一共创建两个对象
一个在常量池中（字符串），一个在堆区（new创建的对象）

对象创建说明

public class StringExamTest {

    public static void main(String[] args) {

        // 1.请问下面的代码会创建几个对象？分别存放在什么地方？
        //String str1 = "hello"; // 1个对象 存放在常量池中
        //String str1 = new String("hello"); // 2个对象 一个在常量池中，一个在堆区

        // 2.问题：下列分别打印什么内容？（常量池和堆区对象的比较）
        String str1 = "hello"; // 常量池
        String str2 = "hello"; // 常量池
        String str3 = new String("hello"); // 堆区
        String str4 = new String("hello"); // 堆区

        System.out.println(str1 == str2);       // true  比较地址
        System.out.println(str1.equals(str2));  // true  比较内容
        System.out.println(str3 == str4);       // false 比较地址
        System.out.println(str3.equals(str4));  // true  比较内容
        System.out.println(str2 == str3);       // false 比较地址
        System.out.println(str2.equals(str3));  // true  比较内容

        // 3.常量优化机制，变量没有优化机制
        String str5 = "abcd";
        String str6 = "ab" + "cd"; // 常量优化机制
        System.out.println(str5 == str6); // true 比较地址

        String str7 = "ab";
        String str8 = str7 + "cd"; // str7是变量，所有没有优化机制
        System.out.println(str5 == str8); // false 比较地址

    }
}

2.3 常用的成员方法（练熟、记住）

String类和数组之间的转换

方法声明功能介绍
String toString()返回字符串本身
byte[] getBytes()将当前字符串内容转换为byte数组并返回
char[] toCharArray()用于将当前字符串内容转换为char数组并返回
使用案例
public class StringByteCharTest {

    public static void main(String[] args) {

        // 1.创建String类型的对象并打印
        String str1 = new String("world");
        System.out.println("str1 = " + str1); // world

        // 2.实现将String类型转换为Byte类型并打印
        // 思路：先将字符串拆分为字符，再将每个字符转换byte类型，即获取所有字符的ASCII码
        byte[] bArr = str1.getBytes();
        for(int i = 0; i < bArr.length; i++) {
            System.out.println("下标为" + i + "的元素是：" + bArr[i]);
        }
        // 将byte类型转回String类型
        String str2 = new String(bArr);
        System.out.println("byte类型转回字符串为：" + str2); // world

        // 3.实现将String类型转换为char数组类型并打印
        // 思路：将字符串拆分为字符并保存到char数组中
        char[] cArr = str1.toCharArray();
        for(int i = 0; i < cArr.length; i++) {
            System.out.println("下标为" + i + "的元素是：" + cArr[i]);
        }
        // 将char类型的数组转回到String类型并打印
        String str3 = new String(cArr);
        System.out.println("char数组转回字符串为: " + str3);
    }
}

String类中长度及字符的获取

方法声明功能介绍
char charAt(int index)方法charAt用于返回字符串指定位置的字符
int length()返回字符串字符序列的长度
boolean isEmpty()判断字符串是否为空
使用案例
public class StringCharTest {

    public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("hello");
        System.out.println("str1 = " + str1);

        // 2.获取字符串的长度和每个字符并打印
        System.out.println("字符串的长度为：" + str1.length()); // 5
        System.out.println("下标为0的字符为：" + str1.charAt(0)); // h
        System.out.println("下标为1的字符为：" + str1.charAt(1)); // e
        System.out.println("下标为2的字符为：" + str1.charAt(2)); // l
        System.out.println("下标为3的字符为：" + str1.charAt(3)); // l
        System.out.println("下标为4的字符为：" + str1.charAt(4)); // o
        //System.out.println("下标为5的字符为：" + str1.charAt(5)); // 编译ok，运行报错
        // StringIndexOutOfBoundsException 字符串下标越界异常
        /**
         * 至此，一共出现过7种异常
         * 1.算术异常：ArithmeticException
         * 2.数组越界异常：ArrayIndexOutOfBoundsException
         * 3.空指针异常：NullPointerException
         * 4.类型转换异常：ClassCastException
         * 5.非法参数异常：IllegalArgumentException
         * 6.数字格式异常：NumberFormatException
         * 7.字符串下标越界异常：StringIndexOutOfBoundsException
          */

        // 3.使用for循环获得所有字符
        for(int i = 0; i < str1.length(); i++) {
            System.out.println("下标为" + i + "的字符为：" + str1.charAt(i));
        }

        // 4.判断字符串是否为空
        System.out.println(0 == str1.length()? "字符串为空": "字符串不为空");
        System.out.println(str1.isEmpty()? "字符串为空": "字符串不为空");
    }
}
笔试考点

使用两种方式实现字符串"12345"装换为整数12345并打印

public class StringCharTest {
    public static void main(String[] args) {

        String str2 = new String("12345");
        // 方式一：调用Integer类中的parseInt()方法即可
        int ia = Integer.parseInt("12345");
        System.out.println("转换出来的整数是：" + ia); // 12345
        // 方式二：利用ASCII码来实现类型转换并打印
        // '1' - '0' => 1     '2' - '0' => 2 ... (字符0的ASCII码是48)
        int ib = 0;
        for(int i = 0; i < str2.length(); i++) {
            ib = ib*10 + (str2.charAt(i) - '0');
        }
        System.out.println("转换出来的整数是：" + ib);
        
        // 如何实现整数到字符串的转换
        // String str3 = String.valueOf(ib);
        String str3 = "" + ib;    //开发中推荐使用
        System.out.println("str3 = " + str3);
    }
}
案例----回文数判断
  • 判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读还是从右向左读都是相同的句子
public class StringJudeTest{
    public static void main(String[] args){
        // 1.创建字符串对象并打印
        String str1 = new String("上海自来水来自海上");
        System.out.println("str1 = " + str1);
        // 2.判断该字符串内容是否为回文并打印
        for(int i = 0; i < str1.length()/2; i++) {
            if (str1.charAt(i) != str1.charAt(str1.length()-i-1)) { // 0和9 1和8 3和7
                System.out.println("不是回文！");
                return; // 仅仅是用于实现方法的结束
            }
        }
        System.out.println("是回文！");
    }
}

String类中大小比较关系

比较大小关系有大于、小于和等于三种关系，而布尔类型只有false和true两种，无法表示，所以使用int类型类表示大小关系

方法声明功能介绍
int compareTo(String anotherString)用于比较调用对象和参数对象的大小关系
int compareToIgnoreCase(String str)不考虑大小写，也就是’a’和’A’是相等的关系

字符串之间比较大小：两个字符串从左到右比较相同索引位置字符的ASCII码大小，当较短的字符串和较长的字符串的前部分相同，则比较长度

案例 — 比较字符串的大小
public class StringCompareTest {

    public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("hello");
        System.out.println("str1 = " + str1); // hello

        // 2.使用构造好的对象与其它字符串对象之间比较大小并打印
        System.out.println(str1.compareTo("world"));  // 'h'-'w' => 104 - 119 => -15
        System.out.println(str1.compareTo("haha"));   // 'e'- 'a' => 101 - 97  => 4
        System.out.println(str1.compareTo("hehe"));   // 'l'-'h' => 108 - 104 => 4
        System.out.println(str1.compareTo("heihei")); // 'l'-'i' => 108 - 105 => 3
        System.out.println(str1.compareTo("helloworld")); // 长度： 5 - 10 => -5
        System.out.println(str1.compareToIgnoreCase("HELLO")); // 0
    }
}

String类实现各种方法的使用

方法声明功能介绍
String concat(String str)用于实现字符串的拼接
boolean contains(CharSequence s)用于判断当前字符串是否包含参数指定的内容
String toLowerCase()返回字符串的小写形式
String toUpperCase()返回字符串的大写形式
String trim()返回去掉前导和后继空白的字符串
boolean startsWith(String prefix)判断字符串是否以参数字符串开头
boolean startsWith(String prefix, int toffset)从指定位置开始是否以参数字符串开头
boolean endsWith(String suffix)判断字符串是否以参数字符串结尾
使用案例
public class StringManyMethodTest{
    public static void main(String[] args){
        // 1.构造String类型的对象并打印
        String str1 = new String("     Let Me Give You Some Color To See See!");
        System.out.println("str1 = " + str1); //Let Me Give You Some Color To See See

        // 2.实现各种成员方法的调用和测试
        boolean b1 = str1.contains("some");
        System.out.println("b1 = " + b1); // false  区分大小写
        b1 = str1.contains("Some");
        System.out.println("b1 = " + b1); // true

        System.out.println("----------------------------------------------");
        // 将所有字符串转换为大写  小写  以及去除两边的空白字符
        String str2 = str1.toUpperCase();     // str1本身不变
        System.out.println("str2 = " + str2); //LET ME GIVE YOU SOME COLOR TO SEE SEE
        // str1为常量
        System.out.println("str1 = " + str1); //Let Me Give You Some Color To See See   

        String str3 = str1.toLowerCase();
        System.out.println("str3 = " + str3); //let me give you some color to see see
        System.out.println("str1 = " + str1); //Let Me Give You Some Color To See See

        String str4 = str1.trim();
        System.out.println("str4 = " + str4); //Let Me Give You Some Color To See See

        System.out.println("----------------------------------------------");
        // 判断字符串是否以...开头  以...结尾
        b1 = str1.startsWith("Let");
        System.out.println("b1 = " + b1); // false
        b1 = str1.startsWith(" ");
        System.out.println("b1 = " + b1); // true
        // 从下标5开始是否以"Let"开头
        b1 = str1.startsWith("Let", 5);
        System.out.println("b1 = " + b1); // true

        b1 = str1.endsWith("See");
        System.out.println("b1 = " + b1); // false
        b1 = str1.endsWith("See!");
        System.out.println("b1 = " + b1); // true
    }
}

String类实现字符串内容比较

方法声明功能介绍
boolean equals(Object anObject)用于比较字符串内容是否相等并返回
int hashCode()获取调用对象的哈希码值
boolean equalsIgnoreCase(String anotherString)用于比较字符串内容是否相等并返回，不考虑大小写， 如：'A’和’a’是相等
案例—模拟登录功能

提示用户从键盘输入用户名和密码信息，若输入”admin”和”123456”则提示“登录成功，欢迎使 用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已 冻结，请联系客服人员！”

import java.util.Scanner;

public class StringEqualsTest {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        for (int i = 3; i > 0; i--) {
            // 1.提示用户从键盘输入用户名和密码信息并使用变量记录
            System.out.println("请输入您的用户名和密码信息：");
            String userName = sc.next();
            String password = sc.next();

            // 2.判断用户名和密码是否为"admin"和"123456"并给出提示
            //if ("admin".equals(userName) && "123456".equals(password)) {
            // 忽略大小写	
            if ("admin".equalsIgnoreCase(userName) && "123456".equals(password)) { 		
            // 如果写成下面的形式，由于userName有可能为null，会引起空指针异常
            // if (userName.equalsIgnoreCase("admin") && "123456".equals(password)) {
                System.out.println("登录成功，欢迎使用！");
                break;
            } //else {
            if (1 == i) {
                System.out.println("账户已冻结，请联系客服人员！");
            } else {
                System.out.println("用户名或密码错误，您还有" + (i - 1) + "次机会！");
            }
            //}
        }
        // 关闭扫描器
        sc.close();
    }
}

String类中实现字符和字符串的正反向查找

方法声明功能介绍
int indexOf(int ch)用于返回当前字符串中参数ch指定的字符第一次出现的下标
int indexOf(int ch, int fromIndex)用于从fromIndex位置开始查找ch指定的字符
int indexOf(String str)在字符串中检索str返回其第一次出现的位置，若找不到返回-1
int indexOf(String str, int fromIndex)表示从字符串的fromIndex位置开始检索str第一次出现的位置
int lastIndexOf(int ch)用于返回参数ch指定的字符后一次出现的下标
int lastIndexOf(int ch, int fromIndex)用于从fromIndex位置开始查找ch指定字符出现的下标
int lastIndexOf(String str)返回str指定字符串后一次出现的下标
int lastIndexOf(String str, int fromIndex)用于从fromIndex位置开始反向搜索的第一次出现的下标

注：当字符或字符串不存在被查找的字符串中时，返回-1代表查找失败

​ 查找字符串时返回字符串中第一个字符的下标

案例----字符串查找

编写通用的代码可以查询字符串"Good Good Study, Day Day Up!"中所有"Day"出现的索引位置并打印出来

public class StringIndexTest {

    public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("Good Good Study, Day Day Up!");
        System.out.println("str1 = " + str1); // Good Good Study, Day Day Up!

        // 2.实现字符串中指定字符和字符串的查找功能
        int pos = str1.indexOf('g');
        System.out.println("pos = " + pos); // -1  代表查找失败
        pos = str1.indexOf('G');
        System.out.println("pos = " + pos); // 0   该字符第一次出现的索引位置
        // 表示从下标0开始查找字符'G'第一次出现的索引位置，包含0
        pos = str1.indexOf('G', 0);
        System.out.println("pos = " + pos); // 0
        pos = str1.indexOf('G', 1);
        System.out.println("pos = " + pos); // 5

        System.out.println("------------------------------------------------------");
        // 查找字符串
        pos = str1.indexOf("day");
        System.out.println("pos = " + pos); // -1
        pos = str1.indexOf("Day");
        System.out.println("pos = " + pos); // 17   字符串中第一个字符的下标
        pos = str1.indexOf("Day", 17);
        System.out.println("pos = " + pos); // 17   字符串中第一个字符的下标
        pos = str1.indexOf("Day", 18);
        System.out.println("pos = " + pos); // 21   字符串中第一个字符的下标

        System.out.println("------------------------------------------------------");
        // 编写通用代码实现将字符串str1中所有"Day"出现的索引位置找到并打印出来
        pos = str1.indexOf("Day");
        while (-1 != pos) {
            System.out.println("pos = " + pos); // 17
            pos = str1.indexOf("Day", pos+1);
        }

        System.out.println("------------------------------------------------------");
        // 优化一下
        pos = 0;
        while ((pos = str1.indexOf("Day", pos)) != -1) {
            System.out.println("pos = " + pos);
            pos += "Day".length();
        }

        System.out.println("------------------------------------------------------");
        // 3.实现字符和字符串内容的反向查找
        pos = str1.lastIndexOf('G');
        System.out.println("pos = " + pos); // 5
        // 从下标5的位置开始反向查找
        pos = str1.lastIndexOf('G', 5);
        System.out.println("pos = " + pos); // 5

        pos = str1.lastIndexOf('G', 6);
        System.out.println("pos = " + pos); // 5

        pos = str1.lastIndexOf('G', 4);
        System.out.println("pos = " + pos); // 0

        System.out.println("------------------------------------------------------");
        pos = str1.lastIndexOf("Day");
        System.out.println("pos = " + pos); // 21
        pos = str1.lastIndexOf("Day",  21);
        System.out.println("pos = " + pos); // 21
        pos = str1.lastIndexOf("Day", 20);
        System.out.println("pos = " + pos); // 17
        pos = str1.lastIndexOf("Day", 15);
        System.out.println("pos = " + pos); // -1
    }
}

String类中字符串的获取

方法声明功能介绍
String substring(int beginIndex, int endIndex)返回字符串中从下标beginIndex（包括）开始到 endIndex（不包括）结束的子字符串
String substring(int beginIndex)返回字符串中从下标beginIndex（包括）开始到字符串结尾 的子字符串
使用案例
public class SubStringTest {

    public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("Happy Wife, Happy Life!");
        System.out.println("str1 = " + str1); // Happy Wife, Happy Life!

        // 2.获取字符串中的一部分内容并打印
        // 表示从当前字符串中下标12开始获取子字符串
        String str2 = str1.substring(12);
        System.out.println("str2 = " + str2); // Happy Life!
        // 可以取到6但是取不到10
        String str3 = str1.substring(6, 10);
        System.out.println("str3 = " + str3); // Wife
    }
}
案例 — 字符串获取

提示用户从键盘输入一个字符串和一个字符，输出该字符(不含)后面的所有子字符串

import java.util.Scanner;
public class SubStringTest {

    public static void main(String[] args) {
        // 获取输入字符串中从输入字符起的子字符串内容
        System.out.println("请输入一个字符串：");
        Scanner sc = new Scanner(System.in);
        String str4 = sc.next();
        System.out.println("请输入一个字符：");
        String str5 = sc.next();
        // 从str4中查找str5第一次出现的索引位置
        int pos = str4.indexOf(str5);
        System.out.println("pos = " + pos);
        // 根据该位置获取子字符串
        String str6 = str4.substring(pos+1);
        System.out.println("获取到的子字符串是：" + str6);
    }
}

正则表达式

注：本内容为个人拉勾教育大数据学习课程笔记！

是你得不到的人
关注
专栏目录
Java 常用类库详解
fudaihb的博客
06-18 1091
Java 作为一种广泛使用的编程语言，提供了丰富的类库来支持各种开发需求。这些类库涵盖了从基础的数据结构、网络通信到图形界面、并发编程等各个方面。本文将详细介绍一些在Java开发中常用的类库，帮助开发者更好地理解和使用这些工具来提升开发效率。
模块三作业解题思路
weixin_43835305的博客
08-27 821
拉勾教育大数据训练营模块三作业
JAVA开发面试题&String篇&第一部分
zsk1996888的博客
11-15 670
JAVA开发面试题&String篇&第一部分169.下面程序的运行结果是（）（选择一项）170.Java语言中，String类中的indexOf()方法返回值的类型是（）171.给定以下代码，程序的运行结果是 （）172.执行下列代码后，哪个结论是正确的（）（选择两项）173.实现String类的replaceAll方法174.在“=”后填写适当的内容：175.是否可以继承String类?188.String类为什么是final的176.给定两个字符串s和t， 写一个函数来决定是否t是s的重
Java核心类库
qq_50048558的博客
08-13 3884
Java核心类库
JAVA-核心类库
分享，学习，专注，努力，向上。
06-30 1524
Java核心类库是指Java语言提供的一组基础类和接口，用于处理常见的任务和操作，包括字符串处理、集合操作、IO操作、多线程等。熟练掌握Java核心类库的使用，可以提高开发效率和编写高质量的Java应用程序的能力。
Java String 类
最新发布
lly202406的博客
07-20 425
Java中的String类是Java语言中最常用的类之一，用于处理文本数据。它提供了丰富的API来执行各种字符串操作，如创建、查找、替换和比较字符串等。String类在java.lang包中定义，因此在使用时不需要导入。
【Java】String类
a6458360的博客
08-03 268
1.实例化String类对象 有两种方式: package m10d26; public class String_1 { public static void main(String[] args) { //实例化方式一 String name1="张三"; System.out.println(name1); //实例化方式二 String name2=new String("李四"); System.out.println(name2); } } 123456
Java 核心类库一览
程序员蜗牛
06-15 2864
作者：白色蜗牛来源：蜗牛互联网阅读本文你将收获：类库与 JAR 文件什么是类库我们知道，在面向对象的程序设计里，一个类是可以调用另外一个类的方法，只要把被调用的那个类引入到 classp...
JAVA_ClassLib.rar_classlib ja_java 类库_java核心_java类库手册
09-21
`JAVA_ClassLib.rar_classlib ja_java 类库_java核心_java类库手册` 这个压缩包文件包含了一份详细的 Java 类库指南，旨在帮助学习者深入理解和运用Java的核心功能。 首先，我们要明白Java类库的重要性。类库是预...
Java -核心类库 Object类常方法 Math类常用方法 System类常用方法 基本类型包装类常用方法等
05-05
### Java核心类库详解 #### 一、Object类常用方法 在Java中，`Object`类是最基础的类，所有其他类都直接或间接继承自它。因此了解并掌握`Object`类的方法对于深入理解Java编程至关重要。 1. **toString() 方法**...
java核心类库（一） 常用类
weixin_43835305的博客
08-24 770
常用类的介绍和使用，包括Object类，包装类，数学类等
多态的使用场合
weixin_43835305的博客
08-25 642
java 多态的一些使用场合
模块四解题思路
weixin_43835305的博客
09-13 574
第一阶段模块四作业解题思路
阶段二模块三解题思路
weixin_43835305的博客
09-28 563
阶段二模块三java-web作业
java核心类库（七） IO流--文件的读写
weixin_43835305的博客
09-04 517
java中文件的读写操作可用类
Mysql数据库（三） MySQL多表&外键&数据库设计
weixin_43835305的博客
09-24 475
mysql基础，多表操作，外键约束，数据库设计
Mysql数据库（一） 数据库基础及sql语句
weixin_43835305的博客
09-24 437
mysql数据库基础，安装卸载及基础sql语句
前端基础（五） Vue框架
weixin_43835305的博客
09-26 430
前端Vue框架基础知识
XML文档
weixin_43835305的博客
09-26 369
XML文档基础知识
Java常用类库详解与核心类介绍
3. `java.lang.*` 包含了Java语言的核心类，如`String`、`Object`、`System`等。`String`类用于表示不可变字符串，`Object`是所有类的基类，而`System`类提供了系统级的函数，如获取当前时间、输出流等。 4. `java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值