精华内容
下载资源
问答
  • C++常见的字符串处理函数

    千次阅读 多人点赞 2019-06-21 21:13:40
    C++常见的字符串处理函数 #include< string > 1. 应用于查找的find()函数

    C++常见的字符串处理函数

    #include< string >

    1. 应用于查找的find()函数

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string str;
        cin>>str;
        //主要字符串是从0开始计数的
        cout<<"ab在str中的位置:"<<str.find("ab")<<endl;
        //返回第一次出现ab的位置,没有则返回一串乱码
        cout<<"ab在str[2]到str[n-1]中的位置:"<<str.find("ab",2)<<endl;
        //返回第一次从str[2]开始出现ab的位置,没有则返回一串乱码
        cout<<"ab在str[0]到str[2]中的位置:"<<str.rfind("ab",2)<<endl;
        //返回ab在str[0]到str[2]中的位置,没有则返回一串乱码
        return 0;
    }
    
    

    输入1

    sdefdwefdadabbababab
    

    输出1

    ab在str中的位置:11
    ab在str[2]到str[n-1]中的位置:11
    ab在str[0]到str[2]中的位置:18446744073709551615
    Program ended with exit code: 0
    

    输入2

    abfeofihwabab
    

    输出2

    ab在str中的位置:0
    ab在str[2]到str[n-1]中的位置:9
    ab在str[0]到str[2]中的位置:0
    Program ended with exit code: 0
    

    输入3

    asdfghjk
    

    输出3

    ab在str中的位置:18446744073709551615
    ab在str[2]到str[n-1]中的位置:18446744073709551615
    ab在str[0]到str[2]中的位置:18446744073709551615
    Program ended with exit code: 0
    

    2. 子串substr()函数

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string str;
        cin>>str;
        cout<<"返回str[3]及其以后的子串:"<<str.substr(3)<<endl;
        //若小于限制长度则报错
        cout<<"从ste[2]开始由四个字符组成的子串:"<<str.substr(2,4)<<endl;
        //若小于限制长度则报错
        return 0;
    }
    
    

    输入1

    asdfghjkl;'/.,mnbvcxz
    

    输出1

    返回str[3]及其以后的子串:fghjkl;'/.,mnbvcxz
    从ste[2]开始由四个字符组成的子串:dfgh
    Program ended with exit code: 0
    

    3. 替换replace()函数

    示列1

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string line = "this@ is@ a test string!";
        line = line.replace(line.find("@"), 1, ""); //从第一个@位置替换第一个@为空
        cout<<line<<endl;
        return 0;
    }
    

    输出

    his is@ a test string!
    Program ended with exit code: 0
    

    示列2

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string line = "this@ is@ a test string!";
        line = line.replace(line.begin(), line.begin()+6, "");  //用str替换从begin位置开始的6个字符
        cout << line << endl;
        return 0;
    }
    
    

    示列3

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string line = "this@ is@ a test string!";
        char* str = "12345";
        line = line.replace(0, 5, str); //用str替换从指定位置0开始长度为5的字符串    
        cout << line << endl;
        return 0;
    }
    
    

    输出

    12345 is@ a test string!
    Program ended with exit code: 0
    

    4. 插入:insert()函数

    #include <string>
    #include <iostream>
    using namespace std;
    int main()
    {
        string str;
        cin>>str;
        cout<<"从2号位置插入字符串jkl并形成新的字符串返回:"<<str.insert(2, "jkl")<<endl;
        return 0;
    }
    
    

    输入

    sdfgh
    

    输出

    从2号位置插入字符串jkl并形成新的字符串返回:sdjklfgh
    Program ended with exit code: 0
    

    5. 添加字符串:append()函数

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string str;
        cin>>str;
        cout<<"在字符串str后面添加字符串ABC:"<<str.append("ABC")<<endl;
        return 0;
    }
    
    

    输入

    diguwhdcow
    

    输出

    在字符串str后面添加字符串ABC:diguwhdcowABC
    Program ended with exit code: 0
    

    6. 交换字符串:swap()函数

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string str1,str2;
        cin>>str1>>str2;
        cout<<"str1:"<<str1<<endl;
        cout<<"str2:"<<str2<<endl;
        swap(str1, str2);
        cout<<"str1:"<<str1<<endl;
        cout<<"str2:"<<str2<<endl;
    }
    
    

    输入

    qwertyui
    asdfghjk
    

    输出

    str1:qwertyui
    str2:asdfghjk
    str1:asdfghjk
    str2:qwertyui
    Program ended with exit code: 0
    

    8. 字符串比较函数:compare()

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string str1,str2;
        cin>>str1>>str2;
        cout<<str1.compare(str2)<<endl;
        return 0;
    }
    

    输入

    diwguc
    aschsdnv
    

    输出

    3
    Program ended with exit code: 0
    

    7. 字符串大小

    size()函数和length()函数

    #include <iostream>
    #include <string>
    using namespace std;
    int main()
    {
        string str1;
        cin>>str1;
        cout<<str1.size()<<endl;
        cout<<str1.length()<<endl;
        return 0;
    }
    
    

    输入

    dchiascnsc
    

    输出

    10
    10
    Program ended with exit code: 0
    

    #include< string.h >

    strcpy(s1,s2)

    复制字符串s2到s1

    strcat(s1,s2)

    连接s2到s1的末尾

    strlen(s1)

    返回字符串s1的长度

    strcmp(s1,s2)

    若s1和s2是相同的,则返回0,s1< s2,返回值小于0,若s1>s2,返回值大于0

    strchr(s1,ch)

    返回一个指针,指向字符串s1中字符ch第一次出现的位置

    strstr(s1,s2)

    返回一个指针,指向字符串s1中字符串s2的第一次出现位置

    memcpy (void *dest, const void *src, int size)

    从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中
    strcpy与memcpy的区别:
    1、复制的内容不同。strcpy只能复制字符串,而memcpy可以复制任意内容,例如字符数组、整型、结构体、类等。
    2、复制的方法不同。strcpy不需要指定长度,它遇到被复制字符的串结束符"\0"才结束,所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
    3、用途不同。通常在复制字符串时用strcpy,而需要复制其他类型数据时则一般用memcpy

    展开全文
  • C语言中常见的字符串处理函数

    万次阅读 多人点赞 2017-01-11 23:50:27
    C语言中常见的字符串处理函数C语言中提供了大量丰富的字符串处理函数,大致可以分为字符串的输入,输出,合并,修改,比较,转换,复制,搜索几类。 用于输入输出的函数包含在stdio.h中而其他的字符串处理函数一般...

    C语言中常见的字符串处理函数

    C语言中提供了大量丰富的字符串处理函数,大致可以分为字符串的输入,输出,合并,修改,比较,转换,复制,搜索几类。
    用于输入输出的函数包含在stdio.h中而其他的字符串处理函数一般包含在string.h中。

    1:字符串的输出函数
    int puts(char const*strPtr);
    输出字符串到显示器中去,传入的实参可以是字符串数组也也可以是字符指针
    一般情况下我们用fputs来代替

    2:字符串的输入函数
    char *gets(char *strptr);
    char *fgets();
    从标准键盘输入一个字符串存放到指针strptr指向的字符数组,一般我们使用fgets来操作

    3:获取字符串的长度
    int strlen(char const*string);
    获取字符串的长度,返回的是字符的个数,但是不会包括’\0’,结束符

    4:字符串拷贝函数
    char *strcpy(char*des,char*src);
    char *strncpy(char *des,char *src,int size);
    将src指向的字符串拷贝到des指向的字符串数组中去,结束符也一同进行拷贝,size参数也可以拷贝制定长度的字符串,建议des为字符数组
    注意:目标尽量使用字符数组,因为如果是字符指针的话,分配的内存在常量池中,是不允许进行改变的,容易造成段错误

    5:字符串的连接函数
    char * strcat(const *char str1,const *char str2);
    char *strncat(const *char str1,const *char str2,int size);
    将str2指向的字符串连接到str1指向的字符后面,同时会删除str1后面的’\0’,返回的是str1指向字符串的首地址重点内容

    6:字符串比较函数
    int strcmp(const char * str1,const char *str2);
    int strncmp(const char*str1,const char *str2,int size);
    按照ascii码来进行比较,并由函数返回值进行判断
    返回0,字符串1等于字符串2,
    大于0,字符串1大于字符串2,
    小于0,字符串1小于字符串2,

    7:字符串分割函数
    char* strtok(char *str,const char *delimiters);
    根据delimiters指向的分割符号,将str指向的字符串分割成若干个子字符串,同时返回的是分割出的子字符串

    8:字符串中是否包含字符
    char * strchr(const char *,int c);//从做往右寻找字符c
    char * strrchr(const char *,int c); //从有往左开始寻找字符c
    判断字符串中是否包含字符串;

    9:内存的初始化
    memset(void *s,int c,size_t n);

    10:内存的拷贝
    memcpy(void *des,void *src ,size_t ,n);

    下面通过案例来演示:

    #include<stdio.h>
    #include<string.h>
    
    
    int main(int argc,char *argv[]){
    
        char str_array[20] = {'\0'};
        //gets(str_array);
        //puts(str_array);
    
        fgets(str_array,sizeof(str_array),stdin);//从标准输入中读入字节数-1个字节的字符
        fputs(str_array,stdout);
    
        char *ptr_string = "helloworld";
        printf("ptr_string len:%d\n",strlen(ptr_string));
    
        printf("==============strcpy==================\n");
        char str_array2[20] = {'\0'};
        strcpy(str_array2,ptr_string);
        printf("str_array2:%s\n",str_array2);
        printf("---------------------------\n");
    
        char str_array3[10] = {"1234567890"};
        strncpy(str_array3,ptr_string,7);//将ptr_str的前7位拷贝进去
        printf("str_array3:%s\n",str_array3);
    
        printf("===============strcmp===============\n");
    
        char *ptr_string_1 = "helloworld";
        char *ptr_string_2 = "helloworld";
    
        printf("value:%d\n",strcmp(ptr_string_1,ptr_string_2));//等于0相等,大于零,即前一个大于后一个,小于0,前一个小于后一个,按ascii码比较
        char *ptr_string_3 = "nuli";
        printf("value:%d\n",strcmp(ptr_string_3,ptr_string_2));
    
        printf("=============strcat=================\n");
        char str_array4[10] = "hello";
        strcat(str_array4,str_array3);
        printf("str_array4:%s\n",str_array4);
    
        printf("============strchr=================\n");//判断字符串中是否包含字符,返回的是这个字符的指针(从左往右边)
        char *ptr_string_4 = strchr(str_array4,'l');
        printf("ptr_string4:%s,%c\n",ptr_string_4,*ptr_string_4);
    
        char *ptr_string_5 = strrchr(str_array4,'l');//从右往左寻找
        printf("ptr_string4:%s,%c\n",ptr_string_5,*ptr_string_5);
    
        if(strchr(ptr_string_5,'o')!=NULL){
            printf("ptr_string_5 contains o!\n");
        }else{
            printf("ptr_string_5 not contains o!\n");
        }
    
        printf("==================strstr===========\n");//字符串中是否包含另外一个字符串
        char *str9 = "hello";
        char *str10 = "first helloworld";
        if(strstr(str10,str9) != NULL){
            printf("str10 contains str9\n");
        }else{
            printf("str10 not contains str9\n");
        }
    
        printf("=================strtok=============\n");
    
        char str[] ="hello:zzf:hello:tom";
        int counter = 0;
        char *p = strtok(str,":");
        while(p!=NULL){
            counter++;
            printf("%s",p);
            p = strtok(NULL,":");
        }
    
        printf("================memset,memcpy==========");//内存清空和拷贝
        char src[] = "i love you";
        char des[] = "you love me";
        memset(des,0,sizeof(des));//清空或者初始化
        memcpy(des,src,sizeof(des)-1);//拷贝des字节数-1,最后一个符号用于存储结束符号
        return 0;
    }
    
    
    谢谢大家访问,代码是可以直接进行run的,由于作者是一个新Coder,所以如果大家有什么指点的地方,欢迎留言或私信
    展开全文
  • java常见的字符串(String)面试问题

    千次阅读 2019-01-11 11:58:37
    常见的字符串面试问题 1. Java中的String关键字是什么? 2.为什么字符串是不可变的? 3.什么是String常量池? 4.关键字'实习生'用法 5.匹配正则表达式? 6.使用equals()和'=='进行字符串比较? 7. String类中...

    我们所有人都必须通过java中与String类相关的面试问题。这些字符串访谈问题包括不变性和内存泄漏问题。我将尝试在这篇文章中介绍这些问题。

    常见的字符串面试问题
    
    1. Java中的String关键字是什么?
    2.为什么字符串是不可变的?
    3.什么是String常量池?
    4.关键字'实习生'用法
    5.匹配正则表达式?
    6.使用equals()和'=='进行字符串比较?
    7. String类中的内存泄漏问题
    8. String如何在Java中运行?
    9.创建String对象有哪些不同的方法?
    10.如何检查String是否为回文。
    11.如何从String中删除或替换字符。
    12.如何制作String大写或小写?
    13.如何在java程序中比较两个字符串?
    14.我们可以在开关盒中使用String吗?
    15.编写一个程序来打印String的所有排列?
    16.编写一个java程序来反转给定字符串的每个单词?
    17.如何在java中拆分字符串?
    18.为什么Char数组优先于字符串存储密码?
    19. String中的String是否是线程安全的
    20.为什么String是Java中流行的HashMap密钥
    21. String,StringBuffer和StringBuilder之间的区别?
    22.如何连接多个字符串。
    23.使用字符串初始化代码创建多少个对象?
    24.如何计算字符串中每个字符的出现次数?
    25.编写一个java程序来反转一个字符串?

    1. Java中的String关键字是什么?

    没有。String不是Java保留关键字。它是派生类型数据类型,即类。

     

    StringExample.java

    public class StringExample

    {

        public static void main(String[] args)

        {

            Integer String = 10;

             

            System.out.println(String);     //Prints 10

        }

    }

    2.为什么字符串是不可变的?

    我们都知道java中的字符串是不可变的。如果你想知道,什么是不变性以及如何实现?按照这篇文章:如何使java类不可变

    这里的问题是为什么?为什么一成不变?我们来分析吧。

    1. 我能想到的第一个原因是性能提升。Java语言的开发是为了加速应用程序的开发,因为它在以前的语言中并没有那么快。JVM设计人员必须足够聪明,以确定实际应用程序将主要由标签,消息,配置,输出和各种方式的字符串组成。

      看到这种过度使用,他们想象了弦的不当使用是多么危险。所以他们想出了一个字符串池的概念(下一节)。字符串池只是一些字符串的集合,大多是唯一的。String池背后的基本思想是在创建后重用字符串。这样,如果在代码中创建了20次特定字符串,则应用程序最终只有一个实例。

    2. 我认为安全考虑的第二个原因。字符串是java编程的每个方面中最常用的参数类型。无论是加载驱动程序还是打开URL连接,您都需要以字符串的形式将信息作为参数传递。如果字符串还没有最终结果,那么他们就会打开一个Pandora框的安全问题。我们所有人都必须通过java中与String类相关的面试问题。这些问题包括从不变性到内存泄漏问题。我将尝试在这篇文章中介绍这些问题。

    除了上述两个原因外,我没有找到任何令人信服的答案。如果您有什么吸引力的话,请与我分享。

    3.字符串池概念

    字符串池是一个特殊的内存区域,与存储这些字符串常量的常规堆内存分开。这些对象在应用程序的生命周期中被称为字符串变量。

    在Java中,可以通过多种方式创建String。让我们理解他们:

    1)字符串赋值

    String str = "abc";

    上面的代码使JVM验证是否已经有一个字符串“abc”(相同的char序列)。如果存在这样的字符串,JVM只是将现有对象的引用赋给变量str,否则,将创建一个新对象“abc”,并将其引用赋给变量str

    2)使用新关键字

    String str = new String("abc");

    此版本最终在内存中创建两个对象。字符串池中的一个对象具有char序列“abc”,第二个在堆内存中,由变量引用str并具有与“abc”相同的char序列。

    正如java文档所说:除非需要原始的显式副本,否则不必使用此构造函数,因为字符串是不可变的。

    4.关键字'实习生'用法

    这是java docs最好的描述:

    intern()调用该方法时,如果池已包含Stringequals(Object)方法确定的此对象相等的字符串,则返回池中的字符串。否则,将此String对象添加到池中,并String返回对此对象的引用。

     

    String str = new String("abc");

     

    str.intern();

    它遵循对于任何两个字符串sts.intern() == t.intern()true当且仅当s.equals(t)true。意味着如果s和t都是不同的字符串对象并且具有相同的字符序列,则在两者上调用intern()将导致由两个变量引用的单个字符串池文字。

    5.匹配正则表达式

    如果您还没有探索过它,那么不是那么秘密但有用的功能。您必须已经看到Pattern和Matcher用于正则表达式匹配。String类提供了自己的快捷方式。直接使用它。此方法还在函数定义中使用Pattern.matches()

    String str = new String("abc");

     

    str.matches("<regex>");

    6.与equals()和'=='的字符串比较

    采访中另一个最喜欢的领域 通常有两种比较对象的方法

    • 使用==运算符
    • 使用equals()方法

    ==运算符比较对象引用,即内存地址相等。因此,如果两个字符串对象在字符串池中引用相同的文字或在堆中引用相同的字符串对象,则s==t返回true,否则false

    equals()方法在String类中重写,它验证字符串对象保存的char序列。如果它们存储相同的char序列,则s.equals(t)将返回true,否则返回false。

    7.内存泄漏问题

    直到现在我们已经完成了基本的工作。现在有些严肃。您是否尝试过从字符串对象创建子字符串?我打赌,是的。你知道java中子串的内部吗?它们如何造成内存泄漏?

    Java中的子字符串是使用方法substring(int beginIndex)和此方法的一些其他重载形式创建的。所有这些方法都创建一个新的String对象,并更新我们在本文开头看到的offset和count变量。

    原始值[]保持不变。因此,如果您创建一个包含10000个字符的字符串并创建100个子字符串,每个子字符串中包含5-10个字符,则所有101个对象将具有大小为10000个字符的相同字符数组。毫无疑问,这是记忆的浪费。

    让我们看看这个程序:

    import java.lang.reflect.Field;

    import java.util.Arrays;

     

    public class SubStringTest {

        public static void main(String[] args) throws Exception

        {

            //Our main String

            String mainString = "i_love_java";

            //Substring holds value 'java'

            String subString = mainString.substring(7);

     

            System.out.println(mainString);

            System.out.println(subString);

     

            //Lets see what's inside mainString

            Field innerCharArray = String.class.getDeclaredField("value");

            innerCharArray.setAccessible(true);

            char[] chars = (char[]) innerCharArray.get(mainString);

            System.out.println(Arrays.toString(chars));

     

            //Now peek inside subString

            chars = (char[]) innerCharArray.get(subString);

            System.out.println(Arrays.toString(chars));

        }

    }

     

    Output:

     

    i_love_java

    java

    [i, _, l, o, v, e, _, j, a, v, a]

    [i, _, l, o, v, e, _, j, a, v, a]

    显然,两个对象都存储相同的char数组,而subString只需要四个字符。

    让我们使用自己的代码解决这个问题:

    import java.lang.reflect.Field;

    import java.util.Arrays;

     

    public class SubStringTest

    {

        public static void main(String[] args) throws Exception

        {

            //Our main String

            String mainString = "i_love_java";

            //Substring holds value 'java'

            String subString = fancySubstring(7, mainString);

     

            System.out.println(mainString);

            System.out.println(subString);

     

            //Lets see what's inside mainString

            Field innerCharArray = String.class.getDeclaredField("value");

            innerCharArray.setAccessible(true);

            char[] chars = (char[]) innerCharArray.get(mainString);

            System.out.println(Arrays.toString(chars));

     

            //Now peek inside subString

            chars = (char[]) innerCharArray.get(subString);

            System.out.println(Arrays.toString(chars));

        }

     

        //Our new method prevents memory leakage

        public static String fancySubstring(int beginIndex, String original)

        {

            return new String(original.substring(beginIndex));

        }

    }

     

    Output:

     

    i_love_java

    java

    [i, _, l, o, v, e, _, j, a, v, a]

    [j, a, v, a]

    现在,substring只有它需要的字符,用于创建正确子字符串的中间字符串可以被垃圾收集,因此不会留下任何内存。

    8. String如何在Java中运行?

    Java中的字符串就像任何其他编程语言一样,是一系列字符。这更像是一个处理该char序列的实用程序类。此char序列在以下变量中维护:

    /** The value is used for character storage. */

    private final char value[];

    要在不同的方案中访问此数组,请使用以下变量:

    /** The offset is the first index of the storage that is used. */

    private final int offset;

     

    /** The count is the number of characters in the String. */

    private final int count;

    10.如何检查Palindrome中的字符串?

    如果字符串在反转时的值相同,则称其为回文结构。要检查Palindrome,只需反转字符串并检查原始字符串和崇拜字符串的内容。

    StringExample.java

    public class StringExample

    {

        public static void main(String[] args)

        {

            String originalString = "abcdcba";

             

            StringBuilder strBuilder = new StringBuilder(originalString);

            String reverseString = strBuilder.reverse().toString();

     

             

           boolean isPalindrame = originalString.equals(reverseString);

            

           System.out.println(isPalindrame);    //true

        }

    }

    11.如何从String中删除或替换字符?

    要替换或删除字符,请使用String.replace()String.replaceAll()。这些方法有两个参数。第一个参数是要替换的字符,第二个参数是将放在字符串中的新字符。

    如果要删除字符,则在第二个参数中传递空白字符。

    StringExample.java

    String originalString = "howtodoinjava";

     

    //Replace one character

    System.out.println( originalString.replace("h""H") );        //Howtodoinjava

     

    //Replace all matching characters

    System.out.println( originalString.replaceAll("o""O") );     //hOwtOdOinjava

     

    //Remove one character

    System.out.println( originalString.replace("h""") );        //owtodoinjava

     

    //Remove all matching characters

    System.out.println( originalString.replace("o""") );        //hwtdinjava

    12.如何制作String大写或小写?

    使用String.toLowerCase()String.toUpperCase()方法将字符串转换为小写或大写。

    StringExample.java

    String blogName = "HowToDoInJava.com";

     

    System.out.println(blogName.toLowerCase());     //howtodoinjava.com

     

    System.out.println(blogName.toUpperCase());     //HOWTODOINJAVA.COM

    13.如何在java程序中比较两个字符串?

    始终使用equals()方法来验证字符串相等性。切勿使用"=="操作员。双等运算符始终检查内存中的对象引用。equals()方法检查String内容。

    StringExample.java

    String blogName = "HowToDoInJava.com";

             

    String anotherString = new String("HowToDoInJava.com");

     

    System.out.println(blogName == anotherString);     //false

     

    System.out.println(blogName.equals(anotherString));     //true

    14.我们可以在开关盒中使用String吗?

    是的,您可以在Java 7之后使用String类in switch语句。在Java 7之前,它是不可能的,您必须使用if-else语句来实现类似的行为。

    StringExample.java

    String number = "1";

     

    switch (number)

    {

    case "1":

        System.out.println("One");  //Prints '1'

        break;

    case "2":

        System.out.println("Two");

        break;

    default:

        System.out.println("Other");

    }

    15.编写一个程序来打印String的所有排列?

    排列是有序的字符列表的元素的重新排列,使得每个排列相对于其他排列是唯一的。例如下面是字符串“ABC”的排列 - ABC ACB BAC BCA CBA CAB。

    一串长度N具有N! (N Factorial)排列。

    StringExample.java

    import java.util.HashSet;

    import java.util.Set;

     

    public class StringExample

    {

        public static void main(String[] args)

        {

            System.out.println(getPermutations("ABC"));

     

            //Prints

            //[ACB, BCA, ABC, CBA, BAC, CAB]

        }

     

        public static Set<String> getPermutations(String string)

        {

            //All permutations

            Set<String> permutationsSet = new HashSet<String>();

             

            // invalid strings

            if (string == null || string.length() == 0)

            {

                permutationsSet.add("");

            }

            else

            {

                //First character in String

                char initial = string.charAt(0);

                 

                //Full string without first character

                String rem = string.substring(1);

                 

                //Recursive call

                Set<String> wordSet = getPermutations(rem);

                 

                for (String word : wordSet) {

                    for (int i = 0; i <= word.length(); i++) {

                        permutationsSet.add(charInsertAt(word, initial, i));

                    }

                }

            }

            return permutationsSet;

        }

     

        public static String charInsertAt(String str, char c, int position)

        {

            String begin = str.substring(0, position);

            String end = str.substring(position);

            return begin + c + end;

        }

    }

    16.编写一个java程序来反转给定字符串的每个单词?

    要分别反转每个单词,首先,对字符串进行标记,然后将所有单词分开。然后对每个单词应用反向字逻辑,最后连接所有单词。

    StringExample.java

    String blogName = "how to do in java dot com";

     

    //spilt on white space

    String[] tokens = blogName.split(" ");

     

    //It will store reversed words

    StringBuffer finalString = new StringBuffer();

     

    //Loop all words and reverse them

    for (String token : tokens) {

        String reversed = new StringBuffer(token).reverse().toString();

        finalString.append(reversed);

        finalString.append(" ");

    }

     

    //Check final string

    System.out.println(finalString.toString());     //woh ot od ni avaj tod moc

    17.如何在java中拆分字符串?

    使用String.split()方法在给定正则表达式的匹配项周围打破给定字符串。它也被称为基于分隔符的获取字符串标记

    split()method返回字符串数组。数组中的每个字符串都是单个标记。

    StringExample.java

    String numbers = "1,2,3,4,5,6,7";

             

    String[] numArray = numbers.split(",");

     

    System.out.println(Arrays.toString(numArray));  //[1, 2, 3, 4, 5, 6, 7]

    18.为什么Char数组比String更适合存储密码?

    我们知道字符串存储在Java中的常量池中。在字符串池中创建字符串后,它将保留在池中,直到收集垃圾为止。此时,任何恶意程序都可以访问物理内存位置中的内存位置并访问该字符串。

    如果我们将密码存储为字符串,那么它也将存储在弹簧池中,并且将在内存中可用的持续时间超过所需的时间,因为垃圾收集周期是不可预测的。这使得敏感密码字符串容易受到黑客攻击和数据窃取

    使用后我们可以将String变成空白吗?不,我们不可以。我们知道,一旦创建了一个String,我们就无法操纵它,例如你不能改变它的内容。字符串是最终的,不可变的。

    但是char数组是可变的,它们的内容在使用后可以被覆盖。因此,您的应用程序应使用char []存储密码文本,并在使用密码后,用空白替换数组内容。

    StringExample.java

    String password = "123456";     //Do not use it

             

    char[] passwordChars = new char[4];      //Get password from some system such as database

     

    //use password

     

    for(char c : passwordChars) {

        c = ' ';

    }

    19. Java中的字符串是否是线程安全的?

    是的,字符串是线程安全的。它们是不可变的,默认情况下,java中的所有不可变实例都是线程安全的。

    20.为什么String是Java中流行的HashMap键?

    在Java中,必须使用的密钥Map应该是不可变的,并且应该遵守equals()hashCode()方法之间的契约。String班级满足两个条件。

    此外,String类提供了许多有用的方法来比较,排序,标记化或低级大小写。在执行CRUD操作时可以使用这些方法Map。它使它成为一个非常有用的类,Map而不是创建自己的类。

    21. String,StringBuffer和StringBuilder之间的区别?

    • Stringclass表示一系列字符,并提供了处理字符的有用方法。String类实例是不可变的。因此,每次使用字符串类执行字符串连接时,都会使用连接字符串创建一个新对象。
    • StringBuilderclass用于以更高效的内存方式执行字符串连接操作。它在内部维护char array并仅操作此数组中的内容。

      在执行所有操作后需要获取完整的连接字符串时,它会创建一个包含字符数组内容的新String。

    • StringBufferStringBuilder班级非常相似。唯一的区别是它是线程安全的。这都是方法synchronized

    22.如何连接多个字符串?

    根据您的使用StringBufferStringBuilder类别需要线程安全性。使用append()两个类中的方法来连接字符串。

    StringExample.java

    StringBuffer buffer = new StringBuffer();

             

    buffer.append("how")

            .append("to")

            .append("do")

            .append("in")

            .append("java")

            .append(".")

            .append("com");

     

    String blogName = buffer.toString();

     

    System.out.println(blogName); //howtodoinjava.com

    23.使用字符串初始化代码创建多少个对象?

    StringExample.java

    String s1 = "howtodoinjava.com";

    String s2 = "howtodoinjava.com";

    String s3 = new String("howtodoinjava.com");

    1. 上面的代码将创建2个对象
    2. 第一个对象将在第一个语句的字符串池中创建。
    3. 第二个语句不会创建任何新对象,s2并将引用相同的字符串常量s1
    4. 第三个语句将在堆内存中创建一个新的字符串对象。

    24.如何计算字符串中每个字符的出现次数?

    为了找到给定字符串中每个字符的出现次数,我们HashMap将字符用作键,并将其作为值出现。每次出现新事件时,我们都会增加该字符的值。

    StringExample.java

    String blogName = "howtodoinjava.com";

     

    HashMap<Character, Integer> occurancesMap = new HashMap<Character, Integer>();

     

    char[] strArray = blogName.toCharArray();

     

    for (char c : strArray)

    {

        if(occurancesMap.containsKey(c))

        {

            occurancesMap.put(c, occurancesMap.get(c)+1);

        }

        else

        {

            occurancesMap.put(c, 1);

        }

    }

     

    System.out.println(occurancesMap);

    //{a=2, c=1, d=1, h=1, i=1, j=1, m=1, n=1, .=1, o=4, t=1, v=1, w=1}

    25.编写一个java程序来反转没有StringBuilder或StringBuffer的字符串?

    反转字符串的最佳方法绝对是StringBuffer.reverse()StringBuilder.reverse()方法。面试官可能会要求您编写自己的程序,以检查您的技能水平。

    使用下面给出的基于递归的示例来反转字符串。该程序从字符串中获取第一个字符,并放在字符串中的最后一个位置。它使用此替换字符串中的所有字符,直到整个字符串被尊重。

    StringExample.java

    public class StringExample

    {

        public static void main(String[] args)

        {

            String blogName = "howtodoinjava.com";

             

            String reverseString = recursiveSwap(blogName);

             

            System.out.println(reverseString);

        }

         

        static String recursiveSwap(String str)

        {

             if ((null == str) || (str.length() <= 1))

             {

                    return str;

             }

             return recursiveSwap(str.substring(1)) + str.charAt(0);

        }

    }

    展开全文
  • JavaScript中常见的字符串操作函数及用法
    展开全文
  • [C#]常见的字符串方法

    千次阅读 2012-09-07 09:11:57
    C#中常见的字符串方法 1.1 字符串大小写  方法原型  string .ToUpper(); //返回字符串转换的大写形式  string .ToLower(); //返回字符串转换的小写形式  例如:用户在输入用户名的时候,可能会大小写...
  • 通常处理字符串时,都会和其他的数据类型扯上关系,最常见的就是和数组的转化,在https://blog.csdn.net/qq_36923376/article/details/84635247这篇博文中已经讲过一些,这里做下补充。 一、字符串与字符数组 字符...
  • 我遇到了一个很常见的字符串数组string array问题,不能很好地解决。 问题是这样我必须把任意长度的字符串传递给一个solidity智能合约。 我觉得这样就可以: function setStrings(string [] row) 但实际上不太...
  • 常见的字符串的题目

    2013-09-01 21:08:58
    1、查询字符串S是否包含子串S1 ...2、找出字符串S最长重复子串S1 3、找出字符串S1同S2最长公共子串 4、找出字符串S1同S2最长公共子序列 5、找出字符串S最长回文子串S1 6、多模式串模式匹配问题
  • file=/dira/dirb/dirc/me.file.txt可以用${ }分别替换得到不同的值:${file#*/}:删掉第一个/ 及其左边的字符串:dira/dirb/dirc/me.file.txt${file##*/}:删掉最后一个/ 及其左边的字符串:me.file.txt${file#*....
  • 常见的字符串复制函数

    千次阅读 2017-07-02 17:03:24
    功能:把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间 说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 返回指向dest的指针。 2.strcpy_s() _s函数是...
  • 长度不受限制的字符串函数1.字符串拷贝函数1.strcpy函数的注意事项1.strcpy函数的模拟实现2.字符串追加函数1.strcat函数的注意事项2.strcat函数的模拟实现3.字符串比较函数1.strcmp函数的注意事项2.strcmp函数的模拟...
  • 四、常见的字符串函数<1>LENGTH(str): 求字符串长度(以字节为单位),返回字符串str的字节长度。 注:在GBK编码中,一个中文字符为2个字节。UTF-8编码中,一个中文字符为3个字节,一个英文字符为1个字节。 例:*...
  • 常见的字符串方法

    千次阅读 2018-07-22 14:07:11
    1、charAt()——str.charAt(n)——返回第n个字符; 2、indexOf()——str.indexOf(substr,start)——返回 substr 在str 中首次出现位置,start位置从前往后找,不存在,则返回 -1。 3、lastIndexOf——str.index...
  • python中常见的字符串操作

    千次阅读 2017-09-05 15:31:49
    如有字符串mystr = 'hello world and bjsxt yunshuxueyuan sxt beijing',以下是常见的操作 find 检测 str 是否包含在 mystr中,如果是返回开始的索引值,否则返回-1 mystr.find(str, start=0, end=len(mystr...
  • C语言中常见的字符串函数 1、字符串长度 strlen 实现代码: unsigned int strlen(const char *string){ unsigned int i= 0; while (string[i] != '\0'){ i++; } return i; } 2、打印字符串 put string ...
  • ASCII(char) 返回字符ASCII码值SELECT ASCII('a')CONCAT(s1,s2…,sn) 将s1,s2…,sn连接成字符串(oracle只支持两个字符串连接)SELECT CONCAT("super","star","!")INSERT(str,x,y,instr) 将字符串str从第x位置...
  • python中常见的字符串处理函数

    千次阅读 2016-09-11 13:25:06
    这里只是写了字符串对象中方法,不是使用string模块中方法 1.查找字符串子串, 2.字符串的大小写转换upper() lower() eg: a="abc" a.upper() ==>ABC 3.统计某个子字符串,或者字符,在字符串中出现次数...
  • 这些字符串处理函数,大多都是在原字符串上修改,返回值一个修改后的新的字符串
  • 1.异或加密: 原则:同为0,异为1 例:           a — 0 1 1 0 0 0 0 1(a对应二进制数)   ...3 — 0 0 0 0 0 0 1 1(3对应二进制数...
  • 几种常见的字符串匹配算法

    千次阅读 2016-12-05 13:24:03
    转自...1. 朴素算法 朴素算法是最简单的字符串匹配算法,也是人们接触得最多的字符串匹配算法。代码一看就懂,在此不在赘述。 #include #include void search(char *pat, char *txt) { int M = strle

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,184
精华内容 10,473
关键字:

常见的字符串