Java笔记-13

StringBuffer类

StringBuffer和String的区别
* String是一个不可变的字符序列
* StringBuffer是一个可变的字符序列
StringBuffer的构造方法：
* public StringBuffer():无参构造方法
* public StringBuffer(int capacity):指定容量的字符串缓冲区对象
* public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer的方法：
* public int capacity()：返回当前容量。理论值
* public int length():返回长度（字符数）。实际值
* StringBuffer sb =new StringBuffer(); System.out.println(sb.length());//字符个数 System.out.println(sb.capacity());//初始容量，如果有字符则为初始容量+字符串length
StringBuffer的添加功能
* public StringBuffer append(String str):
* 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
* public StringBuffer insert(int offset,String str):
* 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身当没有指定位置索引会报索引越界异常。
* StringBuffer是字符串缓冲区，当new时是在堆内存创建了一个对象，底层是一个长度为16 的字符数组，当调用添加的方法时，不会再重新创建一个对象，在不断向原缓冲区添加字符。

       StringBuffer sb=new StringBuffer();
	    StringBuffer sb2=sb.append(true);
	    StringBuffer sb3 =sb.append("heihei");
	    StringBuffer sb4=sb.append(100);
	    System.out.println(sb.toString());
	    System.out.println(sb2.toString());
	    System.out.println(sb3.toString());
	    System.out.println(sb4.toString());
	    /*输出结果
	     * trueheihei100
           trueheihei100
           trueheihei100
           trueheihei100
	     */

打印的结果都是相同的，只有StringBuffer类重写了toString方法，显示的是对象属性值。

StringBuffer的删除功能
* public StringBuffer deleteCharAt(int index):
* 删除指定位置的字符，并返回本身
* public StringBuffer delete(int start,int end):
* 删除从指定位置开始指定位置结束的内容，并返回本身
StringBuffer的替换功能
* public StringBuffer replace(int start,int end,String str):
* 从start开始到end用str替换
StringBuffer的反转功能
* public StringBuffer reverse():
* 字符串反转
StringBuffer的截取功能
* public String substring(int start):
* 从指定位置截取到末尾
* public String substring(int start,int end):
* 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
*注意事项
* 注意:返回值类型不再是StringBuffer本身

StringBuffer和String的相互转换

A:String – StringBuffer
- a:通过构造方法
- b:通过append()方法
- 1 StringBuffer sb=new StringBuffer("heihei"); System.out.println(sb); 2 StringBuffer sb2=new StringBuffer(); sb2.append("heihei"); System.out.println(sb2);
B:StringBuffer – String
- a:通过构造方法
- b:通过toString()方法
- c:通过subString(0,length);

       StringBuffer sb=new StringBuffer("heihei");
	 1   String s1=new String(sb);
	    System.out.println(s1);
	    
	 2   String s2=sb.toString();
	    System.out.println(s2);
	    
	  3  String s3=sb.substring(0,sb.length());
	    System.out.println(s3);

案例：
把数组中的数据按照指定个格式拼接成一个字符串

		举例：
			int[] arr = {1,2,3};	
		输出结果：
			"[1, 2, 3]"
			
		用StringBuffer的功能实现

将数组转化成字符串：
返回值类型String
参数列表 int[]

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int []arr ={1,2,3};
		System.out.println(arrTostring(arr));

	}
	public static String arrTostring(int []arr){
		StringBuffer sb=new StringBuffer();
		sb.append("[");
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1){
				sb.append(arr[i]).append("]");
				
			}else{
			     sb.append(arr[i]).append(",");
			     
			}
		}
		return sb.toString();
	}

需求：把字符串反转
举例：键盘录入"abc"
输出结果：“cba”
用StringBuffer的功能实现

Scanner sc=new Scanner(System.in);
		String line=sc.nextLine();
		StringBuffer sb=new StringBuffer(line);  //将字符串转换为StringBuffer对象
		sb.reverse();                            //将缓冲区的内容反转
		System.out.println(sb.toString());

第二种

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		String line=sc.nextLine();
		
		System.out.println(revString(line));

	}
	public static String revString(String line){
		
		StringBuffer sb=new StringBuffer(line);
		sb.reverse();
		return sb.toString();
	}

String,StringBuffer,StringBuilder的区别
* StringBuffer和StringBuilder的区别
* StringBuffer是jdk1.0版本的,是线程安全的,效率低
* StringBuilder是jdk1.5版本的,是线程不安全的,效率高
* String和StringBuffer,StringBuilder的区别**
* String是一个不可变的字符序列
* StringBuffer,StringBuilder是可变的字符序列

String做参数传递：
String类虽然是引用数据类型，但是他当做参数传递时和基本类型是一样的

public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s="xiaoxixi";
		System.out.println(s);//输出结果xiaoxixi
		change(s);
		System.out.println(s);//输出结果xiaoxixi
				

	}
	public static void change(String s){
		s+="hahaha";
	}

StringBuffer作参数传递
它作参数传递时，和引用型数据类型一样，值改变

