java string常见操作题

  1. 每个基本类型封装类都有将string转换为基本数据类型的方法
    对于非常大的数字请使用Long,代码如下*

    1
    2
    int age = Integer.parseInt("10");  
    long id = Long.parseLong("190"); // 假如值可能很大.
  2. 将char字符转换为String

    1
    Chraracter.toString(char)
  3. 将stringBuilder转换为string,

    1
    stringBuilder.tostring();
string类常用操作方法

1)string[] string.spilt(“ “);//根据空格符进行分割,返回值是string数组

1
2
3
4
5
6
7
8
String strings = new String("hello world");
System.out.println("原始字符串"+strings);
String[] string1 = strings.split(" ");
System.out.println("新字符串"+Arrays.toString(string1));
/*输出结果
原始字符串hello world
新字符串[hello, world]
*/

2)string string.replaceAll(“a”,”b”);//将a取代成b

1
2
3
4
5
6
7
8
String strings = new String("hello world");
System.out.println("原始字符串:" + strings);
String str2 = strings.replaceAll("hello", "你好");
System.out.println("新字符串:" + str2);
/*输出结果
原始字符串:hello world
新字符串:你好 world
*/

3)int string.indexOf(substr);//返回substr在string中第一个index
4)string string.subString(fromIndex.endIndex);//返回被截取的字符串

1
2
3
4
5
6
7
8
String strings = new String("hello world");
System.out.println("原始字符串:" + strings);
String str2 = strings.substring(6,9);
System.out.println("新字符串:" + str2);
/*输出结果
原始字符串:hello world
新字符串:wor
*/

5)string string.subString(fromIndex);//从第几位开始往后截取
6)char string.charAt(index);返回第几个字符
7)一切的前提,谨记string是final类的,不能更改。保存在方法区的常量池中。
8)用stringBuilder将string相反过来,因为stringBuilder.toReverse()方法,然后再stringBuilder.toReverse().toString()转换为字符串

1
2
3
4
5
6
7
8
9
String strings = new String("hello world");
System.out.println("原始字符串:" + strings);
StringBuilder stringBuilder = new StringBuilder(strings);
strings = stringBuilder.reverse().toString();
System.out.println("新字符串:" + strings);
/*输出结果
原始字符串:hello world
新字符串:dlrow olleh
*/

9)谨记千万不要采用string1+string2+string3这种引用变量的相加,这种会容易造成内存溢出,常量池内存溢出,因为这是引用变量,在程序运行时才会操作。
若想string1这种相加,可以采用字面值相加,如“123”+“abc”+”cbb”,因为这种是编译器会优化,优化成一个string。或者采用,stringBuilder的append(string)方法,将一个stringB附加到主stringBuilder后面。

  1. string.操作方法,默认会生成一个新的string保存在常量池中,不会改变原来常量池中的string。
    因为常量池,string是final的,一经创建无法改变。
    看下面代码:
    1
    2
    3
    String str = "abcde";
    str.toUpperCase();
    System.out.println(str); //输出还是abcde,而非ABCDE。

因为string是final的,string的改变内容的操作方法会生成一个新的string在常量池中。

  1. 引用变量指向常量池中的新的str

    1
    2
    3
    4
    String str = "abcde";
    str = str.toUpperCase();
    System.out.println(str);
    //常量池中新生成一个string,以前的引用变量指向新地址
  2. 字符串反转,用string缓存类,stringBuffer或者stringBuilder.
    因为string缓存类,预先在堆内存中开辟一个16字符的存储空间,借以不断改变string的值

    1
    2
    3
    4
    5
    String str = "abcde";
    StringBuilder stringBuilder = new StringBuilder(str);
    stringBuilder.reverse();
    str = stringBuilder.toString();
    System.out.println(str);//输出edcba

stringBuilder是在堆内存开辟一个存储空间,对stringBuilder的修改全是在修改stringBuilder对象内存本身。

  1. 判断字符串是否对称:

    1
    2
    3
    4
    String str = "abcde";
    StringBuilder stringBuilder = new StringBuilder(str);
    String str2 = stringBuilder.reverse().toString();
    System.out.println(str.equal(str2));
  2. 输出字符串的子串,比如
    string str = “@abc efg . ghk”;
    string[] strArray = string.split(“byChar”);
    string.split(“byChar”)方法
    要求输出abc efg ghk

    1
    2
    3
    4
    5
    6
    String str = "ab@cd ghk efg";
    str = str.replaceAll("@", " ");
    String[] strArray = str.split(" ");
    for (String str1 : strArray) {
    System.out.println(str1);
    }
  3. 编写一个程序,将下面的一段文本中的各个单词的字母顺序翻转,“To be or not to be”,将变成”oT eb ro ton ot eb.”。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public static void main(String[] args) {
    String str = "To be or not to be";
    String[] strings = str.split(" ");
    StringBuilder stringBuilder = new StringBuilder();
    for (int i = 0; i < strings.length; i++) {
    StringBuilder s = new StringBuilder(strings[i]);
    stringBuilder.append(s.reverse());
    if (i < strings.length - 1)
    stringBuilder.append(" ");
    }
    stringBuilder.append(".");
    System.out.println(stringBuilder.toString());
    }
    /**
    * 输出结果:oT eb ro ton ot eb.
    */
    /**
    * 输出结果:oT eb ro ton ot eb.
    */

