01_Java基础_String&StringBuffer

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

String

字符串的初始化和指向问题：

package cn.itcast.api.string;

public class StringDemo {

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

String str = "abcd";  //str是一个String类型的对象，现在str指向abcd
str = "haha";//现在str又指向了另外一个对象haha
System.out.println("str="+str);//这里输出的haha

//------------------------------------------------------------------------------

System.out.println("-------多个引用指向同一个字符串--------");
String s1 = "itcast";//"itcast"这个字符串在内存中躺着，s1指向了它
String s2 = "itcast";//"itcast"继续在内存中躺着，s2又指向了它
System.out.println(s1==s2);//既然s1和s2都指向了"itcast"这个字符串，那么他们指向的是不是相同呢？必然是true

//----------------------------------------------------------------------------------------

System.out.println("-------两个内容相同，创建方式不同的字符串--------");
String s3 = "abc";
String s4 = new String("abc");

//s3和s4有什么不同呢？
/*
* s3创建，在内存中只有一个对象。
*
* s4创建，在内存中有两个对象。
*/

System.out.println(s3==s4);//这里s3和s4是不是指向的同一个对象呢？必然false

}

}

String类方法的使用1：

package cn.itcast.api.string;

public class StringDemo2 {

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

//获取字符串的长度
String str = "abada";
int len = str.length();
System.out.println("len="+len);

//获取某个元素第一次出现的位置
int index = str.indexOf('a');
System.out.println("index="+index);

//从给定位置开始，获取某个元素第一次出现的位置
int index1 = str.indexOf('a',index+1);//从下标为index+1的位置开始寻找。
System.out.println("index1="+index1);

//获取某元素最后一次出现的位置
str = "smdfghjkl;wertyuiop[sdfghjklma;";
int index3 = str.lastIndexOf('m');//如果要找的字符不存在，则返回-1
System.out.println("index3="+index3);

//获取指定位置上字符
str = "itcast";
char ch = str.charAt(3);
System.out.println("ch="+ch);

//根据给定下标，获取部分字符串（包含头，不包含尾）
String s = str.substring(2, 4);
System.out.println("s="+s);

}

}

String类方法的使用2：

package cn.itcast.api.string;

public class StringTest {

public static void main(String[] args) {

//1.字符串是否以指定字符串开头
String str = "StringDemo.java";
boolean b1 = str.startsWith("Demo");//str不是以Demo开始，所以返回false

//----------------------------------------------------------
//2.str中是否包含字符串Demo
boolean b2 = str.contains("Demo");//包含，true

//----------------------------------------------------------
//4.用"test"替换"haha"
String s = str.replace("haha", "Test");//没有被替换内容时，结果是原串儿
System.out.println("s="+s);//输出结果是原串，因为str本身并不含有"haha"字符串

//----------------------------------------------------------
//6.得到str对应的数组
char[] chs = str.toCharArray();//得到str对应的字符数组
byte[] bytes = str.getBytes();//得到str对应的字节数组

//----------------------------------------------------------
//7.将str中字符的大写形式存放到upperString中
String upperString = str.toUpperCase();
System.out.println(upperString);//输出结果：STRINGDEMO.JAVA
System.out.println(str);//输出结果：StringDemo.java-解释在下面代码块中
/*
* 至于为什么上面str的输出结果是 StringDemo.java我们要记住以下几点：
* 1.字符串都是对象；
* 2.一旦初始化就不可以被更改，因为是常量；
* 3.str的toUpperCase()方法，调用后返回的是str指向的对象"StringDemo.java"的大写形式，
* 	而字符串"StringDemo.java"本身并没有改变，且st仍然指向这个字符串，所以输出结果显而易见。
* */

//----------------------------------------------------------
//8.用给定字符串切分str，返回一个字符串数组
str = "lisi,wangwu,zhaoliu";//初始化字符串
String[] names = str.split(",");//切分字符串

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

//-----------------------------------------------------------
//5,字符串如何比较大小?
int result = "ab".compareTo("aa");//只要想让对象具备比较大小的功能只需实现Comparable接口。
System.out.println("result:"+result);//A.compareTo("B")的返回值：若A大于B返回1，小于返回-1，等于返回0

}

}

字符串排序练习

package cn.itcast.api.string;

import java.util.Arrays;

public class StringTest2_1 {

public static void main(String[] args) {

/*
* 案例一：字符串数组
* ["abc","nba","cctv","itcast"]
* 要求从小到大排序。
*
*/
String[] strs = {"abc","nba","cctv","itcast"};

printArray(strs);//排序前打印

sortString(strs);//进行排序

printArray(strs);//排序后打印

}

/**
* 字符串数组
* 思路：
* 1，曾经玩过int[]排序，选择，冒泡。
* 2，字符串排序同理。
* 3，for嵌套循环。
* 4，循环中进行元素的大小比较，满足条件位置置换。
* @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){//对象比较用方法。compareTo。

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;

}
/*
* 打印字符串数组。
*/
private static void printArray(String[] strs) {
for (int i = 0; i < strs.length; i++) {
System.out.print(strs[i]+" ");
}
System.out.println();
}
}

获取字符转在另一个字符串中出现次数的练习：

package cn.itcast.api.string;

