AI 助理
备案控制台
开发者社区 云计算 文章 正文

STL--String类的常用功能复写

2022-11-29 72
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 无

@[TOC]

前言：

  • 本文介绍STL-string中常用函数的复写
  • 博主收集的资料New Young，连载中。
  • 博主收录的问题:New Young
  • 转载请标明出处：New Young

string类的初识

  1. string本质是basic_string模板类的实例化后的重命名,其中含有很多处理字符串的成员函数：重栽的[],=等
typedef basic_string<char> string;

命名空间

在复写string类时，因为string类是标准库中的内置类型，为了避免命名污染问题，可以命名一个自己的命名空间

//完成string的增删查改复写
namespace My_Str //防止污染std命名空间
{
    class string
    {
    private:
        char* _str;
        int _size;//有效字符的个数
        int _capacity;//有效字符的容量，不包含'\0'，但是因为开辟空间时多开辟一个，
                      //因此默认预留了一个'\0',方便执行C函数
        ......
 }；

数据成员

这里使用数组形式，方便操作

namespace My_Str //防止污染std命名空间
{
    class string
    {
    private:
        char* _str;
        int _size;//有效字符的个数
        int _capacity;//有效字符的容量，不包含'\0'，但是因为开辟空间时多开辟一个，
                      //因此默认预留了一个'\0',方便执行C函数

构造函数

  1. string标准在初始化是不能用单一字符的，只能用字符串或者已存在的对象。
  2. 在这些构造函数中推荐使用==现代写法==，利用了函数栈帧后局部变量自动销毁和对代码的灵活复用

自定义构造函数

  1. 全缺省的构造函数,对于空字符串，_size为0,在扩容时要留意
//全缺省的构造函数,对于空字符串，_size为0,在扩容时要留意
//string(const char* str="");
My_Str::string::string(const char* str)
    :_size(strlen(str)), _capacity( _size)
{
    _str = new char[_capacity+1];//+1是给\0预留空间，防止
    strcpy(_str, str);
}

拷贝构造函数

  1. 在不用引用的情况下， 实参到形参的传递也是一种拷贝
  2. 在有需要动态管理的成员时，防止浅拷贝造成的对同一空间多次delete问题
  3. 现代写法，本质是对代码的复用和对局部变量函数栈帧后销毁的操作
//拷贝构造,注意
// 1. 在不用引用的情况下， 实参到形参的传递也是一种拷贝
// 2.在有需要动态管理的成员时，防止浅拷贝造成的对同一空间多次delete问题
My_Str::string::string(const string& s)
    
{
    ////一般写法
    //_str = new char[strlen(s._str) + 1];
    //strcpy(_str, s._str);
    //_size = s._size;
    //_capacity = s._capacity;

    ////现代写法，本质是对代码的复用和对局部变量函数栈帧后销毁的操作
    string tmp(s._str);//调用了自定义的构造函数
    _str = nullptr;//这步必须要有，否则就是对随机值进行delete
    swap(tmp);//string下的swap函数
    //std::swap(_str,tmp._str);//标准库下的swap模板函数


}

赋值运算符

