精华内容
下载资源
问答
  • C++ string类
    千次阅读
    2021-04-15 21:29:56

    string 的初始化

    ​ 使用 string 类要导入头文件 #include <string>,string 类是模板类 typedef basic_string<char> string;basic_string 类模板实例化生成的。string 类有多种构造函数,string 对象的几种初始化方式如下

    string s1("Hello");
    string month = "March";
    string s2(8,'x'); // 生成具有8个x字符的字符串
    // string 对象不能用字符(char)进行初始化,但是可以用字符对string 对象进行赋值
    string error1 = 'c';
    string error2('c');
    // string 对象不能用数值进行初始化
    string error1 = 22;
    string error2(8);
    

    string 的基础操作

    获取长度 length()

    ​ string 对象的长度用成员函数 length() 读取,string s("hello"); cout << s.length();

    流读取 getline()

    ​ string 类支持流读取运算符,string str; cin >> str;。同时支持 getline() 函数,从流读取中读取一整行到指定的 string 对象,getline(cin, str);

    赋值 =

    ​ string 类支持 = 运算符进行赋值,string s1("cat"), s2;

    复制 assign()

    ​ string 对象使用 assign() 成员函数进行复制,string s1("cat"), s3; s3.assign(s1);,使用 assign() 函数除了可以完整复制,也可以指定起始位置和子串长度进行部分复制s3.assign(s1,1,3); 从 s1 中下标为1的字符开始复制3个字符的子串给 s3。除此之外也可以对单个字符进行复制 s2[5] = s1[3] = 'a';

    随机访问 at()

    ​ string 对象可以使用 at() 成员函数逐个访问对象中的字符,也可以使用下标运算符 [] 进行随机访问,区别在于 at() 成员函数会做范围检查,如果超出范围会抛出 out_of_range 异常,而下标运算符不做范围检查。string str("Hello"); sout<< str.at(1) << str[2];

    连接 append()

    ​ string 对象的连接可以使用 append() 成员函数连接字符串,string s1("hello"), s2("world"); s1.append(s2);;和 assign() 函数类似 append() 函数也可以通过指定起始位置和长度进行部分连接s2.append(s1,3,s1.size()); 从 s1 中下标为3开始将s1.size() 个字符连接到 s2 字符串,如果字符串内没有足够字符,则复制到字符串最后一个字符。除了 append() 函数也可以使用连接运算符 + 连接字符串,s1 += s2;

    取子串 substr()

    ​ string 对象使用 substr() 成员函数取子串,string s1("hello"), s2; s2 = s1.substr(0,4); 返回 s1 从下标0开始的4个字符组成的子串给 s2。

    交换 swap()

    ​ string 对象使用 swap() 成员函数交换两个 string 对象的值,string s1("hello"), s2("world"); s1.swap(s2);

    替换 replace()

    ​ string 对象使用 replace() 成员函数替换字符串,string s1("hello"); s1.replace(2,3,"1234"); 将 s1 中从下标 2 开始的3个字符串用 “1234” 替换;也可以使用· s1.replace(2,3,"1234",1,2); 指定用于替换字符串的子串,即用 “1234” 下标 1 开始的两个字符进行替换。

    插入 insert()

    ​ string 对象使用 insert() 成员函数插入其他字符串,string s1("hello"), s2("world"); s1.insert(4,s2); 将 s2 插入到 s1 下标为4的位置;s1.insert(2,s2,0,3); 将 s2 从下标0开始的3个字符插入到 s1 下标为2的位置;

    删除子串 erase()

    ​ string 对象使用 erase() 成员函数删除子串,string s1("hello"); s1.erase(2); 将 s1 中从下标 2 开始(包含下标2的字符)之后的字符删除。

    string 的比较操作

    关系运算符比大小:string 对象可以关系运算符比较大小 ==, >, >=, <, <=, != 返回值都是 bool 类型,成立返回 true,否则返回 false

    string s1("hello"),s2("hello"),s3("hell");
    bool b = (s1 == s2);
    cout << b << endl;
    b = (s1 == s3);
    cout << b << endl;
    b = (s1 > s3);
    cout << b << endl;
    

    compare()函数比大小:string 对象也可以compare() 成员函数比较大小 ,大于返回值为 1,等于返回值为 0,小于返回值为 -1;和 assign(), append()函数类似,compare()函数也可以指定起始位置和长度进行部分比较s1.compare(1,2,s3,0,3); s1 从以开始的2个字符构成的子串和 s3 从0开始的3个字符构成的子串进行比较。

    string 的查找操作

    ​ 示例 string s1("hello, world");

    • find()s1.find("lo"); 在 s1 中从前向后查找 "lo" 第一次出现的地方,如果找到返回对应的位置即 l 的位置下标;如果没有找到则返回一个静态常量 string::npos 。除此之外,find() 成员函数也可以指定查找的起始位置,s1.find("ll",3);表示从 s1 下标为3的位置开始从前向后查找。

    • rfind()s1.rfind("lo"); 在 s1 中从后向前查找 "lo" 第一次出现的地方,如果找到返回对应的位置即 l 的位置下标;如果没有找到则返回一个静态常量 string::npos

    • find_first_of()s1.find_first_of("abcd"); 在 s1 中从前向后查找 "abdc"任何一个字符第一次出现的地方,如果找到返回被找到字母的位置;如果没有找到则返回一个静态常量 string::npos

    • find_last_not_of()s1.find_last_not_of("abcd"); 在 s1 中从后向前查找不在 "abdc"任何一个字符第一次出现的地方,如果找到返回被找到字母的位置;如果没有找到则返回一个静态常量 string::npos

    string 的C语言转换

    ​ C++ 是兼容 C 语言的,但是 C 语言中没有 string 类,所以要使用一些方法将 string 对象转换为 C 语言支持的 char * 字符串。

    • c_str():返回一个以 \0 结尾的 C 字符串,即 c_str() 函数返回一个指向正规 C 字符串的指针, 内容与原始string串相同。例如 string s1("hello world"); s1.c_str();s1.c_str(); 返回传统的 const char * 类型字符串,且该字符串以 \0 结尾。
    • data():与 c_str() 方法类似,但是返回的是 char * 类型字符串,而非 const 类型,在修改时会导致原始字符转被更改。

    String 类型转换

    C++11新特性中加入了更加便捷的字符串类型与其他数据类型的转换方法,使用前导入头文件 #include <string>

    其他类型转字符串

    string to_string(int _Val);
    string to_string(unsigned int _Val);
    string to_string(long _Val);
    string to_string(unsigned long _Val);
    string to_string(long long _Val);
    string to_string(unsigned long long _Val);
    string to_string(float _Val);
    string to_string(double _Val);
    string to_string(long double _Val);
    

    字符串转其他类型

    double stod(const string& _Str, size_t *_Idx = nullptr);
    float stof(const string& _Str, size_t *_Idx = nullptr);
    int stoi(const string& _Str, size_t *_Idx = nullptr, int _Base = 10);
    long stol(const string& _Str, size_t *_Idx = nullptr, int _Base = 10);
    long double stold(const string& _Str, size_t *_Idx = nullptr);
    unsigned long stoul(const string& _Str, size_t *_Idx = nullptr, int _Base = 10);
    long long stoll(const string& _Str, size_t *_Idx = nullptr, int _Base = 10);
    unsigned long long stoull(const string& _Str, size_t *_Idx = nullptr, int _Base = 10);
    

    字符串流处理

    ​ 除了标准流和文件流输入输出外,还可以从 string 进行输入输出。类似 istream 和 ostream 进行标准流输入输出,也可以用 istringstream 和 ostringstream 进行字符串上的输入输出,也称为内存输入输出。使用字符串流处理需要导入以下头文件 <string> <iostream> <sstream>

    // 使用 istringstream 进行字符串输入
    string input("Input test 123 4.7 A");
    istringstream inputString(input); // 声明istringstream对象
    int i; double d; char c;
    inputString >> str1 >> str2 >> i >> d >> c; // 使用istringstream对象进行字符串输入
    cout << str1 << str2 << endl;
    cout << i << ' ' << d << ' ' << c << endl;
    
    // 使用 ostringstream 进行字符串输出
    ostringstream outputString;
    int a = 10;
    outputString << "This" << a << "ok" << endl;
    cout << outputString.str(); // 取出ostringstream的字符串
    

    Ctype.h 中的字符分类判断方法

    C 标准库的 ctype.h 头文件提供了一些函数,可用于测试和映射字符。

    这些函数接受 int 作为参数,它的值必须是 EOF 或表示为一个无符号字符。

    如果参数 c 满足描述的条件,则这些函数返回非零(true)。如果参数 c 不满足描述的条件,则这些函数返回零。

    判断字符类型函数

    函数描述
    isdigit( )是数字,返回值为真,否则为0
    isalpha( )是字母,返回值为真,否则为0
    isalnum( )是数字/字母,返回值为真,否则为0
    islower( )是小写字母,返回值为真,否则为0
    isupper( )是大写字母,返回值为真,否则为0
    isspace( )是空白字符(\n ’ ’ \f \r \t \v),返回值为真,否则为0
    iscntrl( )是控制字符(\t \v \f \a \b \r \n),返回值为真,否则为0
    isprint( )是可打印字符(包含空格),返回值为真,否则为0
    isgraph( )是可打印字符(除了空格),返回值为真,否则为0

    字符转换函数

    函数描述
    tolower( )若为大写字母,则转为小写字母并返回,否则返回原值
    toupper( )若为小写字母,则转为大写字母并返回,否则返回原值

    Reference

    C++string类总结

    更多相关内容
  • Java基础语法(九)——String类

    万次阅读 多人点赞 2021-05-26 12:20:57
    一、创建字符串 创建字符串的方式有很多种,常见的构造 String 的方式如以下: 方式一:直接赋值法 方式二: new String() 方式三:创建一个字符数组ch,new String ( ch )

    Java基础语法(九)——String类


    本次内容介绍大纲


    在这里插入图片描述

      字符串是我们以后工作中非常常用到的类型. 使用起来都非常简单方便, 我们一定要使用熟练。


      那么C语言中是否有字符串类型? 答案是 “ 没有 ” !!


      char *p = " hello";


      那么p 的类型是一个字符串类型么? 不是,p是一个指针!!


      而在 Java当中 是有 字符串类型的——String


    一、定义方式


    创建字符串的方式有很多种,常见的构造 String 的方式如以下:

    方式一:直接赋值法

    String str1 = "hello";
    

    方式二: new String()

    String str2 = new String("hello");
    

    方式三:创建一个字符数组ch,new String ( ch )

    char chs[] = {'h','e','l','l','l','o'};
    String str3 = new String(chs);
    

    二、内存


    在此之前我们要先引入一个概念 字符串常量池

    Sting constant pool 字符串常量池 的特性


    1.在JDK.7 开始,字符串常量池 被挪到堆里了

    2.池内的数据不存在重复


      下面我们通过一系列的练习来熟悉 字符串常量池以及 字符串类型数据在内存中的存放。

      public static void main(String[] args) {
           String str1 = "hello";
           String str2 = new String("hello");
            System.out.println(str1 == str2);
    
            String str3 = "hello";
            System.out.println(str1 == str3);
        }
    

      我们来看这样的代码,str 代表的是引用\地址,请判断 两次打印分别是什么?


    我们来看结果


    在这里插入图片描述


      这个结果说明 str1 和 str2存放的地址是不一样的, str1 和 str3 存放的地址是一样的。


      好的,为什么是这样的结果呢?我们来看一下这几个字符串类型变量的内存。

    在这里插入图片描述

      "hello"如果存放在常量池当中,就会占用内存,假如这块空间的地址为111,那么str1中存放的就是111.

      str2 new一个String对象,那么肯定在堆上开辟内存,假设内存地址是888,在这个String 对象中,存在一个value[] 保存着 orginal传入的字符串,这个val ==“hello”,因为在字符串常量池中已经有了"hello",所以val 直接指向 常量池中的"hello".但是str2 指向的依然是 888在堆中的空间。

    在这里插入图片描述
    在这里插入图片描述

    所以 str1 不等于 str2。


      之后呢,str3 也等于"hello",他也准备把hello放在常量池当中.此时常量池中已经存在"hello",那么之后str3 在存放"hello"地址的时候,就指向的是常量池中原来hello的地址。


    所以 str1 等于 str3


    再看一组练习

        public static void main(String[] args) {
    
            String str1 = "hello";
            String str2 = "hel"+"lo";
            System.out.println(str1==str2);
    
            String str3 = new String("hel")+"lo";
            System.out.println(str1==str3);
    
        }
    

    请判断两次打印的结果…

    结果如下:

    在这里插入图片描述
    下面我们来分析,这组代码中str变量的内存存放

    在这里插入图片描述

    str1 指向字符串常量池中的 “hello”

      str2 是"hel"与"lo" 组合而成的,常量在编译的时候就已经确定了,所以在编译时,已经被处理为"hello",所以也指向 常量池中的"hello"。


    所以 str1 等于 str2


      str3 首先new 了一个String(“hel”)对象,在堆中开辟一块空间,这个对象中的"hel"同时存放在常量池中,之后又在常量池中开辟一块空间存放 “lo”。两块部分之间的"+",将 String 的对象 与常量池中的 "lo"结合在堆中再次开辟一块新的空间,这块内存中的val ==“hello”,str3指向的是合并之后的对象 ,地址为999.

    所以 str1 不等于 str3.


    再看一组练习

     public static void func(String str,char[] array){
            str = "abcdef";
            array[0] = 'g';
        }
    
        public static void main(String[] args) {
            String str1 = "hello";
            char[] val = {'a'};
            System.out.println(str1);
            System.out.println(Arrays.toString(val));
            func(str1,val);
            System.out.println("=================");
            System.out.println(str1);
            System.out.println(Arrays.toString(val));
        }
    

      请看一下,我们将String str 作为参数,改变str 的内容,以及传入 数组 val 改变 数组元素,其打印结果是什么?


    在这里插入图片描述

      我们看到 String str 的内容并未改变,但是数组 val 的元素却改变了。

    我们从内存的角度来分析。

    在这里插入图片描述

      str1 指向字符串常量区的"hello",地址为888

      val 作为数组引用,指向堆中开辟的数组空间,地址为777

      str 作为函数的形参,接收str1实参的值,也就是888,此时str指向常量区的”hello“,但是在方法的内部,str = “abcde”,在字符串常量区中有开辟一块"abcde"的内存,地址为000,最后 str 存放的地址为000.

      array 作为函数的形参,接收val 实参的值,也就是777,此时array 指向堆中 开辟的数组空间,此时通过array 来改变数组元素的内容,最终 改变的也同样是val 实参的内容.


    三、字符串比较相等


    如果现在有两个int型变量,判断其相等可以使用 == 完成。

    str1 = "world";
    System.out.println(str2);
    // 执行结果
    //Hello
    int x = 10 ;
    int y = 10 ;
    System.out.println(x == y); 
    // 执行结果
    //true
    

    如果说现在在String类对象上使用 == ?


    代码1

    String str1 = "Hello";
    String str2 = "Hello"; 
    System.out.println(str1 == str2); 
    // 执行结果
    //true 
    

    看起来貌似没啥问题, 再换个代码试试, 发现情况不太妙.


    代码2

    String str1 = new String("Hello");
    String str2 = new String("Hello");
    System.out.println(str1 == str2);
    // 执行结果
    //false
    

      在上面的几个练习中,我们 用 str1 == str2 比较的是两个字符串的引用/地址,如果比较字符串里面的内容,我们需要用到 equals 方法。


     public static void main(String[] args) {
            String str1 = "hello";
            String str2 = new String("hello");
            
            System.out.println(str1==str2);          //比较的是引用
            System.out.println(str1.equals(str2));   //比较 str1 和 str2 字符串的内容
            
            String str3 = "hello";
            System.out.println(str1.equals(str3));   //比较 str1 和 str3 字符串的内容
        }
    
    

    最后的打印结果


    在这里插入图片描述


    打印的结果符合字符串的内容比较。

    常用的比较方式:

    我们再来看一种情况,

      public static void main(String[] args) {
            String str1 = null;
            String str2 = "hello";
            System.out.println(str1.equals(str2));
        }
    

    这时候运行程序,就会出现以下情况:

    在这里插入图片描述


    空指针异常,因为 null. 任何方法都会出现异常。

    所以一定要保证 str1 不能为null。

    那么如果我们改一下,

    public static void main(String[] args) {
            String str1 = null;
            String str2 = "hello";
            System.out.println(str2.equals(str1));
        }
    

      所以我们知道 equals(),括号里可以是null,但是 点之前一定不能是 null.

    public static void main(String[] args) {
            String str1 = "hello";
    
            System.out.println(str1.equals("hello"));  // 方式1
            System.out.println("hello".equals(str1));  // 方式2
        }
    

      当我们写代码遇到以上的情况时,我们应该尽量选方式2,这样保证 equals之前一定不为null,以防出现异常.


    四、字符串常量池


      在上面的例子中, String类的两种实例化操作, 直接赋值和 new 一个新的 String.


    (1) 直接赋值


    System.out.println("Hello".equals(str));  // 执行结果 false
    String str1 = "hello" ;
    String str2 = "hello" ; 
    String str3 = "hello" ; 
    System.out.println(str1 == str2); // true
    System.out.println(str1 == str3); // true
    System.out.println(str2 == str3); // true
    

    String类的设计使用了共享设计模式

    在JVM底层实际上会自动维护一个对象池(字符串常量池)

      如果现在采用了直接赋值的模式进行String类的对象实例化操作,那么该实例化对象(字符串内容)将自动保存到这个对象池之中.

      如果下次继续使用直接赋值的模式声明String类对象,此时对象池之中如若有指定内容,将直接进行引用

      如若没有,则开辟新的字符串对象而后将其保存在对象池之中以供下次使用


    理解 “池” (pool)

      “池” 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 “内存池”, “线程池”, “数据库连接池” …然而池这样的概念不是计算机独有, 也是来自于生活中.
      举个栗子:现实生活中有一种女神, 称为 “绿茶”, 在和高富帅谈着对象的同时, 还可能和别的屌丝搞暧昧. 这时候这个屌丝被称为 “备胎”. 那么为啥要有备胎? 因为一旦和高富帅分手了, 就可以立刻找备胎接盘, 这样 效率比较高.如果这个女神, 同时在和很多个屌丝搞暧昧, 那么这些备胎就称为 备胎池.


    (2)采用构造方法


    类对象使用构造方法实例化是标准做法。分析如下程序:


    String str = new String("hello");
    

    在这里插入图片描述


    这样的做法有两个缺点:


    1.  如果使用String构造方法就会开辟两块堆内存空间,并且其中一块堆内存将成为垃圾空间(字符串常量 “hello” 也是一个匿名对象, 用了一次之后就不再使用了, 就成为垃圾空间, 会被 JVM 自动回收掉).

    2.  字符串共享问题. 同一个字符串可能会被存储多次, 比较浪费空间.


    (3)intern 的使用

    String str1 = "hello";
    String str2 = new String("hello").intren();
    

      从上面的由 构造方法定义字符串,我们会浪费内存空间,而这里有一个方法 ,叫做intern(),手动入池。


    那这是什么意思呢?


      这是先看一下传入构造方法的字符串在字符串常量池中是否存在,如果有的话,就把常量池中的引用传给当前的引用类型变量。

    在这里插入图片描述

    综上所述,我们一般使用 直接赋值法来 创建 String 对象。

    在这里插入图片描述

    我们再来看这样一组代码,来画一下他的内存结构

    在这里插入图片描述

      在第一步的代码中,new 了两个字符串"1",在堆中创建了两个对象,指向常量池中的"1",拼接在一起,s3.interb(),s3手动入池,“11"在池中没有,所以就把 堆中的"11"的引用 555 传入常量池中。s4 指向池中的"11”,而这时池中已经有了"11"的引用,所以s4 指向的就是 s3在入池的引用。

    所以结果为 true。
    在这里插入图片描述

    所以呢,我们解决了一个疑问

      在常量池当中,可以放 字符串的字面值常量,也可以放引用。什么时候放引用,就是类似于上面的那种情况之下,s3.intern(),s3所指向的这个对象在字符串常量池中是不存在的,那么入池的时候就把堆中s3的引用放入。


    五、理解字符串不可变


      字符串是一种不可变对象. 它的内容不可改变.这是什么意思呢?

      public static void main(String[] args) {
            String str = "hello" ;
            str = str + " world" ;
            str += "!!!" ;
            System.out.println(str);
        }
    

      对于这种代码,乍一看我们以为成功的将str 每次与其他的字符串拼接,但是这样是不可以的, str 原来指向的是"hello",但是 在与" world"拼接之后,又会产生一个新的对象"helll world",再次拼接一个"!!!",那么又会产生一个新的对象"hello world!!!",在内存中就会产生多个对象。

    在这里插入图片描述

    我们最后需要的是"hello world!!!",但是却开辟了5块内存空间。

    如果在一个循环中拼接,那么会开辟更多的内存空间!!

    所以这样的代码是极为不可取的!!!

    那么如何拼接呢,具体在之后的StringBuff、StringBuilder中介绍。


    六、字符、字节、字符串


    (1)字符与字符串


    字符串内部包含一个字符数组,String 可以和 char[] 相互转换

    在这里插入图片描述

    1.字符数组转字符串
    在这里插入图片描述

        public static void main(String[] args) {
            char[] val = {'h','e','l','l','o'};
            String str = new String(val);
            System.out.println(val);
        }
    

    此时我们 的 str 结果就是 “hello”,同时他也可以再给两个参数.


    2.将部分字符数组中的内容转换为字符串
    在这里插入图片描述
    offset–偏移量
    count-- 转换几个

     public static void main(String[] args) {
            char[] val = {'h','e','l','l','o'};
            String str = new String(val,1,2);
            System.out.println(str);
        }
    

    此时我们将val 中偏移1个,转换之后的两个数组元素为字符串

    打印结果应该为 el

    运行结果如下:

    在这里插入图片描述


    3.将字符串中对应索引转换为字符
    在这里插入图片描述

     public static void main(String[] args) {
            String str = "hello";
            char ch = str.charAt(1);
            System.out.println(ch);
        }
    

    索引从0开始,我们输入1,所以转换的为字符串中的e

    运行结果如下:

    在这里插入图片描述


    4.将字符串转换为字符数组
    在这里插入图片描述

     public static void main(String[] args) {
            String str = "hello";
            char[] val = str.toCharArray();
            System.out.println(Arrays.toString(val));
        }
    

    我们用字符数组接收 str转换后的字符。

    运行结果如下:


    在这里插入图片描述

      好了,了解了这几种字符与字符串的方法,我们通过几个练习来继续熟悉。


    练习一

      给定字符串一个字符串, 判断其是否全部由数字所组成.

      思路: 将字符串变为字符数组而后判断每一位字符是否是" 0 “~”‘9’"之间的内容,如果是则为数字.

      public static boolean func1(String str){
            for (int i = 0; i <str.length() ; i++) {
                if(str.charAt(i)>'9' || str.charAt(i)<'0'){
                    return false;
                }
            }
            return true;
        }
    

    (2)字节与字符串


      字节常用于数据传输以及编码转换的处理之中,String 也能方便的和 byte[] 相互转换


    常用方法:

    在这里插入图片描述

    1.字节数组转换为字符串
    在这里插入图片描述

      public static void main(String[] args) {
            byte[] bytes = {97,98,99,100};
            String str = new String(bytes);
            System.out.println(str);
        }
    

    运行结果:
    在这里插入图片描述
    字符串中的内容是字节数组与Ascii 码表中对应的字符。


    2.部分字节数组的内容转换为字符串
    在这里插入图片描述

      public static void main(String[] args) {
            byte[] bytes = {97,98,99,100};
            String str = new String(bytes,2,1);
            System.out.println(str);
        }
    

    运行结果:

    在这里插入图片描述


    3.字符串转换为字节数组
    在这里插入图片描述

       public static void main(String[] args) {
            String str = "abcd";
            byte[] bytes = str.getBytes();
            System.out.println(Arrays.toString(bytes));
        }
    

    运行结果:

    在这里插入图片描述


    (3) 小结


    那么何时使用 byte[], 何时使用 char[] 呢?


      byte[] 是把 String 按照一个字节一个字节的方式处理, 这种适合在网络传输, 数据存储这样的场景下使用. 更适合针对二进制数据来操作.

      char[] 是吧 String 按照一个字符一个字符的方式处理, 更适合针对文本数据来操作, 尤其是包含中文的时候.


    七、字符串的常见操作


    (1)字符串比较


      上面使用过String类提供的equals()方法,该方法本身是可以进行区分大小写的相等判断。除了这个方法之外,String类还提供有如下的比较操作.

    在这里插入图片描述

    1.区分大小写比较
    在这里插入图片描述

       public static void main(String[] args) {
            String str1 = "abcd";
            String str2 = "Abcd";
            System.out.println(str1.equals(str2));
        }
    

    运行结果:
    在这里插入图片描述
    我们常用的equals 方法 是区分大小写的,这点要注意。


    2.不区分大小写的比较
    在这里插入图片描述

        public static void main(String[] args) {
            String str1 = "abcd";
            String str2 = "Abcd";
            System.out.println(str1.equalsIgnoreCase(str2));
        }
    

    运行结果:

    在这里插入图片描述

      这种不区分大小写的比较还是很常见的,比如应用于验证码上,不区分大小写。


    3.比较两个字符串的大小关系
    在这里插入图片描述

    public static void main(String[] args) {
            String str1 = "abcd";
            String str2 = "Abcd";
            System.out.println(str1.compareTo(str2));
        }
    

    运行时结果
    在这里插入图片描述
    在这里插入图片描述
    掌握了字符串比较相等的方法,下来我们来做一道练习题


    比较字符串是否相等
    在这里插入图片描述


    题解思路:


      将word1 字符串数组的内容都在str1 追加,word2 字符串数组的内容在str2 追加,最终equals 比较str1 str2 字符串的内容,相等返回 true,不等返回 false.

    注意:参数等问题要考虑全面

    在这里插入图片描述

    在这里插入图片描述


    (2)字符串查找


      从一个完整的字符串之中可以判断指定内容是否存在,对于查找方法有如下定义:

    在这里插入图片描述

    判断一个字符串中是否存在子字符串
    在这里插入图片描述


    我们可以先看一下 contains 方法的源码

    在这里插入图片描述
    contains 方法的使用

     public static void main(String[] args) {
           String str = "bcdabc";
           boolean flg = str.contains("abc");
            System.out.println(flg);
        }
    

    运行结果

    在这里插入图片描述

    所以可判断在"badabc" 这个字符串中存在 这个 “abc” 的子字符串。


    找到子字符串的下标
    在这里插入图片描述


    我们先来看一下一个参数的 index 方法的源码

    在这里插入图片描述

    带一个参数的 index 方法的使用


        public static void main(String[] args) {
            String str = "ababcabcdabcde";
            int index1 = str.indexOf("abc");
            int index2 = str.indexOf("hello");
            System.out.println(index1);
            System.out.println("============");
            System.out.println(index2);
        }
    

    运行结果:

    在这里插入图片描述

    两个参数的index 方法的使用
    在这里插入图片描述


      在下面我们又看到了一个index 方法,这说明 默认情况下,index 是从0下标开始查找的,如果再给他一个下标参数,那么就从指定的下标位置进行字符串查找。


    使用:

     public static void main(String[] args) {
            String str = "abcabcdabcdef";
            int index1 = str.indexOf("abc");
            int index2 = str.indexOf("abc",6);
            System.out.println(index1);
            System.out.println("=================");
            System.out.println(index2);
        }
    

    运行结果:

    在这里插入图片描述

    从后往前查找到子字符串的位置
    在这里插入图片描述


    lastIndexOf 是从后向前查找 子字符串的位置

    lastIndexOf 方法的使用

     public static void main(String[] args) {
            String str = "abcabcdabcdef";
            int index = str.lastIndexOf("abc");
            System.out.println(index);
        }
    

    运行结果:

    在这里插入图片描述
      同时 lastIndexOf 也有两个参数的方法,从指定下标开始从后向前进行查找。

    判断是否由 参数字符串开头的
    在这里插入图片描述
    同时也有两个参数的方法,从指定位置判断是否由 指定字符串开头
    在这里插入图片描述


    判断是否由指定字符串进行结尾的
    在这里插入图片描述


    (3)字符串替换

    在这里插入图片描述

    (1)替换所有的指定内容
    在这里插入图片描述

    replaceAll 的使用

     public static void main(String[] args) {
            String str = "abcabcacbabc";
            System.out.println(str);
            System.out.println("=================");
            String ret = str.replaceAll("ab","AB");
            System.out.println(ret);
        }
    

    运行结果:

    在这里插入图片描述


    成功的把所有的 “ab” 替换成为 “AB”.


    (2)替换首个要替换的内容.
    在这里插入图片描述

    replaceFirst 的使用

     public static void main(String[] args) {
            String str = "abcabcacbabc";
            System.out.println(str);
            System.out.println("=================");
            String ret = str.replaceFirst("ab","AB");
            System.out.println(ret);
        }
    

    运行结果:

    在这里插入图片描述

    注意说明:

      由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.


    (4)字符串拆分


      可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

    在这里插入图片描述

    1.将字符串全部拆分
    在这里插入图片描述


      接收的类型是字符串数组类型,传参数时,传一个我们想要分割的符号。


    split 的使用

      public static void main(String[] args) {
            String str = "rain7 is cool";
            String[] strs = str.split(" ");
            for (String s:strs) {
                System.out.println(s);
            }
        }
    

      我们在用 split 方法时, 以 空格 为分割符,将我们的str 字符串 进行拆分


    我们来看拆分的效果

    在这里插入图片描述

    2.带两个参数的split 方法
    在这里插入图片描述


    还是以上面的字符串为例

       public static void main(String[] args) {
            String str = "rain7 is cool";
            String[] strs = str.split(" ",2);
            for (String s:strs) {
                System.out.println(s);
            }
        }
    

    运行结果:
    在这里插入图片描述

      我们除了将字符串作为参数,还将limit 设置为2,那么拆分后的数组长度就为2,所以运行结果就如上所示。


    难点

      拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义字符


    示例1

    拆分 IP 地址

    比如说我们要分割IP 地址,192.168.1.1,以 “.” 分割。

    当我们运行时会发现 打印为空,这是为什么呢?

    有些符号比较特殊,必须用到转义字符

    “ \. ”才能表示一个真正的 “.” 
    
    同时"\"也需要进行转义,那么就又要再加一个斜杠。
    
    “\\.”这时字符串才只能被 “ . ”分割。
    
    public static void main(String[] args) {
            String str = "192.168.1.1";
            String[] strs = str.split("\\.");
            for (String s:strs) {
                System.out.println(s);
            }
        }
    

    运行结果

    在这里插入图片描述

    1. 字符"|","*","+"都得加上转义字符,前面加上"\\".
    2. 而如果是"\",那么就得写成"\\".
    3. 如果一个字符串中有多个分隔符,可以用"|"作为连字符.
    

    连字符 “ | ” 的使用

     public static void main(String[] args) {
            String str = "1212@qq.com";
            String[] ret = str.split("@|\\.");
            for (String s:ret) {
                System.out.println(s);
            }
        }
    

    运行结果:

    在这里插入图片描述


    我们来一道练习题:

    在这里插入图片描述

    代码题解:

     public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            while(scanner.hasNext()){
                String ret ="";
                String str = scanner.nextLine();
                String[] strs = str.split(" ");
                for (String s:strs) {
                    ret += s;
                }
    
                System.out.println(ret);
            }
        }
    

    运行结果:

    在这里插入图片描述

    注意:

    1.注意多组输入
    2.不建议在for循环中拼接字符串,在之后讲到的StringBuilder StringBuffer 之后可以知道如何拼接。

    (5)字符串截取

    从一个完整的字符串之中截取出部分内容。可用方法如下:

    在这里插入图片描述

    1.从指定下标截取到字符串结束
    在这里插入图片描述

    方法的使用

     public static void main(String[] args) {
            String str = "ilikeBeijing";
            String ret = str.substring(4);
            System.out.println(ret);
        }
    

    运行结果:

    在这里插入图片描述

    2.带有两个参数的subString 方法,截取指定下标范围内的字符串内容
    在这里插入图片描述

    方法的使用

     public static void main(String[] args) {
            String str = "HelloWorld";
            String ret = str.substring(4,9);
            System.out.println(ret);
        }
    
    

    运行结果

    在这里插入图片描述
    注意:

    1.指定下标范围 是 左闭右开的区间

    2.截取后的字符串是一个新的对象

    (6)其他操作方法

    字符串操作还有很多其他的方法,在这里我们只进行简单介绍。

    在这里插入图片描述

    (7)字符串操作练习题


    1.逆置字符串


    题目要求

    将字符串进行整体逆置


    代码题解:

       public static String reverse(String s){
            if(s==null){
                return null;
            }
    
            int begun = 0;
            int end = s.length()-1;
            char[] chars = s.toCharArray();
            while(begun<end){
                char tmp = chars[begun] ;
                chars [begun] = chars [end];
                chars[end] = tmp;
                begun++;
                end--;
            }
            return new String(chars);
        }
    
    
        public static void main(String[] args) {
            String str = "Hello World!";
            String ret = reverse(str);
            System.out.println(ret);
        }
    
    

    运行结果:
    在这里插入图片描述


    成功的将字符串进行逆置


    2.翻转字符串

    在这里插入图片描述


      我们首先对题目进行一下解读,我们要实现一个方法,给这个方法传入 一个字符串和一个 整数 size 。将大小为 size 的左半区 翻转到 右半区。如图所示:


    在这里插入图片描述


    思路实现:

    1.首先将size 左半区进行单独逆置。

    2.再将 size的右半区单独逆置。

    3.整体字符串进行逆置。

    在这里插入图片描述

    代码展示:

     public static String reverse(String s,int begun,int end){
            if(s==null){
                return null;
            }
    
            char[] chars = s.toCharArray();
            while(begun<end){
                char tmp = chars[begun] ;
                chars [begun] = chars [end];
                chars[end] = tmp;
                begun++;
                end--;
            }
            return new String(chars);
        }
    
        public static String reversSentence(String str,int k){
            str = reverse(str,0,k-1);
            str = reverse(str,k,str.length()-1);
            str = reverse(str,0,str.length()-1);
    
            return str;
        }
    
        public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
           String str = scanner.next();
           int n = scanner.nextInt();
           String ret = reversSentence(str,n);
            System.out.println(ret);
        }
    

    运行结果:

    在这里插入图片描述

    八、StringBuffer 和 StringBuilder


      StringBuffer 和 StringBuilder 又是一种新的字符串类型。

      通常来讲String的操作比较简单,但是由于String的不可更改特性,为了方便字符串的修改,提供 StringBuffer 和 StringBuilder 类。

      StringBuffer 和 StringBuilder 在功能上大部分是相同的,在这里我们着重介绍 StringBuffer.


    (1)append 方法


      在String中使用"+"来进行字符串连接,但是这个操作在StringBuffer类中需要更改为append()方法。


      String和StringBuffer最大的区别在于:String的内容无法修改,而StringBuffer的内容可以修改。频繁修改字符串的情况考虑使用 StingBuffer。


     public static void main(String[] args) {
            StringBuffer sb = new StringBuffer();
            sb.append("a");
            sb.append("b");
            sb.append("c");
            System.out.println(sb);
        }
    

    运行结果:

    在这里插入图片描述
    我们来看一下 StringBuffer 的 append 方法的源码

    在这里插入图片描述
      最后返回的是 this,在字符串本身拼接字符串。同时StringBuffer 有自己重写的 toString 方法,可以直接进行打印。

    我们来看一下 以下的代码:

      public static void main(String[] args) {
           String str1 = "abc";
           String str2 = "def";
           String str3 = str1+str2;
           System.out.println(str3);
    
        }
    

    我们对以上代码进行编译一下:

    在这里插入图片描述
    在编译的过程中,我们发现StringBuilder.append 方法的出现;


    我们将这个过程用 StringBuilder 写一下:

       public static void main(String[] args) {
            String str1 ="abc";
            String str2 = "def";
            StringBuilder sb = new StringBuilder();
            sb.append(str1);
            sb.append(str2);
            String str3 = sb.toString();
            System.out.println(str3);
        }
    

    说明:

      String 的“+” 拼接,会被底层优化为一个 StringBuilder ,拼接的时候会用到 append 方法


    (2)注意


    注意:  String和StringBuffer类不能直接转换。如果要想互相转换,可以采用如下原则:

      String变为StringBuffer:利用StringBuffer的构造方法或append()方法
      StringBuffer变为String:调用toString()方法。

      除了append()方法外,StringBuffer也有一些String类没有的方法:


    字符串反转:

    public synchronized StringBuffer reverse();
    

    (3)区别


    String 和 StringBuilder 及 StringBuffer 的区别

    String 进行拼接时,底层会被优化为StringBuilder

    String的拼接会产生临时对象,但是后两者每次都只是返回当前对象的引用。

    String的内容不可修改,StringBuffer与StringBuilder的内容可以修改.


    StringBuilder 和 StringBuffer 的区别

    我们来看一下这两个类的 append 方法

    在这里插入图片描述


    所以 StringBuffer 和 StringBuilder 的区别主要体现在线程安全上 。


    1.StringBuffer与StringBuilder大部分功能是相似的

    2.StringBuffer采用同步处理,属于线程安全操作;而StringBuilder未采用同步处理,属于线程不安全操作


      字符串操作是我们以后工作中非常常用的操作. 使用起来都非常简单方便, 我们一定要使用熟练.


      好了今天的知识就分享到这里,希望大家多多练习,熟练掌握,感谢大家的欣赏与关注!!


    谢谢欣赏!



    Java基础语法(十)——认识异常 已更新,希望大家多多关注哦!



    完!

    展开全文
  • String类详解

    万次阅读 多人点赞 2019-04-03 22:33:18
    1.String类:即字符串类,其主要构造方法为:  String(String Original),把字符串封装成字符串对象;  举例:String s1 = new String(“hello”);  String(char[] value),把字符数组的数据封装成字符串对象;  ...

    一、基本内容:
    1.String类:即字符串类,其主要构造方法为:
     String(String Original),把字符串封装成字符串对象;
     举例:String s1 = new String(“hello”);
     String(char[] value),把字符数组的数据封装成字符串对象;
     举例:char[] chs = {‘h’,‘e’,‘l’,‘l’,‘o’};   
        String s2 = new String(chs);
     String(char[] value,int index, int count),从索引index开始把count个字符数组值封装成字符串对象。
     举例:char[] chs = {‘h’,‘e’,‘l’,‘l’,‘o’}; 
        String s3 = new String(chs,1,3);
     最为简单的一种方法是直接构造法:
     举例:String s4 = “hello”;
    2.new创建与直接赋值:针对创建的String类的对象,通过构造方法创建的String对象,存放在java虚拟机的堆内存,堆内存里存放的是字符串常量的地址,字符串常量存放在方法区的常量池中;通过直接赋值所创建的对象直接是方法区中的常量池中的字符串常量。而语句(s1==s2)是比较s1和s2中存放的地址,显然不相同,但是s2和s3的地址相同,则会得到true结果。其示意图如下图所示:
    在这里插入图片描述
    3.String类的判断功能:
    Object类:是类层次结构的根类,所有的类都直接或者间接继承自Object类;
    如果一个方法的形参是Object,那么这里我们就可以传递Object类的任意子类对象;

    boolean equals(Object obj):比较字符串的内容是否相同(区分大小写);
    boolean equalsIgnoreCase(String str):比较字符串的内容是否相同(忽略大小写);
    boolean startsWith(String str):判断字符对象是否以指定的str开头;
    boolean endsWith(String str):判断字符对象是否以指定的str结尾;

    4.String类运用举例(模拟用户登录):

    public class UserLogin {
    	public static void main(String [] args) {
    		String username = "hxf1688";
    		String password = "2e5y8hxf";
    		
    		for(int i=0; i < 3; i++) {
    			Scanner sc = new Scanner(System.in);      //创建sc为输入类
    			System.out.println("请输入用户名:");
    			String user = sc.nextLine();
    			System.out.println("请输入密码:");
    			String psw = sc.nextLine();
    			if(username.equals(user)&&password.equals(psw)) {
    				System.out.println("登录成功");
    				break;
    			}
    			else {
    				if(i==2) {
    					System.out.println("您输入错误次数过多,请联系管理员");
    				}
    				else {
    					System.out.println("输入失败,您还有"+(2-i)+"尝试机会");
    				}
    
    			}
    		}
    	}
    }
    

    Scanner类
    在这里插入图片描述

    nextLine()方法
    在这里插入图片描述
    5.String类的获取功能:
    int length():获取字符串的长度,也即字符个数;
    char charAt(int index):获取指定索引处的字符;
    int indexOf(String str):获取字符串str在字符串对象中出现的位置索引,返回str的第一个字符的索引位置;
    String substring(int start):从索引start处开始截取字符串,一直到结尾;
    String substring(int start, int end):从索引start(包括start)开始截取字符串,到end(不包括end)结束。

    6.字符串的遍历:

    for(int i=0; i < str.length() ;i++){   //注意这里使用的是str.length(),这是String类中的方法,若str为数组,则使用str.length,这里的length为属性
        System.out.println(i);
    }
    

    7.统计字符串中大写字符、小写字符、数字字符的个数:
    由于英文字母不论大小写和数字,从小到大都有一定顺序,比如统计大写字符,只需判断:ch >= ‘A’ && ch <= ‘Z’,即可。

    8.String类的转换功能(将String类转换为字符数组、大小写的转换):
    char[] toCharArray(): 把字符串转换为字符数组;
    String toLowerCase(): 把字符串转换为小写字符;
    String toUpperCase():把字符串转换为大写字符;

    练习:将输入的字符串首字母大写,其余为小写!
    解题思路:利用字符串截取的方法substring(int start, int end),将首字母与其余字母分别截取到两个字符串中,再将两个字符串拼接。

    Scanner sc = new Scanner(System.in);
    String str = sc.nextLine();
    s1 = substring(0,1);
    s2 = substring(1);
    s3 = s1 + s2;
    

    9.String类的去空格和按照指定符号分割功能:
    String trim(): 去除字符串两端空格;
    String[] split(String str): 按照指定符号分割字符串;
    举例:

    String s1 = "aa,bb,cc";
    		String[] ArrayStr = s1.split("bb");
    		for(int i=0; i < ArrayStr.length; i++) {
    			System.out.println(ArrayStr[i]);
    		}
    

    结果:
    aa,
    ,cc

    10.字符串的反转:
    例如:输入abc,输出cba;
    解法一:将字符串倒着遍历,再将得到的字符拼接成字符串;
    解法二:把字符串转换为字符数组,再将字符数组进行反转,再将字符数组转换成字符串;

    public static String reverse(String s){     //解法一倒着遍历法
        String ss = "";
        for(int x = length-1; x > 0; x--){
            ss += charAt(x);
        }
        return ss;
    }
    
    public static String reverse(String s){
         char[] str = s.toCharArray();   //将字符串转换成字符数组
         for(int start = 0,int end = length - 1; start <= end ; start++, end--){   //逐个进行首尾交换
             char temp = str[start];
             str[start] = str[end];
             str[end] = temp;
        }
        
        String ss = new String(str);  //通过创建对象的方式把字符数组转换成字符串
        return ss;
    }
    

    11.数组元素按指示格式拼接:
    举例:输入:int [] = {1,2,3}; 输出:[1,2,3]

    public static String arrayToString(int[] arr){
        String s = "";
        s += '[';       //这里的s += '['也可以使用s += "[",单引号和双引号均可
        for(int x=0; x < arr.length; x++){
            if(x == arr.length - 1){
                s += arr[x];
            }
            else {
                s += arr[x];   //字符串拼接也可以将int型数据拼接成字符串;
                s += ", ";
            }
        }
        s += ']';
        return s;
    }
    

    12.StringBuilder类的概述:
    (1)虚拟机角度描述:首先,我们实例化一个String类的字符串对象s,让其存储字符串“hello”,这时s存储的是“hello”的地址(假设在常量池中的地址为001),这时我们运行代码s += “world”,此时“world”会存储在常量池中的地址为002,而字符串“helloworld”则会存储在常量池中的地址003中,并且此时对象s存储的地址为003,即“helloworld”的地址,而此时001和002地址中的常量就浪费了,使用StringBuilder类可以避免拼接字符串时造成的资源浪费这个问题
    在这里插入图片描述
    (2)StringBuilder类基本属性描述:
    String类与StringBuilder类的区别:String类的内容是固定的,StringBuilder类的内容是可变的。

    构造方法
    StringBuilder() : 构造一个不带任何字符的字符串生成器,其初始容量为 16 个字符。
    StringBuilder(String str) : 构造一个字符串生成器,并初始化为指定的字符串内容,这里如果入参为“helloworld”,则其容量变为16+10 = 26。

    成员方法
    public int capacity():返回当前容量。
    public int length():返回长度(字符数)。
    注意:容量为理论值,长度为实际值。

    (3)StringBuilder类的添加方法和反转方法:
    添加方法: public StringBuilder append(任意类型)

    StringBuilder s1 = StringBuilder(hello);
    s2 = s1.append("world");
    (s1 == s2)    //结果为true
    

    说明s1的内容是可变的,s1和s2指向同一片地址,该地址存储的内容是可变的,从hello变成“helloword”.

    另外,append可以将任意类型的值变为字符串:

    s1.append("hello");
    s1.append("world");
    s1.append(true);
    s1.append(100);
    //输出结果为:helloworldtrue100
    
    s1.append("hello").append("world").append(true).append(100);     //链式编程
    //因为append返回的是StringBuilder对象,所以可以连续调用append成员方法,输出结果和上面一样。
    

    反转方法
    public StringBuilder reverse();
    s1.reverse();
    输入:helloworldtrue100
    输出:001eurtdleodolleh

    (4)StringBuilder类的对象和String类的对象之间相互转化:
    StringBuilder转String:StringBuilder类中有一个成员方法为toString()

    StringBuilder s1 = new StringBuilder("hello");
    String s2 = s1.toString();
    

    String转StringBuilder:直接利用StringBuilder类的构造方法StringBuilder(String str)

    String s1 = "hello";
    StringBuilder s2 = new StringBuilder(s1);
    

    (5)练习:数组按照格式拼接成字符串:

    public String arrayToString(int[] arr){
         StringBuilder s1 = new StringBuilder();
         s1.append("[");
         for(int i=0; i < arr.length; i++){
             if(i == arr.length - 1){
                 s1.append(arr[i]);
             }
             else {
                 s1.append(arr[i]).append(", ");
             }
         }
         s1.append("]");
         String result = s1.toString();
         return result;
    }
    

    (6)练习:利用StringBuilder进行字符串反转:

    public String toReverse(String s){
        StringBuilder s1 = new StringBuilder(s);     //首先将String类对象转换成StringBuilder类对象
        s1.reverse();               //使用reverse方法
        String s2 = s1.toString();    //再将StringBuilder转换成String类对象
    }
    

    (7)练习:利用StringBuilder进行对称字符串判断:

    public boolean isSymmetry(String s){         //若字符串反转前等于反转后,则认为两个字符串对称
         StringBuilder s1 = new StringBuilder(s);
         s1.reverse();
         String result = s1.toString();
         return s.equals(result);
    }
    
    展开全文
  • Java基础系列24-常用api之String类

    万次阅读 2021-08-24 14:35:14
    文章目录一.String类概述二.String类案例2.1 String类4种常用构造方法2.2 String类创建对象两种方式2.3 String类练习之模拟用户登录2.4 String类遍历字符串2.5 String类字符串拼接2.6 String类字符串反转参考: ...

    一.String类概述

    String类概述:
    通过JDK提供的API,查看String类的说明

    1. "abc"是String类的一个实例,或者成为String类的一个对象
    2. 字符串字面值"abc"也可以看成是一个字符串对象
    3. 字符串是常量,一旦被赋值,就不能被改变
    4. 字符串本质是一个字符数组

    String类的构造方法:

    1. String(String original):把字符串数据封装成字符串对象
    2. String(char[] value):把字符数组的数据封装成字符串对象
    3. String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象

    String类 api文档:
    image.png

    二.String类案例

    2.1 String类4种常用构造方法

    String的构造方法:
      方式1. String(String original):把字符串数据封装成字符串对象
      方式2. String(char[] value):把字符数组的数据封装成字符串对象
      方式3. String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
      方式4. String():最常用的 API中表示(Java程序中所有字符串字面值 如“abc”都作为此类的实例实现)

    public String toString():返回此对象本身(它已经是一个字符串!)。

    代码:

    package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-30
     * @remark  String类4种常用构造方法
     *
     */
    public class string1 {
    	public static void main(String[] args) {
    		//方式1. String(String original):把字符串数据封装成字符串对象
    		String s1 = new String("hello1");
    		/*如果打印的不是 包名+类名+@+地址 则表示String类重写了toString方法*/
    		System.out.println(s1);//hello1
    		System.out.println("------");
    		
    		//方式2. String(char[] value):把字符数组的数据封装成字符串对象
    		char[] value2 = {'h','e','l','l','o','2'};
    		String s2 = new String(value2);
    		System.out.println(s2);//hello2
    		System.out.println("------");
    		
    		 //方式3. String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
    		char[] value3 = {'h','e','l','l','o','3','3','3'};
    		String s3 = new String(value3, 0, value3.length - 2);
    		System.out.println(s3);//hello3
    		System.out.println("------");
    		
    		//方式4. String():最常用的
    		String s4 = "hello4";
    		System.out.println(s4);
    		System.out.println("------");
    	}
    
    }
    

    测试记录:

    hello1
    ------
    hello2
    ------
    hello3
    ------
    hello4
    ------
    

    2.2 String类创建对象两种方式

    String类创建对象的特点:
      A:通过构造方法创建对象
      B:通过直接赋值的方式创建对象

    这两种方式的创建是有区别的:
      1.通过构造方法创建的字符串对象是在堆内存。
      2.通过直接赋值的方式创建的字符串对象是在方法区的常量池。

    内存图:
    image.png

    代码:

    package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-30
     * @remark  String创建对象的两种方式
     *
     */
    public class string2 {
    	public static void main(String[] args) {
    		String s1 = new String("hello");
    		String s2 = new String("hello");
    		
    		String s3 = "hello";
    		String s4 = "hello";
    		
    		System.out.println(s1 == s2);//false
    		System.out.println(s1 == s3);//false
    		System.out.println(s3 == s4);//true
    	}
    
    }
    

    测试记录

    false
    false
    true
    

    2.3 String类练习之模拟用户登录

    需求:
      模拟登录,给三次机会,并提示还有几次

    分析:
      A:定义两个字符串对象,用于存储已经存在的用户名和密码
      B:键盘录入用户名和密码
      C:拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
        如果内容相同,就提示登录成功
        如果内容不同,就提示登录失败,并提示还有几次机会
        public boolean equals(Object anObject):比较字符串的内容,严格区分大小写(用户名和密码)
        public boolean equalsIgnoreCase(String anotherString):比较字符串的内容,不考虑大小写(验证码)
    image.png

    代码:

    package Java_study;
    
    import java.util.Scanner;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-30
     * @remark  String类练习之模拟用户登录
     *
     */
    public class string3 {
    	public static void main(String[] args) {
    		//定义两个字符串对象,用于存储已经存在的用户名和密码
    		String username = "admin";
    		String password = "admin";
    		
    		//循环次数
    		int count = 0;
    		//键盘录入的用户名
    		String scName;
    		//键盘录入的密码
    		String scPassword;
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in);
    		
    		//模拟登陆,给三次机会
    		while (count < 3) {
    			System.out.println("请输入用户名:");
    			scName = sc.nextLine();
    			System.out.println("请输入密码");
    			scPassword = sc.nextLine();
    			
    			//事件A: 用户名相等
    			boolean a = scName.equals(username);
    			//事件B:密码相等
    			boolean b = scPassword.equals(password);
    			//事件C: 错误次数小于3
    			boolean c = count < 2;
    			if (a && b) {
    				System.out.println("登陆成功");
    				break;
    				//用户名或密码任意一个不低,且登录次数小于3,提示次数,并重新输入
    			} else if (c) {
    				System.out.println("登陆失败,你还有" + (2 - count) + "次机会");
    				//用户名或密码任意一个不对,且登录次数大于3,锁定账号,并跳出循环
    			} else {
    				System.out.println("你的账号被锁定,请与管理员联系");
    				break;
    			}
    			
    			//每次循环次数加1
    			count++;
    			 
    		}
    	}
    
    }
    
    

    测试记录:

    请输入用户名:
    admin
    请输入密码
    abc
    登陆失败,你还有2次机会
    请输入用户名:
    
    请输入密码
    
    登陆失败,你还有1次机会
    请输入用户名:
    admin
    请输入密码
    admin
    登陆成功
    
    

    2.4 String类遍历字符串

    需求:
      遍历字符串(获取字符串中的每一个字符)

    public char charAt(int index):
      返回指定索引处的值

    public int length():
      返回字符串中的字符个数,字符串的长度

    image.png
    image.png

    代码:

    package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-30
     * @remark  INDEX_STATISTICS
     */
    public class string4 {
    	public static void main(String[] args) {
    		//要遍历字符串,你首先得有一个字符串
    		String s = "abcde";
    		
    		//思考:如何获取字符串中的每一个字符
            //假如让我们来提供方法,我们应该提供一个根据索引返回指定位置的字符的方法
            //返回值:char
            //形式参数:int index
            //public char charAt(int index):返回指定索引处的值
            //原始做法
    		System.out.println(s.charAt(0));
    		System.out.println(s.charAt(1));
    		System.out.println(s.charAt(2));
    		System.out.println(s.charAt(3));
    		System.out.println(s.charAt(4));
    		System.out.println("----------");
    		
    		//用for循环改进
    		for (int i = 0; i < s.length(); i++) {
    			System.out.println(s.charAt(i));
    		}
    		System.out.println("----------");
    		
    		
    
    		
    	}
    
    }
    

    测试记录:

    a
    b
    c
    d
    e
    ----------
    a
    b
    c
    d
    e
    ----------
    

    2.5 String类字符串拼接

    需求:
    把数组中的数据按照指定个格式拼接成一个字符串

    举例:int[] arr = {1,2,3};
    输出结果:[1, 2, 3]

    分析:
    A:定义一个int类型的数组
    B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
    C:调用方法
    D:输出结果

    代码:

    package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-30
     * @remark  String类字符串拼接
     *
     */
    public class string5 {
    	public static void main(String[] args) {
    		//定义一个int类型的数组
    		int[] arr = {1,2,3};
    		
    		String result = arrayToString(arr);
    		
    		System.out.print(result);
    	}
    	
    	public static String arrayToString(int[] arr) {
    		String s = "[";
    		for (int i = 0; i < arr.length; i++) {
    			s += arr[i];
    			//如果不是最后一个元素,则再拼个逗号 ,
    			if (i != arr.length - 1) {
    				s += ",";
    				//如果是最后一个元素,则再拼个右括号 ]
    			} else {
    				s += "]";
    			}
    		}
    		return s;
    	}
    
    }
    

    测试记录:

    [1,2,3]
    

    2.6 String类字符串反转

    需求:
    字符串反转

    举例:键盘录入”abc”
    输出结果:”cba”

    分析:
     A:键盘录入字符串数据
     B:写方法实现字符串数据的反转
      把字符串倒着遍历,在把每一个得到的字符拼接成一个字符串
     C:调用方法
     D:输出结果

    代码:

    package Java_study;
    import java.util.Scanner;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-30
     * @remark  String类字符串反转
     *
     */
    public class string6 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个字符串:");
    		String s = sc.nextLine();
    		//写方法实现字符串数据的翻转
    		
    		//调用方法
    		String result = reverse(s);
    		
    		//输出结果
    		System.out.println(result);
    	}
    	
    	public static String reverse(String source) {
    		String result = "";
    		//反向for循环
    		for (int i = source.length() - 1; i >= 0; i--) {
    			result += source.charAt(i);
    		}
    		return result;
    	}
    
    }
    

    测试记录:

    请输入一个字符串:
    adefesefaae
    eaafesefeda!QAZxsw2
    
    

    参考:

    1. https://blog.csdn.net/qq_43529621/article/details/115379095
    展开全文
  • 深入理解Java String类

    万次阅读 多人点赞 2018-06-28 21:15:55
    在Java语言了中,所有类似“ABC”的字面值,都是String类的实例;String类位于java.lang包下,是Java语言的核心类,提供了字符串的比较、查找、截取、大小写转换等操作;Java语言为“+”连接符(字符串连接符)以及...
  • C++——String类超详细介绍

    万次阅读 多人点赞 2019-06-01 17:32:56
    STL的含义:标准模板库 STL的内容: 容器:数据的仓库 算法:与数据结构相关的算法、通用的算法(和数据结构无关) ...string: array:C11静态顺序表 vector:动态顺序表 list:带头节点的双向循环链表 ...
  • Java基础类(四):String类

    万次阅读 多人点赞 2021-01-10 00:08:53
    String类里面常用的20个方法 和长度有关的方法 返回类型 方法名 作用 int length() 得到一个字符串的字符个数(一个中文是一个字符,一个英文是一个字符,一个转义字符是一个字符) 和数组有关的方法 返回类型 ...
  • C++string类常用方法

    万次阅读 多人点赞 2020-10-09 15:34:26
    C++string类常用方法 1、string(const char *s) :将 string 对象初始化为 s 指向的字符串 string str("hello"); 2、string(size_type n,char c) :创建一个包含 n 个元素的 string 对象,其中每个元素都被初始化为...
  • java String类(超详细!)

    万次阅读 多人点赞 2021-04-30 20:00:51
    1、String表示字符串类型,属于 引用数据类型,不属于基本数据类型。 2、在java中随便使用 双引号括起来 的都是String对象。 例如:“abc”,“def”,“hello world!”,这是3个String对象。 3、java中规定,双...
  • 模拟实现string类

    千次阅读 多人点赞 2022-03-10 08:43:53
    由于string类的接口函数很多,所以这里只实现常用的接口函数 部分很简单的接口函数,都放在代码段里了 一、初始准备 引用头文件 引用string的头文件,是为了后面写接口函数,需要调用字符串函数,比如strstr,...
  • String类介绍

    千次阅读 多人点赞 2018-09-17 01:09:42
    一、String类介绍:  String是一个引用数据类型默认为null;  String 为final类型不可更改,不能被继承;  基本类型与String结合都会转换为String类型; 二、String两种赋值方式: 1)直接赋值:String str = ...
  • C++中的string类用法简介

    万次阅读 多人点赞 2019-08-21 17:21:17
    本文主要介绍C++中的string类的常见用法。 1. 概述 string是C++标准库的一个重要的部分,主要用于字符串处理。可以使用输入输出流方式直接进行string操作,也可以通过文件等手段进行string操作。同时,C++的算法库...
  • 日常开发中,String类中常用的方法

    万次阅读 多人点赞 2019-01-11 14:54:24
    // 把字符数组中的一部分数据封装成字符串对象 String(char[] value, int index, int count) 二、String类的获取功能: length():获取字符串的长度,其实也就是字符个数 String str = "adsfaxsdfas沙发上案发地方";...
  • String类的常见问题

    千次阅读 2021-03-17 22:29:24
    String类的常见面试题 1.判定定义为String类型的两个对象是否相等(1) public class StringDemo01 { public static void main(String[] args) { String string01 = "zrt"; String string02 = "zrt"; System.out...
  • Java中String类的几个常用方法

    千次阅读 多人点赞 2020-07-13 15:16:05
    关于String中的常用方法: (1)public String toString() 这个方法就不用说了,字符串本身就是字符串,返回本身。 测试代码: System.out.println("abc".toString()); //输出:abc (2)public char charAt(int ...
  • string类的常用函数(总结)

    千次阅读 多人点赞 2020-10-07 21:14:15
    string类常用成员函数 (1)求长度 int length(); int size(); //求长度 (2)比较2个字符串 strcmp(s1,s2) == 0 直接用运算符 < > = = != <= >= (3)字符串复制 strcpy(s1,s2); s2->s1 可直接用运算符 ...
  • Android-String类

    千次阅读 2019-02-17 13:38:24
    String类创建的字符串对象是不可修改的,也就是说,String字符串不能修改、删除或者替换字符中的某个字符,即String对象一旦创建,那么实体是不可以发生变化的,例如: String s = new String(“我喜欢散步”) String...
  • String类的常用方法总结

    千次阅读 多人点赞 2019-02-24 19:20:51
    Java中的String类是字符串操作类,提供了多种方法对字符串进行操作,以下对String类的常用方法进行总结: 一、String类简介 String类位于Java的lang包下,在使用时不需要通过import引入,java使用String类创建一个...
  • String类常用方法

    千次阅读 2020-04-28 14:07:35
    String类的常用方法1 获取。1.1 字符串中的包含的字符数,也就是字符串的长度。1.2 根据位置获取位置上某个字符。1.3 根据字符获取该字符在字符串中位置。2 判断。2.1 字符串中是否包含某一个子串。2.2 字符中是否有...
  • java--String类常用方法大全

    千次阅读 多人点赞 2019-04-05 21:36:18
    java–String类常用方法大全 1.字符串的替换    1. replace() public static void main(String[] args) { String str1 = "hello word"; String str2 = str1.replace("hello", "hi"); ...
  • string类的各种函数用法

    万次阅读 多人点赞 2018-09-14 11:03:22
    标准c++中string类函数介绍   注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作...
  • C++string类的常用方法

    万次阅读 多人点赞 2018-09-01 13:41:14
    在使用string类时,需要包含头文件 #include&lt;string&gt;,并且引入using std::string; using std::wstring; 或 using namespace std; 下面你就可以使用string/wstring了,它们两分别对应着char和wchar_...
  • string 定义在 iostream 头文件中 , 不必引入另外的头文件 ; # include C++ 字符串 对象 创建方法 C++ 字符串 对象 创建方法 : 1.直接赋值 : 直接使用 C 字符串赋值 ; //① ...
  • String类的两种实例化方式

    千次阅读 2021-02-05 13:11:15
    面试常见问题:比较String类的两种实例化方式
  • java中String类的使用详解

    万次阅读 多人点赞 2018-12-19 22:11:35
    String类构造方法 构造方法是用来完成String对象的创建,下图中给出了一部分构造方法需要在API中找到,并能够使用下列构造方法创建对象。 String s1 = new String(); //创建String对象,字符串中没有内容 byte...
  • Java中String类的常用方法

    千次阅读 多人点赞 2019-10-28 14:59:15
    Java中String类的常用方法 1,String类的介绍 String类在java.lang包中,java使用String类创建一个字符串变量,字符串变量属于对象。 String类是所有语言最常用的一个类,用于描述字符串事物。 String类在Java中被...
  • C++string类常用函数 c++中的string常用函数用法总结

    万次阅读 多人点赞 2018-06-02 16:55:42
    string类的构造函数: string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外,string类还支持默认构造函数和复制构造函数,如string s1;string s2="hello";都是...
  • C++ string类的实现

    千次阅读 2018-06-02 13:17:36
    学了C++的重载机制之后,忍不住去探究一下C++中string类的内部实现过程。于是仿照这string类的功能,写了一个自己的string类练练手。可能还有些东西并未完善,后面再不断去完善。参考代码如下所示:Main.cpp[cpp] ...
  • 字符串(System.String类)是 Unicode 字符的有序集合,用于表示文本,即一系列 Unicode 字符。是基本类型中唯一的引用类型。 System.String类有多个构造函数和共享处理方法。不同于旧的VB6.0,System.String类使用...
  • String类的实现

    千次阅读 2018-05-31 22:55:37
    1.常见的面试的时候经常被问到有关string的实现过程,其中包括拷贝构造函数,赋值函数,以及析构函数等,本次如下实现过程加了几个运算符的重载过程。 class String{ friend ostream& operator<< ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,978,307
精华内容 1,991,322
关键字:

string类

友情链接: ACL 2020 论文.rar