public class StringTest2_2 {

public static void main(String[] args) {

/*
*
* 案例二：
* "witcasteritcasttyuiitcastodfghjitcast"有几个itcast
*
* 思路：
* 1，无非就是在一个字符串中查找另一个字符串。indexOf。
* 2，查找到第一次出现的指定字符串后，如何查找第二个呢？
* 3，无需在从头开始，只要从第一次出现的位置+要找的字符串的长度的位置开始向后查找下一个第一次出现的位置即可。
* 4，当返回的位置是-1时，查找结束。
*/
String str = "witcasteritcasttyuiitcastodfghjitcast";
String key = "itcast";

int count = getKeyCount(str,key);
System.out.println("count="+count);
/*
int x = str.indexOf(key,0);//从头开始找。
System.out.println("x="+x);

int y = str.indexOf(key,x+key.length());//从指定起始位开始找。
System.out.println("y="+y);

int z = str.indexOf(key,y+key.length());//从指定起始位开始找。
System.out.println("z="+z);

int a = str.indexOf(key,z+key.length());//从指定起始位开始找。
System.out.println("a="+a);

int b = str.indexOf(key,a+key.length());//从指定起始位开始找。
System.out.println("b="+b);
*/
}

/**
* 获取key在str中出现次数。
* @param str
* @param key
* @return
*/
public static int getKeyCount(String str, String key) {

//1,定义变量。记录每一次找到的key的位置。
int index = 0;
//2,定义变量，记录出现的次数。
int count = 0;

//3,定义循环。只要索引到的位置不是-1，继续查找。
while((index = str.indexOf(key,index))!=-1){

//每循环一次，就要明确下一次查找的起始位置。
index = index + key.length();

//每查找一次，count自增。
count++;
}
return count;
}

}

字符串的截取练习：

package cn.itcast.api.string;

public class StringTest2_3 {

public static void main(String[] args) {
/*
* 案例三： "itcast_sh"要求，将该字符串按照长度由长到短打印出来。 itcast_sh itcast_s tcast_sh
*/

String str = "itcast";
printStringByLength(str);

}

public static void printStringByLength(String str) {

// 1，通过分析，发现是for嵌套循环。
for (int i = 0; i < str.length(); i++) {

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

//根据start，end截取字符串。
String temp = str.substring(start, end);
System.out.println(temp);

}

}

}

}

StringBuffer

1.是一个字符串缓冲区，其实就是一个容器。

2.长度是可变的，任意类型都行。但是是将任意数据都转成字符串进行存储。

3.容器对象提供很多对容器中数据的操作功能，比如：增删改查。

4.必须所有的数据最终变成一个字符串。

5.和数组最大的不同就是：数组存储完可以单独操作每一个元素，每一个元素都是独立的。

字符串缓冲区，所有存储的元素都被转成字符串，而且最后拼成了一个大的字符串。

6.可变长度数组的原理：新建数组，并复制数组元素到新数组中。

package cn.itcast.api.stringbuffer;

public class StringBufferDemo {

public static void main(String[] args) {

//1,创建一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();

//2,添加数据。不断的添加数据后，但是要对缓冲区的最后的数据进行操作，必须转成字符串才可以。
String str = sb.append(true).append("hehe").toString();//记住append方法

sb.append("haha");//sb=truehehehaha

sb.insert(2, "it");//插入 sb=truitehehehaha

sb.delete(1, 4);//删除,包含头不包含尾 sb=ttehehehaha

sb.replace(1, 4, "cast");//替换，包含头不包含尾 sb=tcastehehaha
sb.setLength(2);//保留字符串的前两个字符，其他的舍去 sb=tc
System.out.println(sb);

}

}

缓冲区的应用：无论多少数据，什么类型都不重要，只要最终变成字符串就可以StringBuffer这个容器。

StringBuffer和toString方法的使用
int[] arr = {34,12,89,68};

将一个int[]中元素转成字符串 格式 [34,12,89,68]

package cn.itcast.api.stringbuffer;

public class StringBufferTest {

public static void main(String[] args) {

int[] arr = {34,12,89,68};
String str = toString_2(arr);
System.out.println(str);
}

public static String toString_2(int[] arr) {
//1,创建缓冲区。
StringBuffer sb = new StringBuffer();

sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i!=arr.length-1){
sb.append(arr[i]+",");
}else{
sb.append(arr[i]+"]");
}
}

return sb.toString();
}

public static String toString(int[] arr) {

//用字符串连接。
String str = "[";
for (int i = 0; i < arr.length; i++) {
if(i!=arr.length-1){
str+=arr[i]+",";
}else{
str+=arr[i]+"]";
}
}
return str;
}

}

String和StringBuffer的区别

package cn.itcast.api.stringbuffer;

public class StringBufferTest2 {

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

String s1 = "hello";
String s2 = "java";
show(s1,s2);
System.out.println(s1+","+s2);
System.out.println("-----------------------");

StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("java");
show(sb1,sb2);
System.out.println(sb1+","+sb2);

}
public static void show(String s1, String s2) {

//s1.append(s2);//报错

s2.replace('a', 'o');
s1 = s2;

}
public static void show(StringBuffer sb1, StringBuffer sb2) {

sb1.append(sb2);
sb1 = sb2;

}
}

StringBuilder和StringBuffer的区别：
StringBuilder:非同步的。单线程访问效率高。

StringBuffer：同步的，多线程访问安全。

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