  1. 一般需要考虑自身赋值问题
  2. 现代写法，因为拷贝构造后的对象地址不同，因此不用考虑自身赋值和多次释放同一空间的问题
My_Str::string& My_Str::string::operator=(const My_Str::string& s)
{
    //自身的赋值
    //if (&s != this)
    //{
    //    //一般写法：
    //    char *tmp = new char[s._size + 1];//防止申请失败，C++的new会抛异常，未学
    //    strcpy(tmp, s._str);
    //    delete[]_str;//释放原先的空间
    //    _str = tmp;//局部变量销毁后，堆的空间仍存在。
    //    _size = s._size;
    //    _capacity = s._capacity;
    //}

    //现代写法,不用考虑自身赋值和多次释放同一空间的问题
        string tmp(s);//
        std::swap(_str, tmp._str);
        _size = tmp._size;
        _capacity = tmp._capacity;
        return *this;

}

析构函数

My_Str::string::~string()//析构函数
{
    delete[]_str;
    _str = nullptr;
    _size =_capacity= 0;

}

c_str()

const char* My_Str::string::c_str()
{
    return _str;
}

const char* My_Str::string::c_str()const 
{
    return _str;
}

clear()

void My_Str::string::clear()
{
    _size = 0;
}

size()

size_t My_Str::string::size()
{
    return _size;
}


size_t My_Str::string::size()const 
{
    return _size;
}

操作符[]

char& My_Str::string::operator[](size_t pos)
{

    assert(pos < _size);
    return _str[pos];
}

const char& My_Str::string::operator[](size_t pos)const
{
    assert(pos < _size);

    return _str[pos];
}

迭代器

迭代器,暂时理解为指针

typedef char* iterator;
typedef const char* const_iterator;

My_Str::string::iterator My_Str::string::begin()
{
    return _str;
}
My_Str::string::iterator My_Str::string::end()
{
    return _str + _size ;

}

My_Str::string::const_iterator My_Str::string::begin()const
{
    return _str;
}
My_Str::string::const_iterator My_Str::string::end()const
{
    return _str + _size;

}

扩容函数

reserve()

不支持缩小扩,因此只需要考虑n>_capacity的情况

void My_Str::string::reserve(size_t n)
{
    if(n > _capacity)    
    {
        char* tmp = new char[n+1];
        strcpy(tmp,_str);
        delete[]_str;
        _str = tmp;
        _capacity = n;
    }
}

resize()

支持缩小扩，因此需要以size为界，考虑情况

void  My_Str::string::resize(size_t n, char ch)
{
    //resize不支持缩小_capacity;
    if (n <= _size)
    {
        _str[n] = '\0';
        _size = n;
    }
    else 
    {
        if (n > _capacity)
        {
            reserve(n);
        }
        memset(_str + _size, ch, n - _size);
        _str[_size] = '\0';
    }
}

插入

尾插

