黑马程序员_java学习笔记13

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

Day14 String StringBuffer StringBuilder 封装类

一、String类常见方法的使用

字符串数据都是一个对象

   字符串数据一旦初始化就不可以被改变了

   字符串对象都存储于常量池中，字符串常量池。

String str1 = "abc";

String str2 = "abc";

String str3 = new String("abc");

为什么str1==str2结果为true呢？

先会在内存里创建str1以及其指向的内容"abc",当再次创建str2时，会在常量池里找是否有"abc"，

有就不会再开辟内存空间，str2直接指向已有的"abc",也就是str2和str1指向了同一个对象。

为什么str1==str3结果为false呢？

==比较的地址值，而new是重新开辟的。

为什么str1.equals(str3)结果为true呢？

String类复写了Object类的equals方法，比较的是字符串中的内容是否相同。

1、判断

A：equals(Object obj)字符串类重写了Object的方法,用于比较字符串的值是否相等。

equalsIgnoreCase(String anotherString)用于比较字符串的值是否相等.不区分大小写

B：contains(String s)判断一个字符串中是否包含另一个字符串

C：startsWith(String prefix)测试此字符串是否以指定的前缀开始。        startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

   endsWith(String suffix)测试此字符串是否以指定的后缀结束。

D：isEmpty()判断字符串是否为空

2、获取

A：int length()获取字符串的长度

B：char charAt(int index)获取指定位置的字符

把一个字符串转换成一个字符数组

String s = "HelloWorld";

//char[] ch = s.toCharArray();

char[] ch = new char[s.length()];

for(int x=0; x<ch.length; x++){

ch[x] = s.charAt(x);

}

C：获取指定的字符或者字符串在给定的字符串中第一次出现的索引

   int indexOf(int ch)获取指定字符在字符中第一次出现的索引

   int indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从  指定的索引开始搜索。

int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。

int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的 索引，从指定的索引开始。

D：获取指定的字符或者字符串在给定的字符串中最后一次出现的索引 

int lastIndexOf(int ch)返回指定字符在此字符串中最后一次出现处的索引。 

int lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 

int lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。 

int lastIndexOf(String str, int fromIndex)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 

E：获取子串

String substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。 

  String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个 子字符串。 

3、转换

A：字符串和字节数组的转换 

从String到byte[]------>byte[] getBytes() 

从byte[]到String-------->new String(byte[] by)构造方法

B：字符串和字符数组的转换 

从String到char[]

***char[] toCharArray()

***length(),charAt(int index)结合 

从char[]到String

***new String(char[] ch) 

***static copyValueOf(char[] data) 

***static String valueOf(char[] data, int offset, int count) 

C：static String valueOf(xxx y) xxx基本数据类型 

举例：int x = 4;

基本数据类型转换成字符串：String.valueOf(x);

D：static String valueOf(Object obj) 把对象转成字符串 

举例：

Demo d = new Demo();

sop(d);

sop(d.toString());

sop(String.valueOf(d));

E：String toUpperCase() 所有字符都转换为大写 

String toLowerCase() 所有字符都转换为小写

F：字符串的连接

  字符串连接符：+

  String concat(String str)  将指定字符串连接到此字符串的结尾。

  String s = "aaa" s.concat("bbb").concat("ccc").concat("ddd");

4、替换 

String replace(char oldChar, char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 

String replace(String oldString, String newString)返回一个新的字符串，它是通过用 newString 替换此字符串中出现的所有 oldString 得到的。 

5、切割

String[] split(String regex)根据给定的字符串把字符串分割.

QQ加好友: 16-22

6、去除字符串的空格 

trim() 去除字符串的前后空格

7、按字典顺序比较两个字符串。

int compareTo(String anotherString) 

二、字符串的练习

u 统计字符串中大写字母,小写字母,数字的个数

public class StringDemo5 {

/**

 * @param args

 */

public static void main(String[] args) {

String str = "sime19374,d00384oJMSIWLksiMd";

int upper_count = getCount(str)[0];

int number_count = getCount(str)[1];

int lower_count = getCount(str)[2];

System.out.println("大写字母个数："+upper_count+"   数字个数："+number_count+" 小写字母个数："+lower_count);

}

public static int[] getCount(String str) {

int upper_count = 0;

int lower_count = 0;

int number_count = 0;

int[] arr = new int[3];

char[] chs = str.toCharArray();

for (char c : chs) {

if(c>64&&c<97){

lower_count++;

}else if(c>96&&c<123){

upper_count++;

}else if(c>47&&c<58){

number_count++;

}

}

arr[0]=lower_count;

arr[1]=upper_count;

arr[2]=number_count;

return arr;

}

}

u 把字符串数组自然排序

public class StringDemo3 {

/**

 * @param args

 */

public static void main(String[] args) {

String[] str = {"cba","nba","qq","zz","abc","sb","nba"};

sort(str);

}

public static void sort(String[] str){

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

for (int j = i+1; j < str.length; j++) {

if (str[i].compareTo(str[j])>0) {

swap(str,i,j);

}

}

}

printArray(str);

}

//两个数组元素位置互换

public static void swap(String[] str, int i, int j) {

String temp = str[i];

str[i]= str[j];

str[j]= temp;

}

//打印数组

public static void printArray(String[] str){

StringBuilder sb = new StringBuilder();

sb.append("{\"");

for (int i = 0; i < str.length; i++) {

if (i!=str.length-1) {

sb.append(str[i]+"\",\"");

}else{

sb.append(str[i]+"\"}");

}

}

System.out.println(sb);

}

}

