【C++】---STL之vector详解

news2024/9/25 1:15:05

【C++】---STL之vector详解

  • 一、vector的介绍：
  • 二、vector的成员函数：
    • 1、vector类的构造函数
    • 2、vector的元素访问符
    • 3、vector的迭代器
    • 4、vector的模版
    • 5、vector的拷贝构造
    • 6、vector的容量
      • （1）vector的增容机制
      • （2）reserve()和resize()
      • （3）size()
      • （4）empty()
    • 7、vector的尾插和尾删
    • 8、vector在任意位置插入与删除
      • （1）插入（insert）
      • （2）删除
    • 9、find()
    • 10、swap()
  • 三、迭代器失效
    • （1）什么是迭代器失效？
    • （2）为什么会出现：迭代器失效问题？
    • （3）如何解决迭代器失效？！
    • （4）迭代器失效的样例

在这里插入图片描述

一、vector的介绍：

二、vector的成员函数：

vector定义：表示可以动态改变大小的数组序列容器！（ vector实际上就是一个顺序表）

vector的特点：

（1）vector像数组一样拥有连续的储存空间来储存元素，因此可以通过下标访问来访问储存的元素。

然而还有一点，它不像数组，那就是它可以动态改变其自身的大小，而数组是静态的，它改变其自身大

小是容器对容量自动处理的。

（2）vector的空间比实际上所需要储存的空间更大一点， vector的尾插尾删的效率更高一点，而在其

他位置的插入删除效率相对较低一点，因为每次的插入删除都会挪动后面的数据。

1、vector类的构造函数

1、参考文档：
在这里插入图片描述
2、
（1）

//构造空的vector
explicit vector(const allocator_type& alloc = allocator_type());

//构造一个vector,有n个元素，每个元素值为val
explicit vector(size_type n, const value_type& val = value_type(),
    const allocator_type& alloc = allocator_type());

//构造一个vector,值为InputIterator的first到last之间的元素
template <class InputIterator>
vector(InputIterator first, InputIterator last,
    const allocator_type& alloc = allocator_type());

//使用x拷贝构造一个vector
vector(const vector& x);

（2）
vector容器的定义元素、构造函数、拷贝构造函数、尾插：

vector<int> v;// 构造一个空的vector容器

	vector<int> v1(3, 5);// 构造一个元素个数为3，每个元素的初始化为5的容器
	vector<int> v2(v1.begin(),v1.end());// 构造一个从v1.begin()到v1.end()的v2容器
	vector<int> v3(v1);// 拷贝构造


	v.push_back(1);// 对v1空容器进行尾插。
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

2、vector的元素访问符

#include<iostream>
#include<vector>

using namespace std;


