11 Java基础 StringBuffer

/*

基本数据类型对象包装类

byte Byte

short Short

int Integer

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.23");

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

Integer i=new Integer("123");

int num =i.intValue();//对象调用方式

十进制转成其他进制

toBinaryString()

toHexString()

toOctalString()

其他进制转成十进制

parseInt(string,radix)

*/

class Integerdemo

{

public static void sop(String str)

{

System.out.println(str);

}

public static void main(String[] args)

{

//整数类型的最大值

//sop("int max:"+Integer.MAX_VALUE);

//将一个字符串转成整数

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

long x=Long.parseLong("123");

sop("sum="+(num+4));

sop("x="+(x+4));

sop(Integer.toBinaryString(-6));

sop(Integer.toHexString(60));

int y =Integer.parseInt("110",10);

int z =Integer.parseInt("110",2);

int s =Integer.parseInt("3c",16);

sop("s="+s);

sop("z="+z);

sop("y="+y);

}

}

/*

1.5版本新特性

*/

class Integerdemo2

{

public static void sop(String str)

{

System.out.println(str);

}

public static void main(String[] args)

{

method();

//Integer x=new Integer(4);

Integer x=4;//自动装箱//new Integer(4);

x=x/*x.intValue()*/+2;//x+2:x进行自动拆箱 变成int类型和2进行加法运算

//再将和进行装箱付给x

Integer m=128;

Integer n=128;

sop("m==n:"+(m==n));

Integer a=127;

Integer b=127;

sop("a==b:"+(a==b));//结果为true 因为a和b指向了同一个Integer对象

//因为当数值在byte范围内，对于新特性 如果该数值已存在 不会在开辟新空间

}

public static void method()

{

Integer x=new Integer("123");

Integer y=new Integer(123);

sop("x==y:"+(x==y));//x y 是两个对象

sop("x.equals(y):"+x.equals(y));//equals()方法覆盖了Object 类 比较的是数值

}

}

/*

StringBuffer是字符串缓冲区 是一个容器

特点：

1而且长度是可变化的

2可以直接操作多个数据类型

3最终会通过toString（）方法变成字符串

C create U update R read D delete

1 存储

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

StringBuffer insert(index,数据)；可以将数据插入到指定index位置

2 剔除

StringBuffer delete(int start ,int end)
;删除缓冲区中的数据 包含star 不包含end

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

3 获取

char CharAt(int index);

int indexOf(String str);

int lastIndexOf(String str);

int length();

String substring(int start ,int end);//与StringBuffer操作相同

4 修改

StringBuffer replace(start ,end,string);

void setCharAt(int index,char ch);

5 反转

StringBuffer reverse();

6 将缓冲区中指定数据存储到指定字符数组中

void getChars(int srcBegain,int srcEnd,char[] dst, int dstBegain)

JDK1.5版本之后出现了StringBuilder

StringBuffer是线程同步的

StringBuilder是线程不同步的

多线程建议用StringBuffer

单线程建议用StringBuilder单线程使用可以自己加锁

升级

提高效率

简化书写

提供安全性

*/

class StringBufferdemo

{

public static void main(String[] args)

{

method_add();

mthod_del();

mthod_update();

mthod_getc();

}

public static void mthod_getc()

{

StringBuilder sb=new StringBuilder("abcde");

// StringBuffer sb=new StringBuffer("abcde");

char[] chs=new char[6];

sb.getChars(1,4,chs,1);

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

{

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

}

}

public static void mthod_update()

{

StringBuffer sb=new StringBuffer("abcde");

sb.replace(1,4,"java");//替换字符串

sb.setCharAt(2,'k');//替换一个字符

sop(sb.toString());

}

public static void mthod_del()

{

StringBuffer sb=new StringBuffer("abcde");

sb.delete(1,3);

//清空缓冲区

//sb.delete(0,sb.length());//全部删除

//sb.delete(2,3);//删除"c"

// sb.deleteCharAt(2);//删除"c"

sop(sb.toString());

}

public static void method_add()

{

StringBuffer sb=new StringBuffer();

sb.append("abc").append(true).append(34);//方法调用链

sb.insert(1,"qq");

sop(sb.toString());

/* StringBuffer sb1=sb.append(34);

sop("sb==sb1:"+(sb==sb1));

sop(sb.toString());

sop(sb1.toString());

*/

}

public static void sop(String str)

{

System.out.println(str);

}

}

/*

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

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

常见的操作有哪些？

“abcd”

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(String str);返回的是str在字符串中第一次出现的位置

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

2 判断

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

booean contains(str);

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

所以也可以用于指定判断是否包含字符串

if(str.indexOf("aa"!=-1))

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

2.2 字符串中是否有内容

boolean isEmpty();原理就是判断长度是否为零 "" null是不同的

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

boolean starsWith(str);

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

boolean endsWith(str);

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

boolean equals(str);

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

boolean equalsIgnoreCase(str);

3 转换

3.1 将字符数组转成字符串

构造函数：String(char[])

Stiing(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[])

Stiing(byte[],offset,count):将字节数组中一部分转成字符串

静态方法：

3.4 将字符串转成字节数组

byte[] getbBytes();

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

static String ValueOf(int);

static String ValueOf(double);

//3+"";//String.valueOf(3);

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

4 替换

String replace(oldchar,newchar);

5 切割

String[] split(regex);把字符串分开为几个字符串

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

String substring(begain,end);

7 转换 去除空格 比较

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

String toUpperCase();

String toLowerCase();

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

String trim();

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

int compareTo(string);

*/

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));//返回ASC(s1)-ASC(s2) 比较第一组两个不同字符即可

}

