Java常用类与基础API--String的实例化与连接操作

news2024/11/15 16:51:12

文章目录

  • 一、String实例化的两种方式
    • （1）两种方式
    • （2）举例
      • 1、案例1
      • 2、案例2
    • （3）内存分配
    • （4）面试题
      • 1、题1
      • 2、题2
  • 二、String的连接操作+
    • （1）案例
      • 1、案例剖析
      • 2、intern方法
    • （2）总结
  • 三、练习
    • （1）练习类型1：拼接
      • 1、题1
      • 2、题2
    • （2）练习类型2：new
      • 1、说明
      • 2、练习
    • （3）练习类型3：intern()
      • 1、说明
      • 2、题1
      • 3、题2
      • 4、题3
      • 5、题4

一、String实例化的两种方式

（1）两种方式

🔥两种方式

第1种方式（字面量的方式）：String s1 = "hello";

第2种方式（String作为类）：String s2 = new String("hello");

（2）举例

1、案例1

🌱代码

@Test
public void test1() {
    String s1 = "hello";
    String s2 = "hello";

    String s3 = new String("hello");
    String s4 = new String("hello");

    System.out.println(s1 == s2); //true
    System.out.println(s1 == s3); //false
    System.out.println(s1 == s4); //false
    System.out.println(s3 == s4); //false
}

🍺输出

image.png

false表示两个地址值不一样。

2、案例2

🌱代码

@Test
public void test1() {
    String s1 = "hello";
    String s2 = "hello";

    String s3 = new String("hello");
    String s4 = new String("hello");

    System.out.println(s1.equals(s2));  //true
    System.out.println(s2.equals(s3));  //true
}

🍺输出

image.png

equals比较的是内容，所以都是true。

（3）内存分配

🎲内存是如何分配的呢？

①String s="hello"; ：在字符串常量池中有一个hello，将地址给了s。

字符串有一个属性叫value，value里面存储核心数据hello，hello是一个数组，所以value这里是一个引用。

②String s=new String("hello"); 在内存中是如何分配空间的？在内存中创建了几个对象？

🚗内存图

String s=new String("hello");

在内存空间中创建了两个对象。

一个是在堆空间里面new的对象；一个是在常量池里面的String类型的hello，这个hello也有一个地址值。（因为字符串比较特别，在new的同时还要往字符串常量池里面放一个字面量）

image.png

两个对象如下：
image.png

这两个对象里面value的属性都指向同一个char型的数组，所以它们里面保留的地址（0X5566）是一样的，但外面来看它们的地址是不一样的（0X3344和0X1122）。

比如：

image.png

s1与s3的地址值就不一样，但是它们value属性的地址一致。

之前说过String内部声明的属性：

  • jdk8中：private final char value[]; //存储字符串数据的容器
    • final : 指明此value数组一旦初始化，其地址就不可变。
  • jdk9开始：为了节省内存空间，做了优化private final byte[] value; //存储字符串数据的容器。

可以看到，声明value的时候，前面加了一个private，也就是value不对外暴露。

所以，我们可以不用过多关注s1与s3它们内部的value指向的地址一致，只需要关注外面的地址不一致就好。

（4）面试题

1、题1

🌋String s2 = new String("hello");在内存中创建了几个对象？

两个！

一个是堆空间中new的对象。另一个是在字符串常量池中生成的字面量。

☕注意

有的小伙伴会有这个疑问，执行第一句代码的时候，已经在字符串常量池中造了一个了。

那么在执行第二句的时候就造一个堆空间里面的不就行了。

image.png

其实一般在问的时候，不考虑在字符串常量池中已经有的情况了。

直接问的时候，就说创建了两个对象即可。

2、题2

🌋下面代码输出结果是？

🌱代码

public class StringDemo1 {
    @Test
    public void test2(){
        Person p1=new Person();
        Person p2=new Person();
        p1.name="Tom";
        p2.name="Tom";

        p1.name="Jerry";
        System.out.println(p2.name);	//Tom

    }
}

class Person{
    String name;
}

🍺输出

image.png

☕分析

若是按照以往的思路，我们会觉得p1与p2的name是各自一份，下面修改了p1的name，不会影响p2的name，所以打印输出p2的name还是Tom。

现在来看的话，p1与p2在内存中指向的是同一个位置。

<1> 对于p1：

Person p1=new Person();

p1.name="Tom";