7.

s="name=zhangsan age=18 classNo=090728"```
1
2
将上面的字符串拆分,结果如下:
```zhangsan 18 090728

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
String s = "name=zhangsan age=18 classNo=090728";
String[] ss = s.split(" ");
StringBuffer sb = new StringBuffer();
for (int i = 0; i < ss.length; i++) {
String[] ss2 = ss[i].split("=");
sb.append(ss2[1]);
sb.append(" ");
}
System.out.println(sb);
}
  1. 判断一个字符串是否包含另一个字符串?
    答:
    java int i = str.indexof(“sss”);
    如果不包含,则返回-1.如果包含则返回被包含字符串的起始位置。

    1
    if(str.indexof()!=-1){包含};
  2. 给定一个字符串,判断该字符串中是否包含某个子串.如果包含,求出子串的所有出现位置.如:”abcbcbabcb34bcbd”中,”bcb”子串的出现位置为: 1,7,12.字符串和子串均由用户输入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public static void main(String[] args) {
    String userInput = "abcbcbabcb34bcbd";
    String subString = "bcb";
    int index = 0;
    while (true) {
    if (userInput.indexOf(subString, index) != -1) {
    System.out.println(userInput.indexOf(subString, index));
    index = userInput.indexOf(subString, index) + subString.length();
    } else
    break;
    }
    }
  3. 给定一个长度,随机产生一个该长度的字符串,由大写,小写字母以及数字组成Java中随机数的生成:
    java.util.Random r = new java.util.Random();
    int a = r.nextInt(100): a 0-99的随机数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    public class suiji {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个整数");
    int shuru = scanner.nextInt();
    char[] s = new char[shuru];
    for (int i = 0; i < shuru; i++) {
    int a = (int) (Math.random() * 3);
    if (a == 0) {
    s[i] = (char) (Math.random() * 10 + 48);
    } else if (a == 1) {
    s[i] = (char) (Math.random() * 26 + 65);
    } else {
    s[i] = (char) (Math.random() * 26 + 97);
    }
    }
    System.out.println(s);
    /**
    *方法二用Random
    */
    // Scanner scanner = new Scanner(System.in);
    // int zs = scanner.nextInt();
    // Random random = new Random();
    // char[] sz = new char[zs];
    // for (int i = 0; i < zs; i++) {
    // int b = random.nextInt(3);
    // if (b == 0) {
    // sz[i] = (char) (random.nextInt(10) + 48);
    // } else if (b == 1) {
    // sz[i] = (char) (random.nextInt(26) + 65);
    // } else if (b == 2) {
    // sz[i] = (char) (random.nextInt(26) + 97);
    // }
    // }
    // System.out.println(sz);
    }
    }
  4. 给定一个由数字组成的字符串,如:”1239586838923173478943890234092”,统计出每个数字出现的次数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    public static void Method_Three()
    {
    Scanner scanner = new Scanner(System.in);
    String string = scanner.next();
    int[] c = new int[10];
    for (int i = 0; i < string.length(); i++)
    {
    char c1 = string.charAt(i); //48-57
    int a = c1-48; // 类型转换
    c[a]++;
    }
    for (int i = 0; i < c.length; i++)
    {
    System.out.println(i+" 出现的次数: "+c[i]);
    }
    System.out.println("=========方法二==========");
    String s = "12548954231351486214894562";
    char[] ch = s.toCharArray();
    Map<Character, Integer> map = new HashMap<Character, Integer>();
    Set<Character> set = map.keySet();
    for (int i = 0; i < ch.length; i++)
    {
    if (set.contains(ch[i])) // 判断map中已经有的char值
    {
    map.put(ch[i], map.get(ch[i])+1);
    } else
    {
    map.put(ch[i], 1); // 第一次放入map中
    }
    }
    Set<Character> set2 = map.keySet();
    for (Character character : set2)
    {
    System.out.println(character+"=========="+map.get(character));
    }
    }
  5. 输出字符串里的大写字母数,小写英文字母数,非英文字母数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public static void main(String[] args) {
    String s = "ddejidsEFALDFfnef2357 3ed";
    int da=0,xiao=0,fei=0;
    for (int i = 0; i < s.length(); i++) {
    char a = s.charAt(i);
    if (Character.isUpperCase(a))
    da++;
    else if (Character.isLowerCase(a))
    xiao++;
    else
    fei++;
    }
    System.out.println("大写字母:"+da+" "+"小写字母:"+xiao+" "+"非字母"+fei);
    }
    /**
    * 输出结果:大写字母:6 小写字母:13 非字母6
    */
总结:字符串的常见操作无非几种