int main()
{

	
	vector<int> v;// 构造一个空的vector容器

	vector<int> v1(3, 5);// 构造一个元素个数为3，每个元素的初始化为5的容器
	vector<int> v2(v1.begin(),v1.end());// 构造一个从v1.begin()到v1.end()的v2容器
	vector<int> v3(v1);// 拷贝构造


	v.push_back(1);// 对v1空容器进行尾插。
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

	// 1、通过访问符[ ]来访问vector容器中的元素：
	for (size_t i = 0; i <v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

在这里插入图片描述

3、vector的迭代器

1、迭代器是各种容器，无论是连续还是不连续的空间的容器，通用的遍历容器的方式。

（1）可读可写的迭代器：

int main()
{


	vector<int> v;// 构造一个空的vector容器

	vector<int> v1(3, 5);// 构造一个元素个数为3，每个元素的初始化为5的容器
	vector<int> v2(v1.begin(), v1.end());// 构造一个从v1.begin()到v1.end()的v2容器
	vector<int> v3(v1);// 拷贝构造


	v.push_back(1);// 对v1空容器进行尾插。
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

	// 2、迭代器遍历vector
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;


	return 0;
}

在这里插入图片描述
（2）只读的迭代器：
在这里插入图片描述
库里面存在：const迭代器，直接用

	// 2、迭代器遍历vector
	vector<int>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

（3）反向迭代器：
在这里插入图片描述

可读可写：

	// 2、反向迭代器遍历vector
	vector<int>::reverse_iterator it = v.rbegin();
	while (it != v.rend())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

在这里插入图片描述

（4）反向迭代器：只读：


	// 2、反向迭代器遍历vector
	vector<int>::const_reverse_iterator it = v.rbegin();
	while (it != v.rend())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

4、vector的模版

template<class T>
void PrintVector(const vector<T>& v)
{
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}
int main()
{
	// 1、定义一个v1的顺序表，里面的数据都是int类型
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	// 调用打印函数：printvector
	PrintVector(v1);

	// 2、定义一个v2的顺序表，里面的数据都是char类型,并且把s1里面的字符串内容,初始化时赋给v2
	string s1 = "hello world";

	vector<char> v2(s1.begin(),s1.end());
	// 调用打印函数：printvector
	PrintVector(v2);

	// 3、定义一个v3的顺序表，里面的数据都是double类型
	vector<double> v3;

	v3.push_back(1.1);
	v3.push_back(2.2);
	v3.push_back(3.3);
	v3.push_back(4.4);
	v3.push_back(5.5);
	// 调用打印函数：printvector
	PrintVector(v3);

	return 0;
}

在这里插入图片描述

5、vector的拷贝构造

1、拷贝构造：
在这里插入图片描述
2、样例展示：

	string s2("hello vector");
	vector<string> v4;
	v4.push_back(string(s2));
	PrintVector(v4);

	// 此时v4的内容就是：hello vector
	// 拷贝构造：
	vector<string> v5(v4);// 把v4拷贝构造给v5
	PrintVector(v5);

在这里插入图片描述

6、vector的容量

（1）vector的增容机制

在VS下执行这段代码：

void test_vector3()
{
    size_t sz;
    std::vector<int> foo;
    sz = foo.capacity();
  
    std::cout << "making foo grow:\n";
 
    for (int i = 0; i < 100; i++)
    {
        foo.push_back(i);
        if (sz != foo.capacity())
        {
            sz = foo.capacity();
            std::cout << "capacity changed:" << sz << endl;
        }
    }
}

发现增容的过程是大概按照1.5倍增容的：
在这里插入图片描述
同样的代码在linux下运行，发现是2倍增容的！

（2）reserve()和resize()

1、reserve（）：

void reserve (size_type n);//开辟n个元素空间
void resize (size_type n, value_type val = value_type());
//开辟n个元素空间，并将每个元素默认初始化为val

如果加上reserve()，那么会提前知道要开多少空间，就提前开好了，避免后面再开空间

void test_vector3()
{
    size_t sz;
    std::vector<int> foo;
    sz = foo.capacity();
    foo.reserve(100);
  
    std::cout << "making foo grow:\n";
 
    for (int i = 0; i < 100; i++)
    {
        foo.push_back(i);
        if (sz != foo.capacity())
        {
            sz = foo.capacity();
            std::cout << "capacity changed:" << sz << endl;
        }
    }
}

2、resize（）：
在这里插入图片描述
（1）样例演示：

vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);


	PrintVector(v1);// resize()前：

	v1.resize(3);// 将v1顺序表的元素个数缩小为3个
	PrintVector(v1);// resize()后：

	v1.resize(10,0);// 将v1顺序表的元素个数扩大为10个，并且其余多出来的元素初始化为0。
	PrintVector(v1);// resize()后：

在这里插入图片描述

（3）size()

1、计算顺序表中的·元素个数：

	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);

	cout << v1.size() << endl;

在这里插入图片描述

（4）empty()

1、判断顺序表是否为空：

	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);

	cout << v1.empty() << endl;

	vector<int> v2;
	cout << v2.empty() << endl;

在这里插入图片描述

7、vector的尾插和尾删

	vector<int> v1;
	v1.push_back(1);//尾插
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);

	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.pop_back();
	v1.pop_back();//尾删2次
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

