字符串

覆盖

 子类中方法覆盖父类方法，必须保证子类的方法权限应大于等于父类方法的权限。覆盖方法必须和被覆盖方法具有相同的方法名称，参数列表和返回值类型。

 静态只能覆盖静态。

字符串类

1 public final class String

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

2 构造方法

String()
初始化一个新创建的 String 对象，使其表示一个空字符序列。

即 String s=new String（）；

 String s=“”；两种定义方法等价  后者最方便

3 任意一个用双引号括起来的字符串都是一个String对象，一旦被初始化，就不可以改变。它是一个常量。

一旦被初始化，就不可以改变的例子如下：

Class stringdame{

Public static void main(string []args){

String s=”abc”;

String s=”kk”;

Syso(s);

//这样的代码是s原来指向“abc”这个对象，现在s指向“kk”这个对象，“abc”这个对象还是原来的”abc”对象，内容内容没有变。

}

}

4 string 有一个构造方法String(String original)，

即String s=”abc”;

String s=new String（”abc”）;使用时等价。

但有区别;

Class stringdame{

Public static void main(string []args){

String s1=”abc”;

String s2=new strign（”abc”）;

Syso(s1==s2);

Syso(s1.equals(s2));}

}

运行结果;

Faulse

ture

结果分析

String 类重写了object类中的equals方法，object类中的equals方法是比较两个对象的地址。String 类重写的object类中的equals方法，用于比较两个字符串内容是否相同。

面试题;

S1与s2有什么区别？

S1在内存中有一个对象，S2在内存中有两个对象。

注意以下代码：

Class stringdame{

Public static void main(string []args){

String s1=”abc”;

String s2=new string（”abc”）;

String s3=”abc”;

Syso(s1==s2);

Syso(s1==s3);}

}

运行结果;

Faulse

Ture

结果分析，字符串是常量，他在常量池的一个数组中存放，数组中有字符串对象s1是abc ，如果再有对象如s3是abc的话，它会直接指向原来的abc对象，而没有重新创建。所以s1==s3。

String 类适用于描述字符串事物，那么，它就提供了多个方法对字符串操作。

常量字符串的操作：

1获取 （ 非常重要）

1.1字符串的长度int length（）；数组也有长度。但那是数组的属性，调用时不加括号。

1.2根据位置获取位置上的字符char charAt（int index）；

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

int indexof（int ch）；返回的是ch（ch是阿斯科马值）在字符串中第一次出现的位置。

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

int indexof（string  str）；返回的是str在字符串中第一次出现的位置。

Int indexOf(string  str, int  fromIndex)；
应用代码：

public class Stringg {

public static void main(String[] args) {

String str="abcdeakpf";// 存放在数组中下标从0开始

//长度

sop(str.length());

 //根据索引获取字符

sop(str.charAt(4));//StringIndexOutOfBoundsException: String index out of range: 40

sop(str.lastIndexOf('a'));//从右向左查找，下标还是从左边的0开始

//根据字符获取索引

sop(str.indexOf('m',3)); //如果没有找到返回-1

}

public static void sop(Object obj){

System.out.println(obj);//返回值可能是 int string char 此处用的是装箱

}

}

运行结果：

9

E

5

-1

2判断

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

Boolean contains（str）；

特殊之处：indexof（str）；可以索引str第一次出现的位置，如果返回-1，表示str不在字符串中存在，所以，也可以用于对指定判断是否包含。

