黑马程序员——Java基础---String类和基本数据类型包装类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

String类和基本数据类型包装类

一、String类
字符串是一个特殊的对象，字符串一旦初始化就不可以改变。

String s1="abc";//t1是一个类类型变量，"abc"是一个对象。类类型变量指向对象。

String s1 = "abc"; 与 String s2= new String("abc");区别？使用是一样的。

s1与s2的区别：s1在内存中有一个对象，s2在内存中有两个对象

(s1==s2)// false

(s1.equals(s2))// true //原因：String类复写了Object类中的equals方法，该方法用于判断字符串是否相同

String类适用于描述字符串事物。

那么它就提供了多个方法对字符串进行操作。

String类常见的操作有哪些？

1,获取

1.1 字符串中的包含的字符数，也就是字符串的长度。

int length();获取长度。

1.2 根据位置获取位置上的某个字符。

char charAt(int index);

1.3 根据字符获取该字符在字符串中的位置。

int indexOf(int ch);返回ch在字符串中第一个出现的位置。

int indexOf(int ch, int fromIndex);从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf(int str);返回str在字符串中第一个出现的位置。

int indexOf(int str, int fromIndex);从fromIndex指定位置开始，获取str在字符串中出现的位置。

2,判断

2.1字符串中是否包含某一个子串

boolean contains(str);

特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1，表示str不在字符串中存在，

所以，也可以用于对指定判断是否包含。而且该方法既可以判断，又可以获取出现的位置。

2.2字符串是否有内容

boolean isEmpty();原理是判断长度是否为0。

2.3字符串是否以指定内容开头

boolean startWith(str);

2.4字符串是否以指定内容结尾

boolean endsWith(str);

2.5判断字符串内容是否相同，复写了Object类中的equals方法。

boolean equals(str);

2.6判断内容是否相同，并忽略大小写。

boolean equalsIgnoreCase();

3,转换

3.1 将字符数组转成字符串

构造函数：String(char []);

String(char [],offset ,count);将字符数组中的一部分转成字符串。

静态方法：static String copyValueOf(char []);

static String copyValueOf(char [] data,int offset, int count);

static String ValueOf(char []);

3.2 将字符串转成字符数组

char [] toCharArray();

3.3 将字节数组转成字符串

String(byte []);

String(byte [],offset ,count);将字节数组中的一部分转成字符串。

3.4 将字符串转成字节数组

byte [] getBytes();

3.5 将基本数据类型转成字符串

static String valueOf(int)

static String valueOf(double)

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4,替换

String replace(oldchar, newchar)

5,切割

String [] split(regex);

6,子串，获取字符串中的一部分

String substring(begin);

String substring(begin,end);

7，转换，去空格，比较

7.1将字符串转成大写或小写

String toUpperCase();

String toLowerCase();

7.2将字符串两端的多个空格去除

String trim();

7.3对两个字符串进行自然顺序的比较

int compareTo(string);