u 查找子串在大串出现的次数

public static void main(String[] args) {

String str = "nbamiknbaxxykinsajwrenbamsonba";

String s = "nba";

int count = getCount(str,s);

System.out.println(count);

}

public static int getCount(String str,String s){

int count = 0;

int index = 0;

while((index = str.indexOf(s, index))!=-1) {

index = index + s.length();

count++;

}

return count;

}

u 查找两个字符串中最大的子串(正三角)

public class StringDemo4 {

/**

 * @param args

 */

public static void main(String[] args) {

String s1 = "kjiwmiancctv8mihw";

String s2 = "wminicctv8sime";

String str = getMaxSubstring(s1, s2);

System.out.println(str);

}

//求两个字符串的最大相同子串！

public static String getMaxSubstring(String s1,String s2){

String max;

String min;

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

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

for (int i = 0; i < max.length(); i++) {

for (int j = 0,z =min.length()-i; z!=min.length()+1; j++,z++) {

String temp = min.substring(j, z); 

if(max.contains(temp)){

return temp;

}

}

}

return null;

}

}

u 对字符串中的数据进行排序

public class StringDemo6 {

/**

 * @param args

 */

public static void main(String[] args) {

String str = "34 -7 15 39 67 25";

String s = sort(str);

System.out.println(s);

}

public static String sort(String str){

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

int[] arr = new int[ss.length];

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

arr[i]=Integer.parseInt(ss[i]);

}

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

}

}

}

StringBuilder sb = new StringBuilder();

for (int i : arr) {

sb.append(i).append(" ");

}

return sb.toString();

}

private static void swap(int[] arr, int i, int j) {

int temp = arr[i];

arr[i]= arr[j];

arr[j]= temp;

}

}

三、StringBuffer&StringBuilder

1、字符串String是定长的，StringBuffer是变长的.

String s = "Hello";

s = s + "World"; //"HelloWorld"

StringBuffer buffer = new StringBuffer("Hello");

buffer.append("World");

2、append(元素)追加

insert(索引,元素)

reverse();反转

capacity();容量 它可以存储的元素个数

length();长度 它实际存储的元素个数

String substring(索引,); 

把StringBuffer中的一部分复制,然后把复制的这部分内容赋给了一个String.

3、StringBuffer,StringBuilder区别

StringBuffer 线程安全的,效率低(同步)

StringBuilder 线程不安全的,效率高(不同步)

四、封装类

基本数据类型和引用类型之间能转换吗?不能

int x = 20;

String s = x;

"10-20" 我们可以使用split方法进行切割,切割后生成了一个字符串数组 String[] strArray = {"10","20"}

int startAge = strArray[0];

int endAge = strArray[1];

为了使我们的基本数据类型和字符串能够相互转换(字符串必须是能够转换的):

我们就对基本数据类型进行了封装，使每一个基本数据类型都有一个对应的封装类，这个时候，我们就可以使用封装类中的方法进行转换.

byte  Byte

Short Short

int  Integer

long  Long

float  Float

double  Double

char  Character

boolean  Boolean

1、基本类型到封装类的转换

JDK1.5以后的新特性

Integer i = new Integer(5)

Integer ii = 5; //装箱 Integer i = new Integer(int)

Integer iii = ii + 20; //先把ii拆箱变成一个int类型的数据,然后在和20做加法,

   //最后在把结果装箱成一个Integer类型的数据.

ii.intValue();

2、基本类型到字符串的转换

String toString(); Integer类型

static String toString(int x);

3、字符串到基本类型的转换

static int parseInt(String s) 

int startAge = Integer.parseInt(strArray[0]);

int endAge = Integer.parseInt(strArray[1]);

static Integer valueOf(String s)

他们都实现了Comparable接口，具备了compareTo方法，用于比较，结果只有整数、零和负数。

基本数据类型用比较运算符进行比较，引用数据类型用compareTo进行比较。

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