首先在堆里面new了一个Person，属性是name。然后用的是“字面量”的方式给它做的赋值，在字符串常量池里面有一个字符串Tom（数组中存放），它的地址赋值给了value（String的一个属性），然后String的地址（比如0x1122）赋值给了name。

最后Person的地址（比如0x3344）给了p1。

如下：

image.png

<2> 对于p2：

Person p2=new Person();

p2.name="Tom";

同样的，在堆空间中新创建了一个对象，也会有一个地址值（比如0x5566），将它赋给了p2。

堆空间的对象有一个属性name，指向字符串常量池中的String（也是0x1122），value指向Tom。

image.png

可与看到，p1与p2它们在内存中使用了同一个Tom。

以前我们画的是简略图：

image.png

<3> 接下来，用p1调用name，并将它改为Jerry。

p1.name="Jerry";

此时详细的过程应该是：字符串常量池里面有一个“Jerry”，它的地址给了String的value，整一个新的地址。

然后p1的name指向的String的地址变成了0x7788。

如下：

image.png

<4> 现在用p2调用name，还是"Tom"，不受影响。

System.out.println(p2.name);

这样设计的目的是为了节省内存空间。

当不同的属性（比如p1.name和p2.name）值是相同（比如"Tom"）的时候，就让他们在字符串常量池里面共用同一个。

🎲为什么String要有不可变性？

我们看到的像是各自持有一份，但实际上用的是同一个。

假设现在有1000个用的都是Tom，是同一个Tom，若是其中一个想要改，不能在原有的地方改（要不然其他的都要一起变），要改的话自己新造一个，其他的不改就还用之前的那个。

这就极大节省了内存空间。

对于我们平常使用者来说，感受不到底层它们使用的是同一份。

只知道它们都有一个一样的值，其中一个修改不会影响其他的改变。

共用一个节省了空间，在这个基础之上，谁想要改谁就自己重新造一个，不影响现有的对象使用当前的结果。

二、String的连接操作+

（1）案例

1、案例剖析

🌱代码

//测试String的连接符：+
@Test
public void test3(){
    String s1="hello";
    String s2="world";

    String s3="helloworld";
    String s4="hello"+"world";
    String s5=s1+"world";
    String s6="hello"+s2;
    String s7=s1+s2;

    System.out.println(s3==s4); //true
    System.out.println(s3==s5); //false
    System.out.println(s3==s6); //false
    System.out.println(s3==s7); //false

    System.out.println(s4==s5); //false
    System.out.println(s4==s6); //false
    System.out.println(s4==s7); //false

    System.out.println(s5==s6); //false
    System.out.println(s5==s7); //false

    System.out.println(s6==s7);	//false
}

🍺输出

image.png

🍰分析

false表示两者的地址是不一样的。

看一下反编译文件：

image.png

s3与s4已经写成一样的了。

在字节码文件当中，它就已经做了合并了。看到的是两个不同的字面量，其实编译之后就是一个拼接起来的。

所以s3==s4输出的是true。

"hello"和"world"相当于是两个常量，常量做拼接（“hello”+“world”）和直接写这个常量（“helloworld”）没有区别。

