《黑马程序员》java笔记->关于String类及方法概述，练习

------- android培训、java培训、期待与您交流！ ----------

/*

 * String类的特点：
 * 1，Java语言中用于描述最常见的字符串数据的对象。
 * 2，字符串数据都是一个对象。
 * 3，字符串数据一旦初始化就不可以被改变了。双引号表示的都是字符串常量。 
 * 4，字符串对象都存储在常量池中。 字符串常量池。 
 * 
 * 
 */


public class StringDemo {


/**
* @param args
*/
public static void main(String[] args) {

// 定义一个字符串。
// String str = "abcd";

String s1 = "abcd";//这时在常量池中创建了一个字符串对象。
// System.out.println(str==s1);//true

String s2 = new String("abcd");//这是在堆内存创建一个String类的对象。并在常量池创建了"abcd"对象。
System.out.println(s1);
System.out.println(s2);
System.out.println(s1==s2);//false
//对于字符串对象的比较，应该用equals方法完成。
//记住，基本数据用==进行比较相同。 对象比较相同都用equals方法。 
System.out.println(s1.equals(s2));//String类覆盖了Object中的equals方法，比较的是字符串内容是否相同。

String s3 = "ab"+"cd";
System.out.println(s1==s3);//true.
}

}

-------------------------------------------

public static void main(String[] args) {

String str = "abnbacde";

/*
* 字符串对象应该具备什么功能便于操作呢？
* 1，字符串中多少个字符串啊？字符串的长度 
* 如果有这个功能，结果应该是整数。而且该方法操作的就是本类字符串对象的方法。不需要参数。
* 接下来，按照返回值类型进行查找，匹配后，在看参数列表，匹配后，参看名称和介绍。int  length();
* 
* 2，其中一个字符在字符串中的哪个位置上？
* 功能结果：int。参数：char.
* 
* 3，具体一个子串在该字符串的哪个位置出现？
* 结果是：int,参数：String.
* 
* 4，指定位置上的字符是什么？
* 结果：char，参数：int index.
* 
* 5，能不能获取到字符串中的指定的子串。
* 结果：string，参数：两个int。索引index。
* 
* 6，如何将这个字符串变成大写的字符串呢？
* 结果：String，参数，无。
* 
* 习惯：一旦操作字符串，先找String对象中的方法。没有时在进行自定义，而自定义过程中，往往是多个String方法的组合完成的。
* 
* 
* 
*/

// int len  = str.length();
// System.out.println("len="+len);

int index = str.indexOf('a',2);//'a'在字符串中第一次出现的位置。
System.out.println("index="+index);

int index2 = str.indexOf("cba");
System.out.println("index2="+index2);//-1 象这样的索引方法，
// 好处一：获取具体的位置。好处二：还可以判断被索引的内容是否存在。通过-1来判断即可。


// char ch = str.charAt(8);//StringIndexOutOfBoundsException 访问到字符串中不存在的角标就会发生该异常。 
// System.out.println("ch="+ch);

String sub_str = str.substring(2, 5);//截取整个字符串，str.substring(0,str.length());
System.out.println("sub_str="+sub_str);


String upper_str = str.toUpperCase();
System.out.println("upper_str="+upper_str);
}
}

------------------------------------------------------------------------------------------------------------------------

public static void main(String[] args) {
/*
* 按照基本思路快速查找方法。
* 练习：1，将字符串中的指定字符串替换成给定字符串。测试如果指定的字符串不存在，结果又是什么？原串。
* 结果： 字符串     参数：string，string。
* replace(string ,string);
* 
* 练习：2，将字符串变成多个字符(char[]字符数组).
* 结果：char[]  参数：无
* 
* 
* 练习：3，字符串是否包含指定的子串。以及是否是以指定字符串开头或者结尾。
* 结果：boolean 参数:string.
* 
* 练习：4，将给定的字符串"zhangsan,lisi,wangwu"获取其中每一个人的姓名。
* 意味着获取多个字符串。
* 结果:String[] 参数：指定的方式。
* 
* 练习：5，字符串在书写时往往不注意会在字符串的两端加有空格,找出取出两端空白的方法。 
* 
* 结果：string。参数：无。
* 
*/


String str = "abnbacd";

String s = str.replace("nba", "haha");
System.out.println("s="+s);
System.out.println(str);

char[] chs = str.toCharArray();//将字符串转成字符数组。


boolean b = str.contains("Demo");
System.out.println("b="+b);

boolean b1 = str.endsWith(".java");


str = "zhangsan,lisi,wangwu";
String[] names = str.split(",");

for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}


str = "     ab   c     ";
str = str.trim();
System.out.println("-"+str+"-");
}

---------------------------------------------------------------------------------------------------------------------------------------

/*
* 综合性练习：
* 1，获取一个子串在字符串中出现的次数。
* "nbawernbatyunbaidfnbaghjnba" nba出现了几次。 
* 
* 思路：
* 1，需要对nba在整串中进行查找。
*  2，如果找到了，记录nba出现的位置，
*  3，再从这个位置+nba长度的位置开始继续查找剩下的字符串中是否还有nba。
*  4，通过计数器来记录每次查找的次数 
*  
*  步骤:
*  1，先有计数器。
*  2，定义变量记录每次出现的位置。
*  3，可以通过String类中的indexOf方法来完成对子字符串的索引。 
*  4，指定的子串有可能有很多，需要不断的查找(循环 ，条件，找不到了就结束。).
*  
*/
String s1 = "nbawernbatyunbaidfnbaghjnba";
String key = "nba";
int count = getSubCount(s1,key);
System.out.println(key+",count="+count);



