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 =  new StringBuilder(str);
        stringBuilder.reverse();
        str = stringBuilder.toString();
        System.out.println(str);//輸出edcba

stringBuilder是在堆內存開辟一個存儲空間，對stringBuilder的修改全是在修改stringBuilder對象內存本身。

4.判斷字符串是否對稱：

String str = "abcde";
        StringBuilder stringBuilder =  new StringBuilder(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 void main(String[] args) {
String s = "To be or not to be";
String ss[] = s.split(" ");
StringBuffer sb2 = new StringBuffer();
for (int i = 0; i < ss.length; i++) {
StringBuffer sb = new StringBuffer(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 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);
    }
    
    

 

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 = new AppMain();
        appMain.calculateSubStrIndexFromString(str,subStr,0);
        
    }

    public void calculateSubStrIndexFromString(String string,String subStr,int startIndexFirst) {
        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 void Method_Two()
    {
        System.out.println("請輸入一個長度");
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        char[] cs = new char[n];
         
        Random random = new Random();
        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 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));
        }
    }

 

輸出字符串里的大寫字母數，小寫英文字母數，非英文字母數

 

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"); // 假如值可能很大.