`

s5、s6、s7中都有变量参与，变量参与的话该如何实现呢？

之前其实已经说过了，如下：

image.png

s2+="world"就相当于s2=s2+"world"。

像String s5=s1+"world"这种结构，其实是底层给new了一个对象。

看一下下面的解释（字节码文件）：

image.png

总之，就是调用了StringBuilder的toString，看一下：

public String toString(){
    //Create a copy,don't share the array
    return new String(value,0,count);
}

可以看到，这里面返回的是一个new了之后的对象。

所以，这里其实是新new的对象：（通过查看字节码文件发现，调用了StringBuilder的toString()方法–>new String()）

String s5=s1+"world";	//新new的对象
String s6="hello"+s2;	//新new的对象
String s7=s1+s2;	//新new的对象

因此，s5、s6、s7都是新new的对象，它们之间作比较，肯定都是不一样的。

s3是常量池里面的，跟堆空间里面new的对象显然也不是一致的，所以结果是false。

2、intern方法

🗳️补充

intern()：调用这个方法后会得到一个新的字符串，返回的是字符串常量池中字面量的地址。

//测试String的连接符：+
@Test
public void test3(){
    String s1="hello";
    String s2="world";

    String s3="helloworld";
    String s4="hello"+"world";
    String s5=s1+"world";   //通过查看字节码文件发现，调用了StringBuilder的toString()方法-->new String()

    //...
    String s8=s5.intern();	//intern:返回的是字符串常量池中字面量的地址
    System.out.println(s3==s8);	//true
}

输出结果：

image.png

intern返回的是字符串常量池中字面量的地址，此时字符串常量池中已经有"helloworld"了，所以就将已有的地址返回给了s8。

因此，s3、s4、s8的地址是一样的。

看一下内存图：

image.png

（2）总结

【String的连接操作:+】

①情况1

常量 + 常量：结果仍然存储在字符串常量池中，返回此字面量的地址。

注：此时的常量可能是字面量，也可能是final修饰的常量。

比如：

🌱代码

String s1="hello";  //字面量，存储在常量池中
String s2="world";  //字面量

String s3="helloworld"; //字面量
String s4="hello"+"world";  //常量+常量，结果还在字符串常量池中

System.out.println(s3==s4); //true

再比如final修饰的常量：

🌱代码

public void test4(){
    final String s1="hello";  //字面量，存储在常量池中
    String s2="world";  //字面量

    String s3="helloworld"; //字面量
    String s4="hello"+"world";  //常量+常量，结果还在字符串常量池中
    String s5=s1+"world";   //通过查看字节码文件发现，调用了StringBuilder的toString()方法-->new String()
    String s6="hello"+s2;
    String s7=s1+s2;

    System.out.println(s3==s5); //true
    System.out.println(s3==s6); //false
}

在s1前面加了一个final，就让它变成了常量。

此时s5就跟s4类似了。

🍺输出

image.png

这种考的场景比较少。

②情况2

常量 + 变量 或 变量 + 变量 ：都会通过new的方式创建一个新的字符串，返回堆空间中此字符串对象的地址。

🌱代码

String s1="hello";  //字面量，存储在常量池中
String s2="world";  //字面量

String s5=s1+"world";   //通过查看字节码文件发现，调用了StringBuilder的toString()方法-->new String()
String s6="hello"+s2;

System.out.println(s5==s6); //false

③情况3

调用字符串的intern()：返回的是字符串常量池中字面量的地址。

🌱代码

String s1="hello";
String s3="helloworld"; //字面量
String s5=s1+"world";

String s8=s5.intern();  //intern():返回的是字符串常量池中字面量的地址

System.out.println(s3==s5); //false
System.out.println(s3==s8); //true

如果字符串常量池当中字面量不存在，就会新创建一个然后返回。

如果存在，就会返回已有的。（字符串常量池中不允许存放两个相同的字符串常量）

④(了解)情况4

concat(xxx)：不管是常量调用此方法，还是变量调用，同样不管参数是常量还是变量，总之，调用完concat()方法都返回一个新new的对象。

🌱代码

@Test
public void test5(){
    String s1="hello";
    String s2="world";

    String s3=s1.concat(s2);  //s1连接s2
    String s4="hello".concat("world");    //常量连接常量
    String s5=s1.concat("world");
    String s6="hello".concat(s2);

    System.out.println(s3==s4);
    System.out.println(s3==s5);
    System.out.println(s3==s6);
    System.out.println(s4==s5);
    System.out.println(s4==s6);
    System.out.println(s5==s6);

}

🍺输出

image.png

三、练习

（1）练习类型1：拼接

1、题1

🌱代码

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2);	//true
// 内存中只有一个"hello"对象被创建，同时被s1和s2共享。

🍺输出

image.png

🍰分析

对应内存结构为：（以下内存结构以JDK6为例绘制）：

image.png

进一步：
image.png

2、题2

🌱代码

@Test
public void test6(){
    Person p1 = new Person();
    p1.name = "Tom";

    Person p2 = new Person();
    p2.name = "Tom";

    System.out.println(p1.name.equals( p2.name)); //true
    System.out.println(p1.name == p2.name); //true
    System.out.println(p1.name == "Tom"); //true
}

🍰分析

在这里插入图片描述

🍺输出

image.png

（2）练习类型2：new

1、说明

String str1 = “abc”; 与 String str2 = new String(“abc”);的区别？

image.png

str2 首先指向堆中的一个字符串对象，然后堆中字符串的value数组指向常量池中常量对象的value数组。

  • 字符串常量存储在字符串常量池，目的是共享。
  • 字符串非常量对象存储在堆中。

2、练习

🌱代码

@Test
public void test7(){
    String s1 = "javaEE";
    String s2 = "javaEE";
    String s3 = new String("javaEE");
    String s4 = new String("javaEE");

    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3);//false
    System.out.println(s1 == s4);//false
    System.out.println(s3 == s4);//false
}

🍰分析

image.png

🍺输出

image.png

🎲问：String str2 = new String("hello"); 在内存中创建了几个对象？

两个。

（3）练习类型3：intern()

1、说明

①

String s1 = "a";

说明：在字符串常量池中创建了一个字面量为"a"的字符串。

②

s1 = s1 + "b";

说明：实际上原来的“a”字符串对象已经丢弃了，现在在堆空间中产生了一个字符串s1+“b”（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。

③

String s2 = "ab";

说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。

④

String s3 = "a" + "b";

说明：s3指向字符串常量池中已经创建的"ab"的字符串。

⑤

String s4 = s1.intern();

说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。

2、题1

🌱代码

@Test
public void test8(){
    String s1 = "hello";
    String s2 = "world";
    String s3 = "hello" + "world";
    String s4 = s1 + "world";
    String s5 = s1 + s2;
    String s6 = (s1 + s2).intern();

    System.out.println(s3 == s4);   //false
    System.out.println(s3 == s5);   //false
    System.out.println(s4 == s5);   //false
    System.out.println(s3 == s6);   //true
}

🍺输出

image.png

结论：
（1）常量+常量：结果是常量池。且常量池中不会存在相同内容的常量。
（2）常量与变量 或 变量与变量：结果在堆中
（3）拼接后调用intern方法：返回值在常量池中

3、题2

🌱代码

@Test
public void test01(){
	String s1 = "hello";
	String s2 = "world";
	String s3 = "helloworld";
		
	String s4 = s1 + "world";//s4字符串内容也helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中
	String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是变量，变量 + 变量的结果在堆中
	String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
		
	System.out.println(s3 == s4);//false
	System.out.println(s3 == s5);//false
	System.out.println(s3 == s6);//true
}

@Test
public void test02(){
	final String s1 = "hello";
	final String s2 = "world";
	String s3 = "helloworld";
	
	String s4 = s1 + "world";//s4字符串内容也helloworld，s1是常量，"world"常量，常量+常量结果在常量池中
	String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是常量，常量+ 常量 结果在常量池中
	String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
		
	System.out.println(s3 == s4);//true
	System.out.println(s3 == s5);//true
	System.out.println(s3 == s6);//true
}

@Test
public void test01(){
	String s1 = "hello";
	String s2 = "world";
	String s3 = "helloworld";
		
	String s4 = (s1 + "world").intern();//把拼接的结果放到常量池中
	String s5 = (s1 + s2).intern();
		
	System.out.println(s3 == s4);//true
	System.out.println(s3 == s5);//true
}

4、题3

🌱代码

public class TestString {
	public static void main(String[] args) {
		String str = "hello";
		String str2 = "world";
		String str3 ="helloworld";
		
		String str4 = "hello".concat("world");
		String str5 = "hello"+"world";
		
		System.out.println(str3 == str4);//false
		System.out.println(str3 == str5);//true
	}
}

concat方法拼接，哪怕是两个常量对象拼接，结果也是在堆。

5、题4

🌱代码

public class StringTest {

    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + " and ");//
        System.out.println(ex.ch);
    }
}

🍺输出

image.png

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1444302.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

小程序-云开发 获取用户的openid等信息

小程序-云开发 获取用户的openid等信息

说明介绍&#xff1a; 小程序云开发功能来获取用户的openid。 一般在我们需要用到用户登录的时候&#xff0c;通常是需要获取微信小程序的openid的&#xff0c;由于微信的限制&#xff0c;一般我们只能通过后台去调微信的接口&#xff0c;来授权获取&#xff0c;增加了后端开发…
阅读更多...
从零开始学howtoheap：fastbins的double-free攻击实操3

从零开始学howtoheap：fastbins的double-free攻击实操3

how2heap是由shellphish团队制作的堆利用教程&#xff0c;介绍了多种堆利用技术&#xff0c;后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境&#xff1a;优化pwn虚拟机配置支持libc等指令-CSDN博客 1.fastbins的double-free攻击 这个程序展示了怎样利…
阅读更多...
人工智能|推荐系统——基于tensorflow的个性化电影推荐系统实战(有前端)

人工智能|推荐系统——基于tensorflow的个性化电影推荐系统实战(有前端)

代码下载&#xff1a; 基于tensorflow的个性化电影推荐系统实战(有前端).zip资源-CSDN文库 项目简介&#xff1a; dl_re_web : Web 项目的文件夹re_sys&#xff1a; Web app model&#xff1a;百度云下载之后&#xff0c;把model放到该文件夹下recommend&#xff1a; 网络模型相…
阅读更多...
appears to be hung in Auto SQL Tuning task

appears to be hung in Auto SQL Tuning task

appears to be hung in Auto SQL Tuning task Oracle 自动定时优化任务执行失败分析 错误现象&#xff1a; Sat Feb 10 03:10:57 2024 Process 0x0x00007FFB81BE44A8 appears to be hung in Auto SQL Tuning task Current time 1707505857, process death time 1707505803 …
阅读更多...
【Linux】make和Makefile

【Linux】make和Makefile

目录 make和Makefile make和Makefile 我们使用vim编辑器的时候&#xff0c;在一个文件里写完代码要进行编译&#xff0c;要自己输入编译的指令。有没有一种可以进行自动化编译的方法——makefile文件&#xff0c;它可以指定具体的编译操作&#xff0c;写好makefile文件&#x…
阅读更多...
读千脑智能笔记10_人类智能存在的风险

读千脑智能笔记10_人类智能存在的风险

1. 人类智能存在的风险 1.1. “末日时钟” 1.1.1. 核战争引发的大火列为地球毁灭的主要原因 1.1.2. 气候变化列为人类自我毁灭的第二大潜在原因 1.2. 除非我们刻意加入自私的驱动力、动机或情感&#xff0c;否则智能机器并不会威胁到人类的生存 1.2.1. 人类在不远的将来会…
阅读更多...
c语言游戏实战（7）：扫雷

c语言游戏实战（7）：扫雷

前言&#xff1a; 扫雷是一款经典的单人益智游戏&#xff0c;它的目标是在一个方格矩阵中找出所有的地雷&#xff0c;而不触碰到任何一颗地雷。在计算机编程领域&#xff0c;扫雷也是一个非常受欢迎的项目&#xff0c;因为它涉及到许多重要的编程概念&#xff0c;如数组、循环…
阅读更多...
MongoDB存储引擎发展及WiredTiger深入解析（二）

MongoDB存储引擎发展及WiredTiger深入解析（二）

在现代的数据管理领域中&#xff0c;MongoDB作为一个高性能、开源的NoSQL数据库系统&#xff0c;已经在全球范围内被广泛应用。而MongoDB背后的存储引擎&#xff0c;作为其数据管理的核心组件&#xff0c;也经历了不断的发展和优化。本文将对MongoDB的存储引擎发展进行简要回顾…
阅读更多...
数据结构——6.2 图的存储与基本操作

数据结构——6.2 图的存储与基本操作

6.2 图的存储与基本操作 概念 图的存储 邻接矩阵存有向图和无向图 根据邻接矩阵求度&#xff1a; 无向图&#xff1a;第i个结点的度 第i行 (或第列) 的非零元素个数 有向图&#xff1a; 第i个结点的出度 第i行的非零元素个数 第i个结点的入度 第i列的非零元素个数 第i个结…
阅读更多...
数据库恢复

数据库恢复

文章目录 前言一、事务1.概念2.定义语句3.ACID特性 二、数据库恢复的必要性1.为什么要进行数据库恢复2.数据库恢复机制的作用 三、数据恢复使用的技术1.数据转储2.登记日志文件 四 、不同故障的数据恢复策略1.事务内部的故障2.系统故障3.介质故障 五、具有检查点的恢复技术1.检…
阅读更多...
【机器学习笔记】基于实例的学习

【机器学习笔记】基于实例的学习

基于实例的学习 文章目录 基于实例的学习1 基本概念与最近邻方法2 K-近邻&#xff08;KNN&#xff09;3 距离加权 KNN4 基于实例/记忆的学习器5 局部加权回归5 多种回归方式对比6 懒惰学习与贪婪学习 ​ 动机&#xff1a;人们通过 记忆和行动来推理学习。 1 基本概念与最近邻方…
阅读更多...
Cubase学习：音频转midi

Cubase学习：音频转midi

大家好！我是诗书画唱！今天要分享的小技巧就是Cubase中的音频转midi的功能！希望对你有所帮助！以后我会在这个账号分享自己知道的很多小技巧！关注我！不迷路！大家也可以关注我后，在我的空间搜索关键词，找到各种对应的教程进行学习，非常的方便！而且自己的教程会尽可能纠…
阅读更多...
数据结构~~树（2024/2/8）

数据结构~~树（2024/2/8）

目录 树 1、定义&#xff1a; 2、树的基本术语&#xff1a; 3、树的表示 树 1、定义&#xff1a; 树是一种非线性的数据结构&#xff0c;它是由n&#xff08;n>0&#xff09;个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树&…
阅读更多...
《动手学深度学习(PyTorch版)》笔记8.4

《动手学深度学习(PyTorch版)》笔记8.4

注&#xff1a;书中对代码的讲解并不详细&#xff0c;本文对很多细节做了详细注释。另外&#xff0c;书上的源代码是在Jupyter Notebook上运行的&#xff0c;较为分散&#xff0c;本文将代码集中起来&#xff0c;并加以完善&#xff0c;全部用vscode在python 3.9.18下测试通过&…
阅读更多...
C++初阶：适合新手的手撕vector（模拟实现vector）

C++初阶：适合新手的手撕vector（模拟实现vector）

上次讲了常用的接口&#xff1a;C初阶&#xff1a;容器&#xff08;Containers&#xff09;vector常用接口详解 今天就来进行模拟实现啦 文章目录 1.基本结构与文件规划2.空参构造函数&#xff08;constructor)4.基本函数&#xff08;size(),capacity(),resize(),reserve())4.增…
阅读更多...
Android---Jetpack Compose学习002

Android---Jetpack Compose学习002

Compose 布局。Compose 布局的目标&#xff1a;1&#xff09;实现高性能&#xff1b;2&#xff09;让开发者能够轻松编写自定义布局&#xff1b;3&#xff09;在 Compose 中&#xff0c;通过避免多次测量布局子级可实现高性能。如果需要进行多次测量&#xff0c;Compose 具有一…
阅读更多...
【MySQL】数据库的基础——数据库的介绍、MySQL的介绍和架构、SQL分类、MySQL的基本使用、MySQL的存储引擎

【MySQL】数据库的基础——数据库的介绍、MySQL的介绍和架构、SQL分类、MySQL的基本使用、MySQL的存储引擎

文章目录 MySQL1. 数据库的介绍1.2 主流数据库 2. MySQL的介绍2.1 MySQL架构2.2 SQL分类2.3 MySQL的基本使用2.4 MySQL存储引擎 MySQL 1. 数据库的介绍 数据库&#xff08;Database&#xff0c;简称DB&#xff09;是按照数据结构来组织、存储和管理数据的仓库。它是长期存储在计…
阅读更多...
安装了多个Java版本如何指定特定版本

安装了多个Java版本如何指定特定版本

Java版本问题的实战场景 机器安装了一个JDK 8的安装版本&#xff0c;默认的安装路径是 C:\Program Files\Java&#xff0c;JDK的安装版本同时安装了JDK 和JRE, 安装的路径分别是&#xff1a; JDK 路径&#xff1a; C:\Program Files\Java\jdk1.8.0_361JRE 路径&#xff1a; C…
阅读更多...
Java图形化界面编程——菜单组件 笔记

Java图形化界面编程——菜单组件 笔记

2.7 菜单组件 ​ 前面讲解了如果构建GUI界面&#xff0c;其实就是把一些GUI的组件&#xff0c;按照一定的布局放入到容器中展示就可以了。在实际开发中&#xff0c;除了主界面&#xff0c;还有一类比较重要的内容就是菜单相关组件&#xff0c;可以通过菜单相关组件很方便的使用…
阅读更多...
在 Windows上恢复删除照片的 4 种有效方法

在 Windows上恢复删除照片的 4 种有效方法

您是否曾在 Windows 7/8/10/11 中不小心删除过照片&#xff1f;如何轻松快速地恢复已删除的照片&#xff1f;在这里这篇文章列出了几种在Windows 11/10/8/7中恢复已删除照片的可行方法&#xff0c;而MiniTool数据恢复软件 是丢失照片恢复的最佳选择。 意外删除的照片 根据一项…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023