/* 
* 2，对字符串进行反转。 如："abcd"-->"dcba";
* 思路：
* 1，一看反转，就让我想到了曾经的数组反转。
* 2，可以将字符串转成数组，
* 3，数组进行反转。(无非就是头尾角标元素的位置置换。)
* 4，将数组变成字符串。
* 
*/
String s2 = "abcde";
s2 = reverseString(s2);
System.out.println("reverse:"+s2);



}


/**
* 将给定字符串反转并返回。 
* @param str
* @return
*/
public static String reverseString(String str) {

//1，将字符串转成字符数组。
char[] chs = str.toCharArray();

reverseArrary(chs);

return new String(chs);//通过构造器将字符数组转成字符串。 
}

/*
* 将一个字符数组进行反转。
*/
private static void reverseArrary(char[] chs) {

for (int start = 0,end = chs.length - 1; start < end; start++,end--) {

swap(chs,start,end);
}

}


/*
* 对字符数组元素进行位置的置换。 
*/
private static void swap(char[] chs, int start, int end) {
char temp = chs[start];
chs[start] = chs[end];
chs[end] = temp;
}


/**
* 获取一个子串在字符串中出现的次数。
* @param str 给定的字符串。
* @param key 要找的子串
* @return 返回key出现在str中的次数。 
*/

public static  int getSubCount(String str,String key){

//1,定义变量，一个是计数器，一个是记录位置。
int count = 0;
int index = 0;

//2，调用indexOf方法获取key出现的位置。
while((index = str.indexOf(key,index))!=-1){
index = index + key.length();
count++;
}
return count;
}

------------------------------------------------------------------------------------------------------------------

/* 3，对一个字符串中的字符进行字典顺序的排序生成一个有序的字符串。
* 如："cbda"--->"abcd";
* 思路：
* 1，一看排序，就想到数组。
* 2，将字符串先转成数组。
* 3，对数组排个序。
* 4，将排序的数组变成字符串。
* 
*/
String s3 = "cde2ba-8+1fq";

s3 = sortString(s3);
System.out.println("sort:"+s3);



}


public static String sortString(String str) {

//1，将字符串转成字符数组。 
char[] chs = str.toCharArray();

//2，对数组排序。
// Arrays.sort(chs);
mySort(chs);

return new String(chs);
}


private static void mySort(char[] chs) {

for(int x=0; xfor(int y=x+1; yif(chs[x]>chs[y]){
swap(chs,x,y);
}
}
}
}


private static void swap(char[] chs, int x, int y) {
char temp = chs[x];
chs[x] = chs[y];
chs[y] = temp;
}

--------------------------------------------------------------------------------------------------------------------------

/* 
* 4，获取两个字符串中最大相同子串。
* 如："rtyuicctvoprtyu"
*         "cvbcctvnm"  最大相同是cctv
*         
* 思路：
* 1，既然获取的最大子串，找到其中一个比较短的为参照，
* 去判断大中的是否包含短串。
* 2，如果不包含，将短的长度按照依次递减的方式获取短串中的子串。
* 并不断地判断是否在长串中存在，
* 3，如果存在，视为找到，结束。
*/

String s1 = "rtyuicctvoprtyu";
String s2 = "cvbcctvnm";

String maxsub = getMaxSubstring(s2,s1);
System.out.println("maxsub="+maxsub);
}


/**
* 获取两个字符串中最大相同的子串。 
* @param s1
* @param s2
* @return
*/
public static String getMaxSubstring(String s1, String s2) {

String max,min;
max = s1.length()>s2.length()?s1:s2;

min = max.equals(s1)?s2:s1;

// System.out.println("max="+max+",,min="+min);



for(int x=0; x
for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++){
//获取s2子串
String temp = min.substring(y,z);

// System.out.println(temp);
if(max.contains(temp)){//s1.indexOf(temp)!=-1
return temp;
}

}
}

return null;
}

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

/*
* 有一个字符串数组{"cba","abc","nba","zz","qq","aaa"}.
* 对这个字符串数组进行字典顺序的排序。
* {"aaa","abc","cba","nba","qq","zz"}
* 
* 思路；
* 1，既然要数组排序，必须是循环嵌套。
* 2，进行位置的置换。
* 3，排序都需要进行比较，字符串怎么比较呢？不能用比较运算符了。
* 字符串对象进行比较。是不是应该这样的功能啊？
* 结果：int （只有三种情况中的一种，负数，0，正数）  参数：String
* 
* 
* 
* 基本数据类型比较用的是比较运算符。
* 对象的比较用的是compareTo方法。
*/

String[] strs = {"cba","abc","nba","zz","qq","aaa"};

sortString(strs);

for (int i = 0; i < strs.length; i++) {
System.out.print(strs[i]+",");
}


}
/**
* 对字符串数组进行排序，按照字典顺序。
* @param strs
*/
public static void sortString(String[] strs) {

for (int i = 0; i < strs.length-1; i++) {
for (int j = i+1; j < strs.length; j++) {

if(strs[i].compareTo(strs[j])>0)
swap(strs,i,j);
}
}

}
/*
* 对字符串数组中的元素进行位置的置换。
*/
private static void swap(String[] strs, int i, int j) {

String  temp = strs[i];
strs[i] = strs[j];
strs[j] = temp;
}
public static void sort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j < arr.length; j++) {
if(arr[i]>arr[j]){
swap(arr,i,j);
}
}
}
}


private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}