  1. 单个字符，只需要按情况扩容2倍即可，
  2. 但是对于字符串，其个数不可空，因此扩容时依情况确定。
  3. 对于尾插更建议使用 +=；

push_back()

void My_Str::string::push_back(char ch)
{

    if (_size == _capacity)
    {
        reserve(_capacity==0?4:_capacity*2);
    }
    _str[_size] = ch;
    ++_size;
    _str[_size] = '\0';
}

append()

void  My_Str::string::append(const char* str)
{
    size_t len = strlen(str);
    if ((len + _size) > _capacity)
    {
    
        reserve(len + _size);
    }
    strcpy(_str + _size, str);
}

操作符+=

My_Str::string& My_Str::string::operator +=(const char ch)
{
    push_back(ch);
    return *this;
}

My_Str::string& My_Str::string::operator +=(const char* str)
{
    append(str);
    return *this;
}

头插

insert()

头插，一般不建议使用，效率低

My_Str::string& My_Str::string::insert(size_t pos, const char ch)
{
    assert(pos <= _size);
    if (_size == _capacity)
    {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    //因为是无符号整型，在减运算中要注意死循环问题
    size_t end = _size+1;
    while (end > pos)
    {
        _str[end] = _str[end - 1];
        --end;
    }
    _str[pos] = ch;
    return *this;
}
My_Str::string& My_Str::string::insert(size_t pos, const char* str)
{
    assert(pos <= _size);
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
        reserve(_size + len);
    }
    size_t end = _size + len;
    while (end > pos+len)
    {
        _str[end] = _str[end - len];
        --end;
    }
    strncpy(_str + pos, str,len);
    //strcpy会将'\0添加进去'
    return *this;
}

查

find()

size_t My_Str::string::find(char ch)
{
    for (size_t i = 0; i < _size; ++i)
    {
    
        if (ch == _str[i])
        {
            return i;
    }
    }
    return npos;
}
size_t My_Str::string::find(const char* str, size_t pos)
{
    assert(pos < _size&& strlen(str)<_size);
    const char* ret = strstr(_str, str);
    if (ret != nullptr)
    {
        return ret - _str;
    }
    return npos;
}

删

erase()

My_Str::string& My_Str::string::erase(size_t pos , size_t len )
{
    assert(pos < _size);

    if (len == npos || len >= (_size - pos))//删除全部
    {
        _str[pos] = '\0';
        _size = pos;
    }
    else 
    {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
    }
    return *this;
}

输入输出函数

operator<<()

std::ostream& operator<<(std::ostream& out, const My_Str::string& s)
{
    for (int i = 0; i < s.size(); ++i)//有限次的循环，可以避免字符串中间含有'\0'的情况
    {    
        out << s[i];
    }
    //cout<<s.c_str();
    return out;
}

operator>>()

std::istream& operator >> (std::istream& in,  My_Str::string& s)
{
    char ch = 0;
    //ch = getchar();
    //while (ch != ' '&&ch!='\n')
    //{
    //    s += ch;
    //    ch = getchar();

    //}
    s.clear();
    ch = in.get();
    while (ch != ' '&&ch!='\n')
    {
        s += ch;
        ch = in.get();
    }
    return in;
}

比较函数

因为string的接口很多，这里将重载的函数都定义为全局函数

operator<()

//"abcd" "abcd" false
//"abcd" "abcde"true
//"abcde" "abcd"false
bool operator<(const My_Str::string& s1, const My_Str::string& s2)
{
    size_t i1 = 0;
    size_t i2 = 0;

    while ( i1< s1.size()&& i2<s2.size())
    {
        if (s1[i1] < s2[i2])
        {
            return false;
        
        }
        ++i1;
        ++i2;
    }

    return i1 < s1.size() ? false : true;

}

operator==()

bool operator==(const My_Str::string& s1, const My_Str::string& s2)
{
    size_t i1 = 0;
    size_t i2 = 0;
    while (i1 < s1.size() && i2 < s2.size())
    {
        if (s1[i1] != s2[i2])
        {
            return false;
        }
        ++i1;
        ++i2;
    }
    return i1 == s1.size() && i2 == s2.size() ? true : false;
}

operator!=()

bool operator!=(const My_Str::string& s1, const My_Str::string& s2)
{
    return !(s1 == s2);
}

operator<=()

bool operator<=(const My_Str::string& s1, const My_Str::string& s2)
{
    return s1 < s2 || s1 == s2;
}

operator>()

bool operator>(const My_Str::string& s1, const My_Str::string& s2)
{
    return !(s1 <= s2);
}

operator>=()

bool operator>=(const My_Str::string& s1, const My_Str::string& s2)
{
    return !(s1 < s2);
}

全部代码

String.h

#pragma once
#include<iostream>
#include<string>
#include<assert.h>
//完成string的增删查改复写
namespace My_Str //防止污染std命名空间
{
    class string
    {
    private:
        char* _str;
        int _size;//有效字符的个数
        int _capacity;//有效字符的容量，不包含'\0'，但是因为开辟空间时多开辟一个，
                      //因此默认预留了一个'\0',方便执行C函数
    public:
        static const size_t npos;
        

        //全缺省的构造函数,不能用空指针赋值，会产生野指针问题
        string(const char* str="");
        
        //自定义拷贝构造,
        // 1. 在不用引用的情况下， 实参到形参的传递也是一种拷贝
        // 2.默认的拷贝构造是浅拷贝，在有需要动态管理的成员时，防止浅拷贝造成的对同一空间多次delete问题
        //这也是现代写法的原因
        string(const string& s);
        
        //析构函数
        ~string();

        void swap(string& s);

        //赋值运算符
        string& operator=(const string& s);
        //字符首地址.
        const char* c_str();
        const char* c_str()const;
        size_t size();
        size_t size()const ;

        char& operator[](size_t pos);
        const char& operator[](size_t pos)const;
        
        //迭代器,暂时理解为指针

        //普通对象迭
        typedef char* iterator;
        iterator begin();
        iterator end();

        //常对象
        typedef const char* const_iterator;
        const_iterator begin()const;
        const_iterator end()const;


        //扩容
        void reserve(size_t n);//不支持缩小扩
        void resize(size_t n, char ch='\0');//支持缩小扩


        //插入,更多的是使用+=
        //头插，一般不建议使用，效率低
        string& insert(size_t pos, const char ch);
        string& insert(size_t pos, const char *str);