public static void method_sub()

{

String s="abcdef";

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

//sop(s.substring(20));//如果角标不存在 出现字符串角标越界

sop(s.substring(2,4));//包含头 不包含尾 s.substring(0,s.length());获取整个字符串

}

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

}

}

public static void method_replace()

{

String s="hello java";

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

String s2=s.replace('q','n');//如果要替换的字符不存在 返回的还是原串

String s3=s.replace("java","word");//替换字符串

sop("s="+s);//s不会改变

sop("s1="+s1);

sop("s2="+s2);

sop("s3="+s3);

}

public static void method_trans()

{

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

String s=new String(arr);

String s1=new String(arr,1,3);//1是起始位 3是个数

sop("s="+s);

sop("s1="+s1);

String s2 ="zxcvbm";

char[] chs=s1.toCharArray();

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

{

sop("ch="+chs[x]);

}

}

public static void method_is()

{

String str="ArrayDemo.java";

//判断文件名称是否是Array单词开头

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

//判断文件名称是否是.java的文件

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

//判断文件中是否包含Demo

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

}

public static void method_get()

{

String str="abcdeakpf";

//长度

sop(str.length());

//根据索引获取字符

sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException

//根据字符获取索引

sop(str.indexOf('a'));

sop(str.indexOf('a',3));//从位置3开始索引第一次出现a的位置

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

//反向索引一个字符出现的位置

sop(str.lastIndexOf("a"));

}

public static void main(String[] args)

{

method_7();

method_sub();

method_split();

method_replace();

method_trans();

method_is();

method_get();

/*

String s1="abc";//s1是一个类类型变量 “abc”是一个对象

//字符串最大特点：一旦被初始化就不可以被改变

String s2=new String("abc");

//s1 和s2有什么区别？

//s1在内存中一个对象

//s2在内存中有两个对象

String s3="abc";

System.out.println(s1==s2);

System.out.println(s1==s3);

System.out.println(s1.equals(s2));//String类复写了Object类中的equals方法

//该方法用于判断字符串是否相同

*/

}

public static void sop(Object obj)

{

System.out.println(obj);

}

}

class Stringtestdemo

{

public static void sop(String str)

{

System.out.println(str);

}

public static void main(String[] args)

{

String s=" ab cd ";

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

// s=myTrim(s);

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

//sop("("+reverseString(s)+")");

sop("("+reverseString(s,12,13)+")");

// sop("("+reverseString(s)+")");

}

//练习二 将字符串反转

/*

思路

1将字符串变成数组

2对数组反转

3将数组变成字符串

*/

//部分反转 将ab反转

public static String reverseString(String s,int start,int end)

{

//字符串变数组

char[] chs=s.toCharArray();

//反转数组

reverse(chs,start,end);

//将数组变字符串

return new String(chs);

}

/*public static String reverseString(String s)

{

return reverseString(s,0,s.length()-1);//调用上面的函数 从头到尾 全部反转

}*/

private static void reverse(char[] arr,int x,int y)

{

for (int start=x,end=y;start<end ;start++,end-- )

{

swap(arr,start,end);

}

}

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

{

//字符串变数组

char[] chs=s.toCharArray();

//反转数组

reverse(chs);

//将数组变字符串

return new String(chs);

}

private static void reverse(char[] arr)

{

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

{

swap(arr,start,end);

}

}

public static void swap(char[] arr,int x,int y)

{

char temp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

*/

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

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

}

}

/*

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

"abkkcdkkefkkskk"

*/

/*

class Stringtestdemo2

{

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;

}

public static void main(String[] args)

{

String str="abkkcdkkefkkskk";

sop("count="+getSubCount(str,"kk"));

}

public static void sop(String str)

{

System.out.println(str);

}

}

*/

//方式二

class Stringtestdemo2

{

public static int getSubCount_2(String str ,String key)

{

int count=0;

int index=0;

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

{

sop("index="+index);

index=index+key.length();

count++;

}

return count;

}

public static void main(String[] args)

{

String str="abkkcdkkefkkskk";

//sop("count===="+str.split("kk".length));//不建议使用

sop("count="+getSubCount_2(str,"kk"));

}

public static void sop(String str)

{

System.out.println(str);

}

}

/*

练习四

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

"abcwerthelloyuiodef"

"cvhellobnm"

思路

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

2将每个获取到的子串去长度中判断是否包含

*/

class Stringtestdemo3

{

public static String getMaxsubstring(String s1 ,String s2)

{

String max="",min="";

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

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

sop("max="+max+"---min="+min);

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

{

for (int y=0,z=min.length()-x; z!=min.length()+1;y++,z++ )

{

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

//sop(temp);

if (max.contains(temp))//或if(s1.indexOf(temp)!=-1)

{

return temp;

}

}

}

return "";

}

public static void main(String[] args)

{

String s1="abcwerthelloyuiodef";

String s2="cvhellobnm";

sop(getMaxsubstring(s1,s2));

}

public static void sop(String str)

{

System.out.println(str);

}

}