StringBuffer
开发文档显示
线程安全的可变字符序列。一个类似于 String 的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步,因此任意特定实例上的所有操作就好像是以串行顺序发生的,该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端;而 insert 方法则在指定的点添加字符。
例如,如果 z 引用一个当前内容为 “start” 的字符串缓冲区对象,则此方法调用 z.append(“le”) 会使字符串缓冲区包含 “startle”,而 z.insert(4, “le”) 将更改字符串缓冲区,使之包含 “starlet”。
通常,如果 sb 引用 StringBuilder 的一个实例,则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。
当发生与源序列有关的操作(如源序列中的追加或插入操作)时,该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。
每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量,就无需分配新的内部缓冲区数组。如果内部缓冲区溢出,则此容量自动增大。从 JDK 5 开始,为该类补充了一个单个线程使用的等价类,即 StringBuilder。与该类相比,通常应该优先使用 StringBuilder 类,因为它支持所有相同的操作,但由于它不执行同步,所以速度更快。
=========================================================================
StringBuffer 属于lang包下的 故调用的时候不需要导包
要理解一个对象首先明白其构造方法
1.StringBuffer() 初始容量为16字符 表示其是一个容器(不过实际长度跟此无关 )
2.StringBuffer(CharSequence seq)就是说明任何字符串序列都可以成为其构造参数(多态)
3.StringBuffer(int capacity) 创建指定大小的字符串容器(用的特别少)
4.StringBuffer(String str) 文档说的很好我就不多说了
下面我来解释一下
StringBuffer与String的区别
相同点 在java中都是字符串对象
不同点 StringBuffer是可变序列 而String是不可变的序列(就是一旦String在内存中存在了就不能更改 只能创建新的对象 或弃之) StringBuffer更节省内存空间
其中StringBuffer与String是可以互相转换的
public class Demo6_StringBuffer {
/**
* * A:String -- StringBuffer
* a:通过构造方法
* b:通过append()方法
* B:StringBuffer -- String
* a:通过构造方法
* b:通过toString()方法
* c:通过subString(0,length);
*/
public static void main(String[] args) {
//demo1();
StringBuffer sb = new StringBuffer("heima");
String s1 = new String(sb); //通过构造将StringBuffer转换为String
System.out.println(s1);
String s2 = sb.toString(); //通过toString方法将StringBuffer转换为String
System.out.println(s2);
String s3 = sb.substring(0, sb.length()); //通过截取子字符串将StringBuffer转换为String
System.out.println(s3);
}
private static void demo1() {
StringBuffer sb1 = new StringBuffer("heima"); //通过构造方法将字符串转换为StringBuffer对象
System.out.println(sb1);
StringBuffer sb2 = new StringBuffer();
sb2.append("heima"); //通过append方法将字符串转换为StringBuffer对象
System.out.println(sb2);
}
}
然后介绍一下StringBuffer是一种安全的线程,可同步化不过效率低
而StringBuilder是一种不安全不可同步化的线程 不过效率高
举个列子 :
上厕所的时候如果门有锁 则进去麻烦不过安全
门没锁的时候 进去不麻烦但是不安全
然后StringBuffer用的比较多的方法
主要是
append 添加
insert 插入
substring 截取
replace 替换
reverse 翻转
关于参数问题其中String有点特殊(虽然是引用数据类型不过其值没有变化)
public class Demo7_StringBuffer {
/**
* * A:形式参数问题
* String作为参数传递
* StringBuffer作为参数传递
* B:案例演示
* String和StringBuffer分别作为参数传递问题
*
基本数据类型的值传递,不改变其值
引用数据类型的值传递,改变其值
String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
*/
public static void main(String[] args) {
String s = "heima";
System.out.println(s);
change(s);
System.out.println(s);
System.out.println("---------------------");
StringBuffer sb = new StringBuffer();
sb.append("heima");
System.out.println(sb);
change(sb);
System.out.println(sb);
}
public static void change(StringBuffer sb) {
sb.append("itcast");
}
public static void change(String s) {
s += "itcast";
}
}
打印结果如下
主要是面试用的上(或者参加一些比赛如蓝桥杯)
简单的冒泡排序
时间复杂度 ON^2
public class Main{
public static void main(String[] args) {
int arr[] = {51,26,32,45,125,321,12,35};
bubbleSort(arr);
print(arr);
}
public static void bubbleSort(int[] arr) {
int temp;
for(int i=0;i<arr.length-1;i++) { //n个数 总共比较n-1轮
for(int j=0;j<arr.length-1-i;j++) { //然后在每轮 比较n-1-i次
if(arr[j]>arr[j+1]) {
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
public static void print(int[] arr) {
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
选择排序(开发中不用)
public class Main{
public static void main(String[] args) {
int arr[] = {51,26,32,45,125,321,12,35};
//bubbleSort(arr);
selectSort(arr);
print(arr);
}
public static void bubbleSort(int[] arr) {
for(int i=0;i<arr.length-1;i++) {
for(int j=0;j<arr.length-1-i;j++) {
if(arr[j]>arr[j+1]) {
swap(arr,j,j+1);
}
}
}
}
//选择排序
public static void selectSort(int[] arr) {
for(int i=0;i<arr.length-1;i++) {
for(int j=i+1;j<arr.length;j++) {
if(arr[i]>arr[j]) {
swap(arr,i,j);
}
}
}
}
//引用数据类型 数组 通过此来转换
public static void swap(int arr[],int i,int j) {
int temp;
temp = arr[i] ;
arr[i] = arr[j];
arr[j] = temp;
}
public static void print(int[] arr) {
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
二分查找 (查找)
前提 :数组要有序!
目的 :查找元素所对应的索引(index)
public class Main{
public static void main(String[] args) {
int arr[] = {11,22,33,44,55,66,77,88};
int index=binarySearch(arr, 22, 0, arr.length-1);
System.out.println(index);
}
//递归二分查找返回索引值 n是指定要找的数
public static int binarySearch(int[] arr,int n,int min,int max) {
if(min>max) {
return -1; //没找到
}
int mid = (min+max)/2;
if(arr[mid]==n) {
return mid; //找到了
}else if(arr[mid]>n){
return binarySearch(arr, n, min, mid-1);
}else {
return binarySearch(arr, n, mid+1, max);
}
}
/* 0 7 mid=3
0 3 mid=1
0 0 mid=0*/
//循环二分查找返回索引值 n是指定要找的数
public static int getIndex(int[] arr,int n) {
int min = 0;
int max = arr.length-1;
int mid = (min+max)/2;
while(arr[mid]!=n) {
if(arr[mid]>n) {
max = mid -1;
}else {
min = mid +1;
}
mid =(min+max)/2;
if(min>max) {
return -1;
}
}
return mid;
}
}
================================================================
系统提供的Arrays类的方法
import java.util.Arrays;
public class Main{
public static void main(String[] args) {
int arr[] = {0,51,26,32,45,125,321,12,35};
Arrays.sort(arr); //排序
System.out.println(Arrays.toString(arr));//[0, 12, 26, 32, 35, 45, 51, 125, 321] 打印
System.out.println("目标索引是"+Arrays.binarySearch(arr, 51)); //二分索引
print(arr);
}
public static void print(int[] arr) {
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}