1.字符串反转 用stringBuilder.reverse();
2.字符串切割 String[] strArray = str.spilt(“spiltChar”);
3.字符串拼接 用stringBuilder.append(“str”);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/**
* 1,给定一个字符串数组。按照字典顺序进行从小到大的排序。
* {"nba","abc","cba","zz","qq","haha"}
* <p>
* 思路:
* 1,对数组排序。可以用选择,冒泡都行。
* 2,for嵌套和比较以及换位。
* 3,问题:以前排的是整数,比较用的比较运算符,可是现在是字符串对象。
* 字符串对象怎么比较呢?爽了,对象中提供了用于字符串对象比较的功能。
*/
public class StringTest_1 {
/**
* @param args
*/
public static void main(String[] args) {
String[] arr = {"nba", "abc", "cba", "zz", "qq", "haha"};
printArray(arr);
sortString(arr);
printArray(arr);
}
public static void sortString(String[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i].compareTo(arr[j]) > 0)//字符串比较用compareTo方法
swap(arr, i, j);
}
}
}
private static void swap(String[] arr, int i, int j) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArray(String[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
System.out.print(arr[i] + ", ");
else
System.out.println(arr[i] + "]");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package cn.itcast.p1.string.test;
/*
* 2,一个子串在整串中出现的次数。
* "nbaernbatynbauinbaopnba"
* 思路:
* 1,要找的子串是否存在,如果存在获取其出现的位置。这个可以使用indexOf完成。
* 2,如果找到了,那么就记录出现的位置并在剩余的字符串中继续查找该子串,
* 而剩余字符串的起始位是出现位置+子串的长度.
* 3,以此类推,通过循环完成查找,如果找不到就是-1,并对 每次找到用计数器记录。
*
*/
public class StringTest_2 {
/**
* @param args
*/
public static void main(String[] args) {
String str = "nbaernbatnbaynbauinbaopnba";
String key = "nba";
int count = getKeyStringCount_2(str,key);
System.out.println("count="+count);
}
public static int getKeyStringCount_2(String str, String key) {
int count = 0;
int index = 0;
while((index = str.indexOf(key,index))!=-1){
index = index + key.length();
count++;
}
return count;
}
/**
* 获取子串在整串中出现的次数。
* @param str
* @param key
* @return
*/
public static int getKeyStringCount(String str, String key) {
//1,定义计数器。
int count = 0;
//2,定义变量记录key出现的位置。
int index = 0;
while((index = str.indexOf(key))!=-1){
str = str.substring(index+key.length());
count++;
}
return count;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package cn.itcast.p1.string.test;
/*
* 3,两个字符串中最大相同的子串。
* "qwerabcdtyuiop"
* "xcabcdvbn"
*
* 思路:
* 1,既然取得是最大子串,先看短的那个字符串是否在长的那个字符串中。
* 如果存在,短的那个字符串就是最大子串。
* 2,如果不是呢,那么就将短的那个子串进行长度递减的方式去子串,去长串中判断是否存在。
* 如果存在就已找到,就不用在找了。
*
*
*/
public class StringTest_3 {
/**
* @param args
*/
public static void main(String[] args) {
String s1 = "qwerabcdtyuiop";
String s2 = "xcabcdvbn";
String s = getMaxSubstring(s2, s1);
System.out.println("s=" + s);
}
/**
* 获取最大子串
*
* @param s1
* @param s2
* @return
*/
public static String getMaxSubstring(String s1, String s2) {
String max = null,min = null;
max = (s1.length()>s2.length())?s1:s2;
min = max.equals(s1)?s2:s1;
System.out.println("max="+max);
System.out.println("min="+min);
for (int i = 0; i < min.length(); i++) {
for(int a = 0,b = min.length()-i; b != min.length()+1; a++,b++){
String sub = min.substring(a, b);
// System.out.println(sub);
if(max.contains(sub))
return sub;
}
}
return null;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package cn.itcast.p1.string.test;
/*
* 4,模拟一个trim功能一致的方法。去除字符串两端的空白
* 思路:
* 1,定义两个变量。
* 一个变量作为从头开始判断字符串空格的角标。不断++。
* 一个变量作为从尾开始判断字符串空格的角标。不断--。
* 2,判断到不是空格为止,取头尾之间的字符串即可。
*/
public class StringTest_4 {
/**
* @param args
*/
public static void main(String[] args) {
String s = " ab c ";
s = myTrim(s);
System.out.println("-" + s + "-");
}
public static String myTrim(String s) {
int start = 0, end = s.length() - 1;
while (start <= end && s.charAt(start) == ' ') {
start++;
}
while (start <= end && s.charAt(end) == ' ') {
end--;
}
return s.substring(start, end + 1);
}
}
  1. 编程. 已知字符串:”this is a test of java”.
    按要求执行以下操作:
    (1) 统计该字符串中字母s出现的次数
    (2) 取出子字符串”test”
    (3) 用多种方式将本字符串复制到一个字符数组Char[] str中.
    (4) 将字符串中每个单词的第一个字母变成大写, 输出到控制台。
    (5) 用两种方式实现该字符串的倒叙输出。(用StringBuffer和for循环方式分别实现)
    (6) 将本字符串转换成一个字符串数组,要求每个数组元素都是一个有意义的额英文单词,并输出到控制台
Hongwei wechat
欢迎大家关注微信公众号:ghw1996