java string ages_java string常见操作题

1.每个基本类型封装类都有将string转换为基本数据类型的方法

对于非常大的数字请使用Long,代码如下

int age = Integer.parseInt("10");

long id = Long.parseLong("190"); // 假如值可能很大.

2.将char字符转换为string   string Chraracter.toString(char),将char转换为string

3.将stringBuilder转换为string，stringBuilder.tostring();

4.string类常用操作方法

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

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

3)int string.indexOf(substr);//返回substr在string中第一个index

4)string string.subString(fromIndex.endIndex);//返回被截取的字符串

5)string string.subString(fromIndex);//从第几位开始往后截取

6)char string.charAt(index);返回第几个字符

7)一切的前提，谨记string是final类的，不能更改。保存在方法区的常量池中。

8)用stringBuilder将string相反过来，因为stringBuilder.toReverse()方法，然后再stringBuilder.toReverse().toString()转换为字符串

9)谨记千万不要采用string1+string2+string3这种引用变量的相加，这种会容易造成内存溢出，常量池内存溢出，因为这是引用变量，在程序运行时才会操作。

若想string1这种相加，可以采用字面值相加，如“123”+“abc”+"cbb",因为这种是编译器会优化，优化成一个string。

或者采用，stringBuilder的append(string)方法，将一个stringB附加到主stringBuilder后面。

1.string.操作方法，默认会生成一个新的string保存在常量池中，不会改变原来常量池中的string。

因为常量池，string是final的，一经创建无法改变。

看下面代码：

String str = "abcde";

str.toUpperCase();

System.out.println(str);//输出还是abcde,而非ABCDE。因为string是final的，string的改变内容的操作方法会生成一个新的string在常量池中。

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

String str = "abcde";

str=str.toUpperCase();

System.out.println(str);

//常量池中新生成一个string，以前的引用变量指向新地址

3.字符串反转，用string缓存类，stringBuffer或者stringBuilder.

因为string缓存类，预先在堆内存中开辟一个16字符的存储空间，借以不断改变string的值

String str = "abcde";

StringBuilder stringBuilder= newStringBuilder(str);

stringBuilder.reverse();

str=stringBuilder.toString();

System.out.println(str);//输出edcba

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

4.判断字符串是否对称：

String str = "abcde";

StringBuilder stringBuilder= newStringBuilder(str);

String str2=stringBuilder.reverse().toString();

System.out.println(str.equal(str2));

5.输出字符串的子串，比如string str = "@abc  efg . ghk";

string[] strArray = string.split("byChar");

string.split(“byChar”)方法

要求输出abc efg ghk

String str = "ab@cd ghk efg";

str= str.replaceAll("@", " ");

String[] strArray= str.split(" ");for(String str1:strArray)

{

System.out.println(str1);

}

5. 编写一个程序，将下面的一段文本中的各个单词的字母顺序翻转，

“To be or not to be"，将变成"oT eb ro ton ot eb."。

public static voidmain(String[] args) {

String s= "To be or not to be";

String ss[]= s.split(" ");

StringBuffer sb2= newStringBuffer();for (int i = 0; i < ss.length; i++) {

StringBuffer sb= newStringBuffer(ss[i]);

sb.reverse();

sb2.append(sb);if(i == ss.length-1){

sb2.append(".");

}else{

sb2.append(" ");

}

}

System.out.println(sb2);

}

6.String s=”name=zhangsan age=18 classNo=090728”;

将上面的字符串拆分，结果如下:

zhangsan 18 090728

public static voidmain(String[] args) {

String s="name=zhangsan age=18 classNo=090728";

String[] ss= s.split(" ");

StringBuffer sb=newStringBuffer();for (int i = 0; i < ss.length; i++) {

String[] ss2=ss[i].split("=");

sb.append(ss2[1]);

sb.append(" ");

}

System.out.println(sb);

}

7.判断一个字符串是否包含另一个字符串？

答：int i = str.indexof("sss");如果不包含，则返回-1.如果包含则返回被包含字符串的起始位置。