在这里插入图片描述

8、vector在任意位置插入与删除

（1）插入（insert）

1、函数的用法理解：

在这里插入图片描述

    vector<double> v5;
    //插入4个float元素
    v5.push_back(1.1);
    v5.push_back(2.2);
    v5.push_back(3.3);
    v5.push_back(4.4);
    v5.push_back(5.5);
    
    v5.insert(v5.end(), 6.6);//在v5末尾插入6.6
    PrintVector(v5);
    
    v5.insert(v5.begin(), 2,0);//在v5开头插入2个0
    PrintVector(v5);
 
    vector<double> v6;
    v6.push_back(7.7);
    v6.push_back(8.8);
 
    v5.insert(v5.begin(), v6.begin(),v6.end());//在v5开头插入v6
    PrintVector(v5);

（2）删除

1、erase的使用：
在这里插入图片描述
2、特别要注意：erase可能会导致迭代器失效！！！

iterator erase (iterator position);//删除某一位置元素
iterator erase (iterator first, iterator last);//删除迭代器first和last之间的元素

    v5.erase(v5.begin());//删除v5开头元素
    PrintVector(v5);
 
    v5.erase(v5.begin(), v5.begin()+2);//从v5开头删除2个元素
    PrintVector(v5);

9、find()

1、在迭代器区间内查找元素，find函数实现在algorithm中，可以给所有容器使用，因此要使用find函数，就要include

template <class InputIterator, class T>
   InputIterator find (InputIterator first, InputIterator last, const T& val);//在InputIterator迭代器first和last区间内查找val元素的位置

注意：迭代器区间是左闭右开，因此能取到第一个位置，但取不到最后一个位置

    vector<double>::iterator pos = find(v5.begin(), v5.begin() + 3, 1.1);//在第一个元素和第四个元素（左闭右开，不包含第四个元素）之间查找值为1.1的元素位置
    v5.erase(pos);//删除1.1位置的元素，即删除1.1
 
     PrintVector(v5);

10、swap()

1、样例展示：

vector<int> v1;
	v1.push_back(1);//尾插
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);

	vector<int> v2;
	v2.push_back(3);
	v2.push_back(3);
	v2.push_back(3);
	v2.push_back(3);
	v2.push_back(3);

	v1.swap(v2);

	cout << "v1:";
	for (auto e : v1)
	{
		
		cout << e << " ";
	}
	cout << endl;

	cout << "v2:";
	for (auto e : v2)
	{
		
		cout << e << " ";
	}
	cout << endl;

在这里插入图片描述

三、迭代器失效

（1）什么是迭代器失效？

1、首先明白什么是迭代器？

1.迭代器的主要作用：就是让算法能够不用关心底层的数据结构，它的底层实际上就是一个指针或者是对指针进行了封装

什么是迭代器失效？迭代器变成了“野指针”！

（2）为什么会出现：迭代器失效问题？

2、为什么会存在迭代器失效？

（1）迭代器失效的原因：是因为迭代器指针所指向的空间被销毁了，而使用一块已经被释放的空间。造成的后果就是程序崩溃。

（2）注意：会引起其底层空间操改变的操作都有可能使迭代器失效，比如resize reserve Insert erase push_back等等。

（3）如何解决迭代器失效？！

如何解决迭代器失效？！
在使用前，对迭代器进行重新赋值即可。

1、样例展示：

#include <iostream>
using namespace std;
#include <vector>
 
int main()
{
 	vector<int> v{ 1, 2, 3, 4 };
 	auto it = v.begin();
 	while (it != v.end())
 	{
 		if (*it % 2 == 0)
 		v.erase(it);
 
 		++it;//  It是一个迭代器，对一块已经释放了空间的迭代器指针进行操作必然会引起程序崩溃。要想程序不崩溃，必须要对迭代器进行重新赋值！
 	}
 
 	return 0;
}
 



