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