if(str.indexOf('m')！=-1）说明包含。

该方法既可以判断，又可以获取出现的位置。

2.2字符串是否有内容（即把length==0封装成isEmpty()）

  Boolean isEmpty()；原理是 当且仅当 length() 为 0 时返回 true。

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

Boolean startswith（str）；

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

Boolean endswith（str）；

2.5判断字符串内容是否相同。覆写了object中的equals方法。

 Boolean  equals（str）；

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

Boolean equalsIsIgnorecase();(邮箱登陆）

应用代码：

public class Stringg {

public static void main(String[] args) {

String str="ArrayDemo .java";

sop(str.startsWith("Array"));

sop(str.endsWith(".java"));

sop(str.contains("Demo"));

}

public static void sop(Object obj){

System.out.println(obj);//返回值可能是 int string char 此处用的是装箱

}

}

3转换

3.1将字符数组转换成字符串

用构造函数string（char【】）实现 。（在字符串初始化时完成转化）。

也可以用静态方法Static string copyValueof（char【】）；实现。

将字符数组的一部分转换成字符串

用构造函数string（char【】，offset count）实现。

也可以用static string copyValueof（char【】，int offset，int count）；实现。

代码;

public class Stringg {

public static void main(String[] args) {

char[]arr={'a','b','c','d','e','f'};

String s1=new String(arr);

    String s2=new String(arr,1,3);

sop(s1);

sop(s2);

}

public static void sop(Object obj){

System.out.println(obj);

}

}运行结果:abcdef  bcd

3.2将字符串转换成字节数组

Byte【】 getBytes（）；

3.3将字节数组转换成字符串

string（byte【】）

string（ byte【】，int offset，int count）；

3.4将字符串转换成字符数组

Char【】 tocharArray（）；

代码：

public class Stringg {

public static void main(String[] args) {

String s="aaakkfbnh";

char[] chs=s.toCharArray();

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

{

sop("chs"+chs[x]);}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

结果:chsa

chsa

chsa

chsk

chsk

chsf

chsb

chsn

chsh

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

Static String Valueof（int）；

Static String Valueof（double）；3+“”=String Valueof（3）；

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

4 替换

  String replace(char oldChar, char newChar)

代码：

public class Stringg {

public static void main(String[] args) {

String s="hello,java";

String s1=s.replace('a', 'n');

sop(s);

String s2=s.replace('p', 'n');//如果替换的字符不存在，输出的还是原串

sop(s2);

}

public static void sop(Object obj){

System.out.println(obj)；

}

}

结果:

hello,java hello,java

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

代码：

public class Stringg {

public static void main(String[] args) {

String s="hello,java";

Strings1=s.replace("java","world");

sop(s1);

}

public static void sop(Object obj){

System.out.println(obj);

}

}结果：

hello,java

hello,world

5切割

String【】 split（regex）；

代码：

public class Stringg {

public static void main(String[] args) {

String s="zhangsanmmlisimmwangwu ";

String[] s1=s.split("mm");//mm作为分隔符

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

{

sop(s1[x]);

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

运行结果：

zhangsan

lisi

wangwu 

6 获取字符串中的一部分 即字串

String substring(int beginIndex, int endIndex)；

public class Stringg {

public static void main(String[] args) {

String s="zhangsan,lisi,wangwu ";

sop(s.substring(2));// 从指定位置开始到结尾处。//如果角标不存在，会存在角标越界的异常

sop(s.substring(2,4));//包含头，不包含尾

sop(s.substring(0,s.lengh));//包含整串

}

public static void sop(Object obj){

System.out.println(obj);

}

}

结果：angsan,lisi,wangwu 

an

zhangsan,lisi,wangwu

7转换

7.1将字符串小写转大写

String touppercase（）；

String tolowercase（）；

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

String trim（）；

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

Int  compareTo（string）；

代码：

public class Stringg {

public static void main(String[] args) {

String s="    zhangsanlisiwangwu    ";

String s1="a1c";

String s2="aaa";

sop(s.toUpperCase());// 从指定位置开始到结尾处

sop(s.toLowerCase());//包含头，不包含尾

    sop(s.trim());

    sop(s1.compareTo(s2));

}

public static void sop(Object obj){

System.out.println(obj);

}

}

结果：

    ZHANGSANLISIWANGWU    

    zhangsanlisiwangwu    

zhangsanlisiwangwu

-48//只要是小于0就知道s1小于s2

1去除字符串两端空格：

public class Stringpri {

public static void sop(String str){

System.out.println(str);

}

public static String myTrim(String str){

int start=0;

int end=str.length()-1;

while(start<=end&&str.charAt(start)==' ')

start++;

while(start<=end&&str.charAt(end)==' ')

end--;

return str.substring(start, end+1);

}

public static void main(String[] args) {

String s="     abdggh     ";

sop("("+s+")");

sop(s);

}

}

2//将字符串翻转

//1 将字符串转换成数组，2将数组翻转3将数组转换成字符串

public class Stringpri {

public static String  reverseString(String s){

//字符变数组

char[] chs=s.toCharArray();

reverse(chs);

//将数组变成字符串

   return  new String(chs); 

}

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 void main(String[] args) {

String s="abcd";

sop(reverseString(s));

}

public static void sop(String str){

System.out.println(str);

}

}

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

    /*先判断kk是否存在str中，不存在则不用判断了，

     * 存在则我们获取它所在的位置index（），下一次查找的位置从c开始，

     * 计算方法是kk的位置+kk的长度，依次找，找到一次用计数器计数*/

public class Geshu {

public static void main(String[] args) {

String str="abkkcdkkefkkskk";

getSubCount( str,"kk");

System.out.println("count:");

}

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

int count=0;

int index=0;

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

System.out.println("str"+str);

str=str.substring(index+key.length());

count++;

}

return count;

}

} 结果 ：

strabkkcdkkefkkskk

strcdkkefkkskk

strefkkskk

strskk

count:4

StringBuffer是字符缓冲区

特点;

1是一个容器，是一个面盆。每次操作后，返回的对象还是原来的面盆。

2长度是可以变化的。

3可以操作多种数据类型.

4最终通过tostring方法变成字符串。

 什么时候用？

当数据类型不确定，个数不确定，最终又变成字符串时使用。

操作熟练掌握：

1添加

StringBuffer append（）；将指定的数据作为参数，添加到已有数据的结尾处。

public class Geshu {

public static void main(String[] args) {

StringBuffer ab=new StringBuffer("abcde");

StringBuffer ab1=new StringBuffer("fg");

System.out.println(ab.append(3435465));

System.out.println(ab1.append(‘a’));

}

}

结果

abcde3435465

Fga

2插入

 StringBuffer insert（index，数据）；角标不存在会出现角标越界异常。

public class Geshu {

public static void main(String[] args) {

StringBuffer ab=new StringBuffer("abcde");

System.out.println(ab.insert(2, 'm'));// 在第二个位置插入m

}

}

结果:

abmcde

3删除

StringBuffer delete（start，end）；删除缓冲区中的数据，包含头，不包含尾。

StringBuffer deleteCharAt（index）；删除指定位置的字符。

public class Geshu {

public static void main(String[] args) {

StringBuffer ab=new StringBuffer("abcde");//面盆一初始化就有东西。

System.out.println(ab.delete(1, 3));

//清空缓冲区

System.out.println("kong:"+ab.delete(0, ab.length()));

}

}

结果：

Ade

“kong:”

4获取

Char charAt(int index);

Int indexOf(string str);

Int lastindexOf(string str);

Int length();

String substring(int start ,int end);

5 替换

StringBuffer replace（int start，int end，string str）；

Void setCharAt（int index，char ch）；注意返回值为空

public class Geshu {

public static void main(String[] args) {

StringBuffer ab=new StringBuffer("abcde");

System.out.println(ab.replace(2, 4, "java"));

}

}

结果：

abjavae

6翻转

StringBuffer reverse（）；

7

public class Geshu {// 将缓冲区中指定数据存储到指定字符数组中

public static void main(String[] args) {

StringBuffer ab=new StringBuffer("abcde");

char [] chs=new char[6];

ab.getChars(1, 4, chs, 1); //包含头不包含尾所以是bcd

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

System.out.println("chs:"+chs[x]);

}

}

}

Chs[]

Chs:b

Chs:c

Chs:d

Chs:[]

Chs:[]

将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer

升级;；提高效率，提高安全性，简化代码

基本数据类型对象包装类

最常见作用就是用于基本数据类型和字符串类型做转换。

基本数据类型转成字符串：

基本数据类型+“”

基本数据类型。String（34）；将34转换成”34“

   字符串转成基本数据类型：

Int num=Interger.parseTnt(“345”);//必须传入数字格式的字符串，否则发生数组格式异常。

Iong num=Long.parselong(“345”);

另一应用进制转换

由integer 对象，返回int类型的值

Integer i=new I nteger（“123”）；

Int num=i.intValue();

Integer 类中覆写了object中的equals方法，Integer 类中的equals方法比较的是数值内容是否相同。

创建integer对象

Integer i=new Integer（4）；等同于Integer i=4；//简化书写

I=i+2;//对象加整数，i进行了自动拆箱，变成了int类型和2加法运算，再将和进行装箱赋给i。

Int i=数据

而Integer还有一个值即 i=null，当i=null，i调用方法是会有空指针异常。

Integer a=128；

Integer b=128；

Syso（a==b）flause

Integer a=127；

Integer b=127；

Syso（a==b）ture//因为a和b指向了同一个对象，因为当数值在字节范围内（-128到127），如果该数值已经存在，则不会开辟新的空间。