        //尾插,
        //单个字符，只需要按情况扩容2倍即可，
        // 但是对于字符串，其个数不可空，因此扩容时依情况确定。
        //
        void push_back(char ch);

        void append( const char* str);
        

        string& operator +=(const char ch);

        string& operator +=(const char* str);
        
        //删
        string& erase(size_t pos = 0, size_t len = npos);
        //查
        size_t find(char ch);
        size_t find(const char* str, size_t pos = 0);

    };
}

std::ostream &operator<<(std::ostream& out, const My_Str::string& s);

std::istream& operator >> (std::istream& in,  My_Str::string& s);

bool operator<(const My_Str::string& s1, const My_Str::string& s2);
bool operator==(const My_Str::string& s1, const My_Str::string& s2);
bool operator!=(const My_Str::string& s1, const My_Str::string& s2);

bool operator<=(const My_Str::string& s1, const My_Str::string& s2);


bool operator>(const My_Str::string& s1, const My_Str::string& s2);

bool operator>=(const My_Str::string& s1, const My_Str::string& s2);

String.cpp

#define _CRT_SECURE_NO_WARNINGS
#include"String.h"

 const size_t My_Str::string::npos=-1;

//全缺省的构造函数,对于空字符串，_size为0,在扩容时要留意
My_Str::string::string(const char* str)
    :_size(strlen(str)), _capacity( _size)
{
    _str = new char[_capacity+1];
    strcpy(_str, str);
}

//拷贝构造,注意
// 1. 在不用引用的情况下， 实参到形参的传递也是一种拷贝
// 2.在有需要动态管理的成员时，防止浅拷贝造成的对同一空间多次delete问题
// 3.这也是现代写法的原因
My_Str::string::string(const string& s)
    
{
    ////一般写法
    //_str = new char[strlen(s._str) + 1];
    //strcpy(_str, s._str);
    //_size = s._size;
    //_capacity = s._capacity;

    ////现代写法，本质是对代码的复用和对局部变量函数栈帧后销毁的操作
    string tmp(s._str);//调用了自定义的构造函数
    _str = nullptr;//这步必须要有，否则就是对随机值进行delete
    swap(tmp);//string下的swap函数
    //std::swap(_str,tmp._str);//标准库下的swap模板函数
    _size = tmp._size;
    _capacity = tmp._capacity;

}


My_Str::string::~string()//析构函数
{
    delete[]_str;
    _str = nullptr;
    _size =_capacity= 0;

}

void My_Str::string::swap(string& s)
{
    std::swap(_str, s._str);
    std::swap(_size, s._size);
    std::swap(_capacity, s._capacity);
}

My_Str::string& My_Str::string::operator=(const My_Str::string& s)
{
    //自身的赋值
    //if (&s != this)
    //{
    //    //一般写法：
    //    char *tmp = new char[s._size + 1];//防止申请失败，C++的new会抛异常，未学
    //    strcpy(tmp, s._str);
    //    delete[]_str;//释放原先的空间
    //    _str = tmp;//局部变量销毁后，堆的空间仍存在。
    //    _size = s._size;
    //    _capacity = s._capacity;
    //}

    //现代写法,不用考虑自身赋值和多次释放同一空间的问题
        string tmp(s);//
        std::swap(_str, tmp._str);
        _size = tmp._size;
        _capacity = tmp._capacity;
        return *this;

}

//字符首地址.
const char* My_Str::string::c_str()
{
    return _str;
}

const char* My_Str::string::c_str()const 
{
    return _str;
}

size_t My_Str::string::size()
{
    return _size;
}


size_t My_Str::string::size()const 
{
    return _size;
}


char& My_Str::string::operator[](size_t pos)
{

    assert(pos < _size);
    return _str[pos];
}

const char& My_Str::string::operator[](size_t pos)const
{
    assert(pos < _size);

    return _str[pos];
}



My_Str::string::iterator My_Str::string::begin()
{
    return _str;


}
My_Str::string::iterator My_Str::string::end()
{
    return _str + _size ;

}


My_Str::string::const_iterator My_Str::string::begin()const
{
    return _str;
}
My_Str::string::const_iterator My_Str::string::end()const
{
    return _str + _size;

}

void My_Str::string::reserve(size_t n)
{
    if(n > _capacity)    
    {
        char* tmp = new char[n+1];
        strcpy(tmp,_str);
        delete[]_str;
        _str = tmp;
        _capacity = n;
    }
}

void  My_Str::string::resize(size_t n, char ch)
{
    //resize不支持缩小_capacity;
    if (n <= _size)
    {
        _str[n] = '\0';
        _size = n;
    }
    else 
    {
        if (n > _capacity)
        {
            reserve(n);
        }
        memset(_str + _size, ch, n - _size);
        _str[_size] = '\0';
    }
}

void My_Str::string::push_back(char ch)
{

    if (_size == _capacity)
    {
        reserve(_capacity==0?4:_capacity*2);
    }
    _str[_size] = ch;
    ++_size;
    _str[_size] = '\0';
}

void  My_Str::string::append(const char* str)
{
    size_t len = strlen(str);
    if ((len + _size) > _capacity)
    {
    
        reserve(len + _size);
    }
    strcpy(_str + _size, str);
}

My_Str::string& My_Str::string::operator +=(const char ch)
{
    push_back(ch);
    return *this;
}

My_Str::string& My_Str::string::operator +=(const char* str)
{
    append(str);
    return *this;
}

size_t My_Str::string::find(char ch)
{
    for (size_t i = 0; i < _size; ++i)
    {
    
        if (ch == _str[i])
        {
            return i;
    }
    }
    return npos;
}
size_t My_Str::string::find(const char* str, size_t pos)
{
    assert(pos < _size&& strlen(str)<_size);
    const char* ret = strstr(_str, str);
    if (ret != nullptr)
    {
        return ret - _str;
    }
    return npos;
}
My_Str::string& My_Str::string::insert(size_t pos, const char ch)
{
    assert(pos <= _size);
    if (_size == _capacity)
    {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    //因为是无符号整型，在减运算中要注意死循环问题
    size_t end = _size+1;
    while (end > pos)
    {
        _str[end] = _str[end - 1];
        --end;
    }
    _str[pos] = ch;
    return *this;
}
My_Str::string& My_Str::string::insert(size_t pos, const char* str)
{
    assert(pos <= _size);
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
        reserve(_size + len);
    }
    size_t end = _size + len;
    while (end > pos+len)
    {
        _str[end] = _str[end - len];
        --end;
    }
    strncpy(_str + pos, str,len);
    //strcpy会将'\0添加进去'
    return *this;
}
My_Str::string& My_Str::string::erase(size_t pos , size_t len )
{
    assert(pos < _size);

    if (len == npos || len >= (_size - pos))//删除全部
    {
        _str[pos] = '\0';
        _size = pos;
    }
    else 
    {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
    }
    return *this;
}
//
//"abcd" "abcd" false
//"abcd" "abcde"true
//"abcde" "abcd"false
bool operator<(const My_Str::string& s1, const My_Str::string& s2)
{
    size_t i1 = 0;
    size_t i2 = 0;

    while ( i1< s1.size()&& i2<s2.size())
    {
        if (s1[i1] < s2[i2])
        {
            return false;
        
        }
        ++i1;
        ++i2;
    }

    return i1 < s1.size() ? false : true;

}
bool operator==(const My_Str::string& s1, const My_Str::string& s2)
{
    size_t i1 = 0;
    size_t i2 = 0;
    while (i1 < s1.size() && i2 < s2.size())
    {
        if (s1[i1] != s2[i2])
        {
            return false;
        }
        ++i1;
        ++i2;
    }
    return i1 == s1.size() && i2 == s2.size() ? true : false;
}
bool operator!=(const My_Str::string& s1, const My_Str::string& s2)
{
    return !(s1 == s2);
}

bool operator<=(const My_Str::string& s1, const My_Str::string& s2)
{
    return s1 < s2 || s1 == s2;
}
bool operator>(const My_Str::string& s1, const My_Str::string& s2)
{
    return !(s1 <= s2);
}


bool operator>=(const My_Str::string& s1, const My_Str::string& s2)
{
    return !(s1 < s2);
}

std::ostream& operator<<(std::ostream& out, const My_Str::string& s)
{
    for (int i = 0; i < s.size(); ++i)//有限次的循环，可以避免字符串中间含有'\0'的情况
    {    
        out << s[i];
    }
    //cout<<s.c_str();
    return out;
}

std::istream& operator >> (std::istream& in,  My_Str::string& s)
{
    char ch = 0;
    //ch = getchar();
    //while (ch != ' '&&ch!='\n')
    //{
    //    s += ch;
    //    ch = getchar();

    //}
    ch = in.get();
    while (ch != ' '&&ch!='\n')
    {
        s += ch;
        ch = in.get();
    }
    return in;
}

总结

在处理边界问题，一定要仔细，否则程序可能会CREASH

文章标签：
云数据库 ClickHouse
关键词：
String类
String功能
String类功能
游客myapyvipxlqt4
目录
相关文章
chian-ocean
|
11天前
|
安全 程序员 C++
C++ --＞ string类的使用（详细介绍）
C++ --＞ string类的使用（详细介绍）
chian-ocean
26 5
chian-ocean
|
11天前
|
存储 编译器 C语言
C++ --＞ string类模拟实现（附源码）
C++ --＞ string类模拟实现（附源码）
chian-ocean
35 4
yinying293
|
11天前
|
安全 Java
12 Java常用类（二）（String类+时间类+BigDecimal类等等）
12 Java常用类（二）（String类+时间类+BigDecimal类等等）
yinying293
23 2
李木子2024
|
1天前
|
缓存 安全 Java
【揭秘】String vs StringBuilder vs StringBuffer：三大字符串类的秘密较量！你真的知道何时该用哪个吗？
【8月更文挑战第19天】探讨Java中`String`、`StringBuilder`与`StringBuffer`的区别及应用场景。`String`不可变，适合做哈希表键或多线程共享。`StringBuilder`支持动态修改字符串，适用于单线程环境以提高性能。`StringBuffer`与`StringBuilder`功能相似，但线程安全。示例代码展示各类型的基本用法。选择哪种类型取决于具体需求和性能考量。
李木子2024
3 0
大柏怎么被偷了
|
6天前
|
编译器 C语言 C++
【C++】模拟实现string类
【C++】模拟实现string类
大柏怎么被偷了
8 0
大柏怎么被偷了
|
7天前
|
存储 算法 C语言
【C++】认识使用string类
【C++】认识使用string类
大柏怎么被偷了
9 0
ForcibleBugMaker
|
1月前
|
编译器 C++
【C++】string类的使用④（字符串操作String operations ）
这篇博客探讨了C++ STL中`std::string`的几个关键操作，如`c_str()`和`data()`，它们分别返回指向字符串的const char*指针，前者保证以&#39;\0&#39;结尾，后者不保证。`get_allocator()`返回内存分配器，通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组，不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量，表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
ForcibleBugMaker
28 1
ForcibleBugMaker
|
1月前
|
存储 C++
【C++】string类的使用③（非成员函数重载Non-member function overloads）
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容，包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容，成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接，关系运算符（如`==`, `&lt;`等）用于比较字符串，以及`swap`非成员函数。此外，还介绍了`getline`函数，用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用，并给出了多个示例代码。
ForcibleBugMaker
23 1
爱你三千遍斯塔克
|
1月前
|
存储
数据存储之数组的特点，长度固定，适应变化需求，集合类特点是空间可变，ArrayList泛型,ArrayList＜String＞ array = new ArrayList＜String＞()
数据存储之数组的特点，长度固定，适应变化需求，集合类特点是空间可变，ArrayList泛型,ArrayList＜String＞ array = new ArrayList＜String＞()
爱你三千遍斯塔克
18 0
爱你三千遍斯塔克
|
1月前
|
存储
定义存储路径的写法 private static final String STORE_DIR = “E:\\B站视频创作\\前后端项目构建-小功能实现\\代码\\backend\\src\\main
定义存储路径的写法 private static final String STORE_DIR = “E:\\B站视频创作\\前后端项目构建-小功能实现\\代码\\backend\\src\\main
爱你三千遍斯塔克
10 0