public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		StringBuffer sb=new StringBuffer();
		sb.append("xiaoxixi");
		System.out.println(sb);//输出结果xiaoxixi
		change(sb);
		System.out.println(sb);//输出结果xiaoxixihahaha
				

	}
	public static void change(StringBuffer sb){
		sb.append("hahaha");
	}

需求：
数组元素：{24, 69, 80, 57, 13}
请对数组元素进行排序。
冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int []arr={1,2,3,5,8,3,22,44,55,11,9};
	      bubbleSort(arr);
		System.out.println();
		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]){
					int 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]+" ");
			
		}
	}

数组高级选择排序

数组元素：{24, 69, 80, 57, 13}
* 请对数组元素进行排序。
* 选择排序
* 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

	public static void main(String[] args) {
		int []arr={1,2,3,5,8,3,22,44,55,11,9};
	     SelectSort(arr);
		System.out.println();
		print(arr);
	}
	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]){
					int 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]+" ");
			
		}
	}

数组高级二分查找代码
*注意事项
- 如果数组无序，就不能使用二分查找。
  - 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

public static int getIndex(int []arr,int value){
		int min=0;
		int max=arr.length-1;
		int mid=(min+max)/2;
		while(arr[mid]!=value){
			if (arr[mid]<value){
				min=mid+1;
				
			}else if(arr[mid]>value){
				max=mid+1;
				
			
			}
			mid=(min+max)/2;
			if(min>max){
				return -1;
			}
			}
		return mid;
	}

Arrays类的概述和方法使用

Arrays类概述
* 针对数组进行操作的工具类。
* 提供了排序，查找等功能。
成员方法
* public static String toString(int[] a)
* public static void sort(int[] a)
* public static int binarySearch(int[] a,int key)
基本类型包装类的概述
为什么会有基本类型包装类
* 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用操作
* 常用的操作之一：用于基本数据类型与字符串之间的转换。
基本类型和包装类的对应
*
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

A:Integer类概述
- 通过JDK提供的API，查看Integer类的说明
- Integer 类在对象中包装了一个基本类型 int 的值,
- 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
- 还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
- public Integer(int value)
- public Integer(String s)

String和int类型的相互转换

A:int – String
- a:和""进行拼接
- b:public static String valueOf(int i)
- c:int – Integer – String(Integer类的toString方法())
- d:public static String toString(int i)(Integer类的静态方法)

1 int i=100;
  String s1=i+"  ";
 2  string s2 =String.valueOf(i);
 3  Integer i2=new Integer(i);
     String s3=i2.toString()
4   String s4=Integet.toStriing(i);

B:String – int
- a:String – Integer – int
- public static int parseInt(String s)

   1   String s="100";
	     Integer i3= new Integer(s ) ;
	      int i4= i3.intValue    ;
	2   int i5 =Integer.parseInt(s);

Boolean类型：
String s1=“true”;
boolean.parseBoolean(s1);
基本数据类型包装类有8种，其中有七种都有parseXxx方法，可将七种的字符串表现形式转换为基本数据类型
char的包装类 Character中没有parseXxx方法，字符串到字符得转换通过toCharArray（），可将字符串转换为字符数组。

JDK5的新特性自动装箱和拆箱

A:JDK5的新特性
- 自动装箱：把基本类型转换为包装类类型
- 自动拆箱：把包装类类型转换为基本类型
B:案例演示
- JDK5的新特性自动装箱和拆箱

int  x =100;
Integer  i1=new Integer(x);    //手动装箱
Integer i2=100;  //自动装箱
int y =  i1.intValue();//手动拆箱
int   z =i2+200;//自动拆箱

* Integer ii = 100;
* ii += 200;

C:注意事项
- 在使用时，Integer x = null;代码就会出现NullPointerException。
- 建议先判断是否为null，然后再使用。

:Integer的面试题
*
看程序写结果

        Integer i1 = new Integer(97);
		Integer i2 = new Integer(97);
		System.out.println(i1 == i2); //--------false-
		System.out.println(i1.equals(i2));   //--------true
		System.out.println("-----------");
	
		Integer i3 = new Integer(197);
		Integer i4 = new Integer(197);
		System.out.println(i3 == i4);//--------false-
		System.out.println(i3.equals(i4)); //--------true
		System.out.println("-----------"); 
	
		Integer i5 = 97;
		Integer i6 = 97;
		System.out.println(i5 == i6); //--------true
		System.out.println(i5.equals(i6));//--------true
		System.out.println("-----------"); 
	
		Integer i7 = 197;
		Integer i8 = 197;
		System.out.println(i7 == i8); //--------false-
		System.out.println(i7.equals(i8)); //--------true

-128到127是byte的取值范围，如果是在这个取值范围内，自动装箱就会新创建对象，之后获取是从常量池中获取，如果超过了byte取值范围，会新创建对象。底层是创建一个数组，0存的是-128 ，255存的是127.

StringBuffer类

Arrays类的概述和方法使用

猜你喜欢