if(str.indexof()!=-1){包含};

8.给定一个字符串,判断该字符串中是否包含某个子串.如果包含,求出子串的所有出现位置.

如:"abcbcbabcb34bcbd"中,"bcb"子串的出现位置为: 1,7,12.字符串和子串均由用户输入

String str = "abcdefghkabcdefdef";

String subStr= "def";

AppMain appMain= newAppMain();

appMain.calculateSubStrIndexFromString(str,subStr,0);

}public void calculateSubStrIndexFromString(String string,String subStr,intstartIndexFirst) {int startIndex =startIndexFirst;int existingIndex = string.indexOf(subStr, startIndex);while(existingIndex != -1)

{

System.out.println("存在的index为："+existingIndex);

calculateSubStrIndexFromString(string,subStr,existingIndex+subStr.length());break;

}

}

9.给定一个长度,随机产生一个该长度的字符串,由大写,小写字母以及数字组成

Java中随机数的生成:

java.util.Random r = new java.util.Random();

int a = r.nextInt(100): a 0-99的随机数

java char 48-57对应0-9

java char 65-90对应A-Z

java chat 97-122对应a-z

10.2.给定一个长度,随机产生一个该长度的字符串,由大写,小写字母以及数字组成

Java中随机数的生成:

java.util.Random r = new java.util.Random();

int a = r.nextInt(100): a 0-99的随机数

public static voidMethod_Two()

{

System.out.println("请输入一个长度");

Scanner s= new Scanner(System.in);int n =s.nextInt();char[] cs = new char[n];

Random random= newRandom();for (int i = 0; i < n; i++)

{int a = random.nextInt(62);if(a>=0 && a<=25)

{

a+=65;

}else if (a>25 && a<=51)

{//97 - 26 = 71

a+=71;

}else{//52-48 = 4

a-=4;

}

cs[i]= (char)a;

}

System.out.println(cs);

}

11.给定一个由数字组成的字符串,如:"1239586838923173478943890234092",统计

出每个数字出现的次数

public static voidMethod_Three()

{

Scanner scanner= new Scanner(System.in);

Stringstring =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 map = new HashMap();

Set 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 set2 =map.keySet();for(Character character : set2)

{

System.out.println(character+"=========="+map.get(character));

}

}

输出字符串里的大写字母数，小写英文字母数，非英文字母数

public class TestString{

public static void main (String[] args) {

String s="ddejidsEFALDFfnef2357 3ed";

int letters=0;//小写字母数

int capitalLetters=0;//大写字母数

for(int i=0;i

char c=s.charAt(i);

if(Character.isLowerCase(c)){

letters++;

}

else if(Character.isUpperCase(c)){

capitalLetters++;

}

总结:字符串的常见操作无非几种

1.字符串反转 用stringBuilder.reverse();

2.字符串切割String[] strArray = str.spilt("spiltChar");

3.字符串拼接 用stringBuilder.append("str");

本文部分转自http://www.cnblogs.com/IamJiangXiaoKun/p/4639302.html

http://www.2cto.com/kf/201402/276764.html 感谢作者

/*

* 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。

* {"nba","abc","cba","zz","qq","haha"}

*

* 思路：

* 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] + "]");

}

}

}

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;

}

}

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;

}

}

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);

}

}

编程. 已知字符串："this is a test of java".

按要求执行以下操作：

(1) 统计该字符串中字母s出现的次数

(2) 取出子字符串"test"

(3) 用多种方式将本字符串复制到一个字符数组Char[] str中.

(4) 将字符串中每个单词的第一个字母变成大写， 输出到控制台。

(5) 用两种方式实现该字符串的倒叙输出。(用StringBuffer和for循环方式分别实现)

(6) 将本字符串转换成一个字符串数组，要求每个数组元素都是一个有意义的额英文单词,并输出到控制台

4. 转换String为数字对于非常大的数字请使用Long,代码如下

复制代码 代码如下:

int age = Integer.parseInt("10");

long id = Long.parseLong("190"); // 假如值可能很大.