int main()
{
	 vector<int> v{ 1, 2, 3, 4 };
	 auto it = v.begin();
 	while (it != v.end())
 	{
		if (*it % 2 == 0)
 			it = v.erase(it);// 在迭代器失效前，对迭代器进行重新赋值，即可保证迭代器不会失效。程序不会崩溃。
 		else
 			++it;
 }
 
 return 0;
}

要特别注意，所有容器如果对它底层的空间数据进行改变的话，就有可能引起迭代器失效，常见的有insert和erase。

（4）迭代器失效的样例

1、

#include <iostream>
using namespace std;
#include <vector>
 
int main()
{
 vector<int> v{1,2,3,4,5,6};
 
 auto it = v.begin();
 
 // 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
 // v.resize(100, 8);
 
 // reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
 // v.reserve(100);
 
 // 插入元素期间，可能会引起扩容，而导致原空间被释放
 // v.insert(v.begin(), 0);
 // v.push_back(8);
 
 // 给vector重新赋值，可能会引起底层容量改变
 v.assign(100, 8);
 
 /*
 出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
 解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
 */
 while(it != v.end())
 {
 cout<< *it << " " ;
 ++it;
 }
 cout<<endl;
 return 0;
}

2、

#include <iostream>
using namespace std;
#include <vector>
 
int main()
{
 int a[] = { 1, 2, 3, 4 };
 vector<int> v(a, a + sizeof(a) / sizeof(int));
 
 // 使用find查找3所在位置的iterator
 vector<int>::iterator pos = find(v.begin(), v.end(), 3);
 
 // 删除pos位置的数据，导致pos迭代器失效。
 v.erase(pos);
 cout << *pos << endl; // 此处会导致非法访问
 return 0;
}

erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代 器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是 没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效 了。

3、

#include <string>
void TestString()

