JavaStringBuffer与StringBuilder，数组的排序，包装类型StringBuffer类与StringBuilder
因为String创建的对象都是常量，在对字符串进⾏拼接操作，每次拼接都会构建String对象，效率低，也耗费内存。⽽StringBuffer类和StringBuilder类解
决了这个问题，因为StringBuffer类和StringBuilder类会在原始的对象上进⾏操作，节省内存空间。
StringBuffer实际上是构造⼀个不带字符的字符缓冲区，这个缓冲区有容量，可以向字符缓冲区添加字符串，字符串的长度可变。
StringBuider与StringBuffer⼀样，但是StringBuilder效率⾼，线程不安全，⽽StringBuffer效率低线程安全。
⼀般字符串数据少的话，就⽤String创建对象，数据多单线程使⽤StringBuilder，数据多多线程使⽤StringBuffer。
StringBuffer构造⽅法：
public StringBuffer():    ⽆参构造⽅法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str):  指定字符串内容的字符串缓冲区对象
StringBuffer的⽅法：
public int capacity()：返回当前容量。理论值
public int length()：返回长度（字符数）。实际值
public static void main(String[] args){
StringBuffer buffer=new StringBuffer(16);
System.out.println(buffer.append("abbc"));
System.out.println(buffer.length());
System.out.println(buffer.capacity());
}
StringBuffer的添加功能
public StringBuffer append(String str):  可以把任意类型数据添加到字符串缓冲区⾥⾯，并返回字符串缓冲区本⾝
public StringBuffer insert(int offset,String str)：在指定位置把任意类型的数据插⼊到字符串缓冲区⾥⾯，并返回字符串缓冲区本⾝
public static void main(String[] args){
StringBuffer buffer=new StringBuffer(16);
System.out.println(buffer.append("abbc"));
System.out.println(buffer.length());
System.out.println(buffer.capacity());
System.out.println(buffer.insert(1,"ee"));//输出结果：aeebbc，在字符串索引为1处插⼊ee；
}
StringBuffer的删除功能
public StringBuffer deleteCharAt(int index)：删除指定位置的字符，并返回本⾝
public StringBuffer delete(int start,int end)：删除从指定位置开始指定位置结束的内容，并返回本⾝
public static void main(String[] args){
StringBuffer buffer=new StringBuffer("zhaorunfa");
System.out.println(buffer.deleteCharAt(8));//zhaorunf
System.out.println(buffer.delete(1,7));//zf
}
StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str): 从start开始到end⽤str替换
StringBuffer的反转功能
public StringBuffer reverse():      字符串反转
public static void main(String[] args){
StringBuffer buffer=new StringBuffer("zhaorunfa");
System.out.place(1,3,"ee"));//输出zeerunfa
System.out.verse());//输出结果afnuroeez，因为对字符串缓冲区进⾏操作会改变字符串缓冲区本⾝，上⼀步已经对字符串缓冲区进⾏了替换操作。
}
StringBuffer的截取功能
public String substring(int start):  从指定位置截取到末尾
public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
public static void main(String[] args){
StringBuffer buffer =new StringBuffer("zhaorunfa");
System.out.println(buffer.substring(4));//runfa，开始的索引字符会被截取到
System.out.println(buffer.substring(0,4));//zhao结束的索引字符不会被截取到
}
Sting类与StringBuffer相互转换
String转换StringBuffer
通过构造⽅法
通过append()⽅法
StringBuffer转换String
通过substring()⽅法
通过构造⽅法
通过toString()⽅法
public static void main(String[] args){
StringBuffer buffer =new StringBuffer("zhaorunfa");
String String();
System.out.println(s);//zhaorunfa
StringBuffer buffer1=buffer.append(s);
System.out.println(buffer1);//zhaorunfazhaorunfa
}
数组排序
冒泡排序
数组中的元素两两进⾏⽐较，⼤的往后放，⼀轮⽐较后，最⼤就会在最后，循环即可。
int arr[]={15,24,25,521,5544};
for(int j =0; j < arr.length; j++){
for(int i =0; i < arr.length -1- j; i++){
if(arr[i]< arr[i +1]){
int t = arr[i];
arr[i]= arr[i +1];
arr[i +1]= t;
}
}
}
选择排序
从0索引开始，⽤元素依次与后⾯的元素⽐较，⼀轮⽐较后，最⼩的元素就在最前⾯。
for(int index =0; index < arr.length-1; index++){
for(int i = index+1; i < arr.length-1; i++){
if(arr[index]< arr[i]){
int t = arr[i];
arr[i]= arr[i +1];
arr[i +1]= t;
}
}
}
快速排序
public void quicksort(int arr[],int start,int end){
if(start<end){
//获取分区索引
int index=getIndex(arr,start,end);
//对左右两个分区再递归调⽤
quicksort(arr, start, index-1);//左半部分
quicksort(arr, index+1, end);//右半部分
}
}
public int getIndex(int[] arr,int start,int end){
int i=start;
int j=end;
int x=arr[i];
while(i<j){
while(i<j&&arr[i]>=x){
j--;
}
if(i<j){
arr[i]=arr[j];
i++;
}
while(i<j&&arr[i]<x){
i++;
}
if(i<j){
arr[j]=arr[i];
j--;
}
}
arr[i]=x;
return i;
}
直接插⼊排序
int ar[]={12,65,34,298,79,-24,45};
for(int i =1; i <ar.length-1; i++){
int j=i;
while(j>0&&ar[j]<ar[j-1]){//进⾏判断如果j>0且后⾯元素⽐前⾯⼩，就会进⾏换位；
int t=ar[j-1];
ar[j-1]=ar[j];
ar[j]=t;
j--;//控制j索引值，使j表⽰的是要⽐的变量
}
}
⼆分查
有序数组中查，每次将数组从中间索引⼀分为⼆，看查的数与中间索引的数是否相等，若是不等，
⽐较中间索引数的⼤⼩，⼤的话在中间索引后部重复以上操作，⼩的话在中间索引前部重复以上操作。
private static int getIndex2(int[] arr,int num2){
//定义三个索引；
int minIndex=0;
int maxIndex=arr.length-1;
int midIndex=(minIndex+maxIndex)/2;
while(minIndex<=maxIndex){//当数组判断的剩⼀个数时，最⼩索引和最⼤索引重合，还需要在判断⼀次。
if(num2==arr[midIndex]){
return midIndex;
}else if(num2<arr[midIndex]){
maxIndex=midIndex-1;
}else if(num2>arr[midIndex]){
minIndex=midIndex+1;
}
//需要重新计算中间索引；
midIndex=(minIndex+maxIndex)/2;
}
return-1;//没有到返回-1
}
包装类
为了对基本类型有更多的操作，java为每⼀种基本类型提供了对应的类类型。
基本类型和包装类的对应
byte    Byte
short    Short
int        Integer
long    Long
float    Float
double      Double
char    Character
boolean          Boolean
Integer类
Integer 类在对象中包装了⼀个基本类型 int 的值,
该类提供了多个⽅法，能在 int 类型和 String 类型之间互相转换，
还提供了处理 int 类型时⾮常有⽤的其他⼀些常量和⽅法
构造⽅法
public Integer(int value)
public Integer(String s)//形参是⼀个字⾯上是数字的字符串，不然会出现数字格式化异常
public static void main(String[] args){
Integer integer=new Integer(45);
System.out.println(integer);
java的tostring方法
String s="123";
Integer integer1=new Integer(s);
System.out.println(integer1);
}
String类与int类相互转换
int--->String
通过拼接""；
通过toString⽅法
通过包装类型
通过valueOf⽅法
public static void main(String[] args){
int i=15;
String s=i+"";
int[] ints=new int[]{15,20};
System.out.String());
Integer integer=new Integer(i);
System.out.String());
System.out.println(integer.valueOf(25).toString());
}
String-->int
通过pareInt()⽅法
通过包装类型中的intValue⽅法
public static void main(String[] args){
String a="123";
Integer integer=new Integer(a);
System.out.println(integer.parseInt(a));
}
⾃动拆箱与⾃动装箱
⾃动装箱：把基本类型转换为包装类型
⾃动拆箱：把包装类型转换为基本类型
当包装类型的数据在进⾏基本运算的时候，包装类型会⾃动转换为基本类型参加运算，运算结束后，⼜会⾃动转换为包装类型。
对于Integer字符串缓冲区中已经创建好-128-127的对象，当我们对Integer类型赋值时，如果在这个范围内，他会直接去取⽤字符缓冲区已经创好的对象，如果不在范围内，就会重新创建对象。
public static void main(String[] args){
Integer i=127;
Integer i1=127;
System.out.println(i==i1);//true
Integer i2=128;
Integer i3=128;
System.out.println(i2==i3);//false
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。