<span style="font-size:18px;">class  StringMethodDemo
{
public static void method_7()
{
String s= "    Hello Java   ";
sop(s.toLowerCase());
sop(s.toUpperCase());
sop(s.trim());
String s1 = "abc";
String s2 = "aaa";
sop(s1.compareTo(s2));
}</span>

<span style="font-size:18px;">	public static void method_sub()
{
String s="abcdef";
sop(s.substring(2));//从指定位置开始到结尾，如果角标不存在，会出现角标异常越界
sop(s.substring(2,4));//包含头，不包含尾
}</span>

<span style="font-size:18px;">	public static void method_split()
{
String s= "zhangsan,lisi,wangwu";
String [] arr= s.split(",");
for(int x=0; x<arr.length; x++)
{
sop(arr[x]);
}
</span>

<span style="font-size:18px;">
public static void method_replace()
{
String s1 = "hello java";
String s2= s.replace('a','n');//如果替换的字符不存在，则返回原字符串
String s3= s.replace("java","world");
sop("s1="+s1);
sop("s2="+s2);
sop("s3="+s3);
}</span>

<span style="font-size:18px;">	public static void method_trans()
{
char [] arr = {'a','b','c','d','e'};
String s = new String(arr);
sop("s="+s);
String s1 = "zxsadc";
char [] chs = s1.toCharArray();
for(int x = 0; x<chs.length; x++)
{
sop("chs="+chs[x]);
}
}</span>

<span style="font-size:18px;">	public static void method_is()
{
String str = "ArrayDemo.java";
//判断文件名称是否是Array单词开头
sop(str.startWith("Array"));
//判断文件名称是否是.java的文件
sop(str.endsWith(".java"));
//判断文件名称是否是包含Demo
sop(str.contains("Demo"));
}</span>

<span style="font-size:18px;">	public static void method_get()
{
String str = "abcdef";
//长度
sop(str.length());
//根据索引获取字符
sop(str.charAt(4));//(40)当访问到字符串不存在的角标时会发生：角标异常越界
//根据字符获取索引
sop(str.indexOf('a',3));//('m',3)如果没有找到返回-1
//反向索引一个字符出现的位置
sop(str.lastIndexOf('a');

}</span>

<span style="font-size:18px;">	public static void main(String[] args)
{
method_7();
method_split();
method_replace();
method_trans();
method_get();
method_is();
//System.out.println("Hello World!");
}</span>

<span style="font-size:18px;">	public static void sop(Object obj)
{
System.out.println(obj);
}
}</span>

联系

1，模拟一个trim方法，去除字符串两端的空格

思路：

(1)判断字符串第一个位置是否是空格，如果是继续向下判断，知道不是空格为止，结尾处判断空格也是如此。

(2)当开和结尾都判断到不是空格时，就是要获取的字符串。

2，将一个字符串进行反转，将字符串指定部分进行反转，"abcdefg",abfedcg

思路：

(1)曾经学习过对数组的元素进行反转

(2)将字符串变成数组，对数组反转。

(3)将反转后的数组变成字符串。

(4)只要将或反转的部分的开始和结束位置作为参数传递即可。

3，获取一个字符串在另一个字符串中出现的次数。

"abkkcdkkefkkskk"

思路：

(1)定义一个计数器

(2)获取kk第一次出现的位置

(3)从第一次出现位置后剩余的字符串中继续获取kk出现的位置，每获取一次就计数一次

(4)当获取不到时，计数完成。

4，获取两个字符串中最大相同子串，第一个动作：将短的那个串进行长度一次递减的子串打印，

"abcwerthelloyuidef"

"cvhellobnm"

思路：

(1)将短的那个子串按照长度递减的方式获取到

(2)将每获取到的子串去长串中判断是否包含，如果包含，已经找到。

class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}

public static void main(String [] args)
{
<span style="font-family: Arial, Helvetica, sans-serif;"> //练习1</span>

String s="    ab cd   ";
sop("("+s+")");
s=myTrim(s);
sop("("+s+")");
<span style="font-family: Arial, Helvetica, sans-serif;">//练习2</span>

String s1="ancbsin";
sop("("+s1+")")
sop("("+reverseString(s1)+")");
sop("("+reverseString(s1,2,5)+")");
<span style="font-family: Arial, Helvetica, sans-serif;">//练习3</span>

String str = "abkkcdkkefkkskk";
sop("count="+getSubCount(str,"kk"));
//sop("count="+str.split("kk").length);不建议使用
<span style="font-family: Arial, Helvetica, sans-serif;">//练习4</span>

String s1 = "abcwerthelloyuidef";
String s2 = "cvhellobnm";
sop(getMaxSubString(s1,s2);
}

 <span style="font-family: Arial, Helvetica, sans-serif;">//练习4 获取两个字符串中最大相同子串</span>

public static String getMaxSubString(String s1,String s2)
{
String max="",min="";
max =  (s1.length()>s2.length())?s1:s2;
min =  (max==s1)?s2:s1;
for(int x=0; x<min.length();x++)
{
for(y=0,z=min.length()-x; z!=min.length()+1;y++, z++)
{
String temp = min.substring(y,z);
if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
return temp;
}
}
return 0;
}

//练习3 获取一个字符串在另一个字符串中出现的次数。

//方式1

public static int getSubCount(String str,String key)
{
int count = 0;
int index = 0;
while((index=str.indexOf(key))!=-1)
{
sop("str="+str);
str=str.substring(index+key.length());
count++;
}
return count;
}

//方式2

public static int getSubCount(String str,String key)
{
int count = 0;
int index = 0;
while((index=str.indexOf(key,index))!=-1)
{
index = index+key.length();
count++;
}
return count;
}

//练习2 将字符串反转

public static String reverseString(String s)
{
return reverseString(s,0,s.length());
}

private static void reverse(char [] arr)
{
for(int start =0, end= arr.length-1;start<end;start++,end--)
{
swap(arr,start,end);
}
}

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

//反转特定位置的字符串
public static String reverseString(String s,int start, int end)
{
//字符串变数组
char [] cha = s.toCharArray();
//反转数组
reverse(chs，start,end);
//将数组变成字符串
return new String(chs)
}

private static void reverse(char [] arr,int x, int y)
{
for(int start =x, end= y-1;start<end;start++,end--)
{
swap(arr,start,end);
}
}

//练习1 去除字符串两端空格

public static String myTrim(String str)
{
int start = 0, end = str.length()-1;
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
return str.substring(start,end+1);
}
}

二、StringBuffer

字符串的组成原理就是通过该类实现的。

StringBuffer可以对字符串内容进行增删

1，StringBuffer是一个容器,

2，StringBuffer是可变长度的

3，可以直接操作多个数据，最终会通过toString方法变成字符串。

很多方法与String相同

(1)，存储

StringBuffer append():将指定数据作为参数添加到已有数据结尾处。

StringBuffer insert(index,数据):可以将数据查到index位置上

(2)，删除

StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end

StringBuffer deleteCharAt(index):删除指定位置的字符。

(3)，获取

char charAt(int index);

int indexOf(String str);

int lastIndexOf(String str);

String substring(int start, int end)

(4)，修改

StringBuffer replace(start,end,string);

void setCharAt(int index, char ch);

(5)，反转

StringBuffer reverse();

(6)，将缓冲区中的指定数据存储到指定数组中

void getChars(int srcBegin, inr srcEnd, char [] dst, intdstBegin)

JDK版本1.5之后出现StringBuilder

StringBuffer是线程同步的，

StringBuilder是线程不同步的。

升级三个因素

1，提高效率

2，简化书写

3，提高安全性

class StringBufferDemo
{
public static void main(String [] args)
{
StringBuffer sb = new StringBuffer("abcdef");
char chs = new char [4];
sb.getChars(1,4,chs,1);
for (int x=0; x<chs.length ;x++ )
{
sop("chs["+x+"]="+chs[x]+";");
}
}

public static void method_update()
{
StringBuffer sb = new StringBuffer("abcde");
sb.replace(1,4,"java");
sb.setChartAt(2,'k');
sop(sb.toString());
}

public static void method_delete()
{
StringBuffer sb = new StringBuffer("abcde");
sb.delete(1,3);
//清空缓冲区
sb.delete(0,sb.length());
sb.deleteChatAt(2);
sop(sb.toString());
}

public static void method_add()
{
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(34);//方法调用链
//	StringBuffer sb1 = sb.append(34);
sb.insert(1,kk);
sop(sb.toString());
//	sop(sb1.toString());
}

public static void sop(String str)
{
System.out.println(str);
}
}

三、基本数据类型对象包装类

byte Byte

shotr Short

int Interger

long Long

boolean Boolean

float Float

double Double

char Character

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

基本数据类型包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换

基本数据类型转成字符串

基本数据类型+"";

基本数据类型.toString(基本数据类型值);

如：Integer.toString(34);//将整数34变成“34”；

字符串转成基本数据类型

xxx a = Xxx.parseXxx(String);

int a = Integer.parseInt("123");//必须传入数字格式的字符串

double b = Double.parseDouble("12.3");

boolean b = Boolean.parseBoolean("true");

Ineger i = new Integer("123");

int num = i.intValue();

十进制转成其他进制

toBinaryString();

toHexString();

toOctalString();

其他进制转成十进制

parseInt(string,radix);

class
{
public static void method()
{
Integer x = new Integer("123");
Integer x = new Integer(123);
sop("x==y:"+(x==y));//false
sop("x.equals(y):"+x.equals(y));//rtue

}
public static void main(String[] args)
{
//整数类型的最大值
sop("int max:"+Integer.MAX_VALUE);
//将一个字符串转换成整数
int num = Integer.parseInt("123");
sop("num="+(num+4));
sop(Integer.toBinaryString(-6));
int x = Integer.parseInt("110",2);
sop("x="+x);

Integer x = 4;//等于Integer x = new Integer(4);自动装箱
x = x/*x.intValue()*/ + 2;//对象加整数,x+2:x进行自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱付给x

Integer m = 128;
Integer n = 128;
sop("m==m:"+(m==n));//false

Integer a = 127;
Integer b = 127;
sop("a==b:"+(a==b));
/*true 因为a和b指向了同一个Integer对象。当数值在byte范围内，
对于新特性，如果该数值已经存在，则不会再开辟新的空间
*/
}
public static void sop(String str)
{
System.out.println(str);
}

}