{
 string s("hello");
 auto it = s.begin();
 
 // 放开之后代码会崩溃，因为resize到20会string会进行扩容
 // 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
 // 后序打印时，再访问it指向的空间程序就会崩溃
 //s.resize(20, '!');
 while (it != s.end())
 {
 cout << *it;
 ++it;
 }
 cout << endl;
 
 it = s.begin();
 while (it != s.end())
 {
 it = s.erase(it);
 // 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
 // it位置的迭代器就失效了
 // s.erase(it); 
 ++it;
 }

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！
在这里插入图片描述

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

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

相关文章

机器人实验室CNRS-AIST JRL, IRL介绍

机器人实验室CNRS-AIST JRL, IRL介绍

一、背景 作为搞机器人方向的学生&#xff0c;必须时常关注国际上顶尖实验室的研究成果&#xff0c;以免自己做的方向out&#xff0c;除了大家耳熟能详的Boston Dynamics&#xff0c;还有许多非常厉害的机器人实验室值得我们关注&#xff0c;如日本的CNRS-AIST JRL, IRL实验室…
阅读更多...
GenVideo、SkelFormer、EfficientGS、HOLD、Motion Synthesis、Learn2Talk

GenVideo、SkelFormer、EfficientGS、HOLD、Motion Synthesis、Learn2Talk

本文首发于公众号&#xff1a;机器感知 GenVideo、SkelFormer、EfficientGS、HOLD、Motion Synthesis、Learn2Talk Enabling Stateful Behaviors for Diffusion-based Policy Learning While imitation learning provides a simple and effective framework for policy learni…
阅读更多...
web前端框架设计第五课-计算属性与监听属性

web前端框架设计第五课-计算属性与监听属性

web前端框架设计第五课-计算属性与监听属性 一.预习笔记 1.计算属性 computed split():拆分 reverse():倒序 join():拼接 计算属性与方法&#xff0c;两者效果一致&#xff0c;但是computed 是基于它的依赖缓存&#xff0c;只有相关依赖发生改变时才会重新取值。而使用 met…
阅读更多...
Rumble Club加速器哪个好用 稳定好用的联机加速器推荐

Rumble Club加速器哪个好用 稳定好用的联机加速器推荐

Rumble Club加速器哪个好用 稳定好用的联机加速器推荐 说到Rumble Club这款游戏&#xff0c;各位休闲玩家肯定不陌生&#xff0c;这是一款基于物理定律的在线玩家对战游戏&#xff0c;玩法独特且充满乐趣。玩家可以使用各种富有想象力的方式推搡、击打和超越对手&#xff0c;以…
阅读更多...
路由过滤，路由策略小实验

路由过滤，路由策略小实验

目录 一&#xff0c;实验拓扑&#xff1a; 二&#xff0c;实验要求&#xff1a; 三&#xff0c;实验思路&#xff1a; 四&#xff0c;实验过程&#xff1a; 1&#xff0c;IP配置&#xff1a; 2、R1 和R2 运行 RIPv2&#xff0c;R2&#xff0c;R3 和R4运行 oSPF&#xff0…
阅读更多...
卫星导航简介

卫星导航简介

本文旨在对卫星导航系统进行简要介绍&#xff0c;包括其基本原理、发展历程以及在现代社会中的广泛应用。文章首先阐述了卫星导航的基本原理&#xff0c;即利用卫星发射的信号进行定位和导航。接着&#xff0c;回顾了卫星导航技术的发展历程&#xff0c;从早期的试验阶段到如今…
阅读更多...
OneNote插件推荐(OneMore)

OneNote插件推荐(OneMore)

使用OneNote编辑笔记时希望有一个插件能够实现markdown的功能&#xff0c;于是发现了OneMark&#xff0c;后面用着用着&#xff0c;OneMark竟然收费了&#xff0c;于是苦苦找寻好用的markdown插件&#xff0c;无果&#xff0c;此时发现我的目标主要是实现对代码的格式化&#x…
阅读更多...
vue3中web前端JS动画案例（二）多物体运动-多值运动

vue3中web前端JS动画案例（二）多物体运动-多值运动

<script setup> import { ref, onMounted, watch } from vue // ----------------------- 01 js 动画介绍--------------------- // 1、匀速运动 // 2、缓动运动&#xff08;常见&#xff09; // 3、透明度运动 // 4、多物体运动 // 5、多值动画// 6、自己的动画框架 // …
阅读更多...
DBUnit增强：填充随机数据和相对时间数据

DBUnit增强：填充随机数据和相对时间数据

痛点 测试环境验证时&#xff0c;遇到与当前相对时间相关的测试吗&#xff1f;准备一份SQL&#xff1f;隔一段时间就不能用了。每过一段时间去更新脚本或重置系统时间&#xff1f;看上去也不是很合适的解决方案。依赖数据测试时要重新做&#xff0c;演示时候得全部改&#xff…
阅读更多...
Ubuntu-18.04本地化部署Rustdesk服务器

Ubuntu-18.04本地化部署Rustdesk服务器

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、配置防火墙二、安装三大件1.下载三大件2.安装三大件 三、安装客户端1.下载客户端1.Windows2.Linux 四、配置客户端连接服务器五、总结 前言 如果你是想数据…
阅读更多...
腾讯云轻量2核2G4M服务器优惠价格99元一年，多配置报价单

腾讯云轻量2核2G4M服务器优惠价格99元一年，多配置报价单

腾讯云轻量2核2G4M服务器优惠价格99元一年&#xff0c;多配置报价单。腾讯云服务器价格表2024年最新价格&#xff0c;轻量2核2G3M服务器61元一年、2核2G4M服务器99元1年&#xff0c;三年560元、2核4G5M服务器165元一年、3年900元、轻量4核8M12M服务器646元15个月、4核16G10M配置…
阅读更多...
JavaWeb开发06-原理-Spring配置优先级-Bean管理-SpringBoot原理-Maven继承和聚合-私服

JavaWeb开发06-原理-Spring配置优先级-Bean管理-SpringBoot原理-Maven继承和聚合-私服

一、Spring配置优先级 不同配置文件&#xff0c;配置同一个属性谁有效 properties>yml>yaml 命令行参数>Java系统属性 项目打包后要改变属性&#xff1a; 红色是Java系统属性&#xff0c;绿色是命令行参数 ‘ 二、Bean管理 1.获取bean 获取IOC容器&#xff1a;ap…
阅读更多...
SpringAOP从入门到源码分析大全（三）ProxyFactory源码分析

SpringAOP从入门到源码分析大全（三）ProxyFactory源码分析

文章目录 系列文档索引五、ProxyFactory源码分析1、案例2、认识TargetSource&#xff08;1&#xff09;何时用到TargetSource&#xff08;2&#xff09;Lazy的原理&#xff08;3&#xff09;应用TargetSource 3、ProxyFactory选择cglib或jdk动态代理原理4、jdk代理获取代理方法…
阅读更多...
内存泄漏详解

内存泄漏详解

一、什么是内存泄漏&#xff1f;二、内存泄漏的原因三、内存泄漏的影响四、如何检测和解决内存泄漏&#xff1f;五、总结 一、什么是内存泄漏&#xff1f; 内存泄漏指的是程序中已分配的内存没有被正确释放&#xff0c;导致这部分内存无法被再次利用&#xff0c;最终导致内存资…
阅读更多...
【Java框架】SpringBoot（一）基本入门

【Java框架】SpringBoot（一）基本入门

目录 SpringBoot介绍Spring Boot的诞生SpringBoot特点Spring和Spring Boot的关系Spring Boot的优点和缺点Spring Boot优点Spring Boot缺点 快速创建Spring Boot项目 IDEA创建SpringBoot工程1.打开IDEA&#xff0c;选择Spring Initlializr2.选择SpringBoot版本和初始化依赖3.更改…
阅读更多...
病理验证mIF和TMA路线（自学）

病理验证mIF和TMA路线（自学）

目录 技术 使用配对病理切片 mIF验证 单基因使用TMA验证 技术 多重荧光免疫组化技术 (Multiplex immunohistochemical&#xff0c;mIHC) 也称作酪氨酸信号放大 (Tyramide dignal amplification&#xff0c;TSA) 技术&#xff0c;是一类利用辣根过氧化酶 (Horseradish Pero…
阅读更多...
(一)Java EE企业级应用开发实战之Servlet教程——JDK安装

(一)Java EE企业级应用开发实战之Servlet教程——JDK安装

首先打开清华大学开源软件镜像站&#xff0c;清华大学开源镜像网站地址为&#xff1a; https://mirrors.tuna.tsinghua.edu.cn/ 打开该地址后的界面显示如下图所示 找到8版本对应的SDK安装包&#xff0c;我现在用的开发机器是Windows&#xff0c;所以我找的是Windows对应的版本…
阅读更多...
Spring AOP (一）

Spring AOP (一）

本篇主要介绍Spring AOP的基础概念和入门使用 一、AOP的基本概念 AOP是一种面向切面编程的思想&#xff0c;它与IOC并称为Spring 的两大核心思想。什么是面向切面编程呢&#xff0c;具体来说就是对一类事情进行集中统一处理。这听起来像不像前面篇章中所介绍的统一功能处理&am…
阅读更多...
Vue2 移动端（H5）项目封装弹窗组件

Vue2 移动端（H5）项目封装弹窗组件

前言 因vant-ui的dialog组件没有自定义footer插槽 效果 参数配置 1、代码示例&#xff1a; <t-dialog :visible.sync"show" :title"title" submit"submit"></t-dialog>2、配置参数&#xff08;t-dialog Attributes&#xff09; 参…
阅读更多...
JAVA基础之垃圾收集器

JAVA基础之垃圾收集器

一 JVM垃圾收集 分代收集思想 当前虚拟机的垃圾收集一般采用分代收集算法&#xff0c;这种算法本身没有创新性&#xff0c;只是根据对象存活周期的不同将内存分为几块。一般将java堆内存分为新生代和老年代&#xff0c;这样我们就可以根据不同年龄到的特点选择不同的垃圾收集…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023