JavaSE学习day13(StringBuffer&数组排序)

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/weixin_42135811/article/details/101642745

###13.01_常见对象(StringBuffer类的概述)

• A:StringBuffer类的概述

• 通过JDK提供的API，查看StringBuffer类的说明
• 线程安全的可变字符序列

• B:StringBuffer和String的区别

• String是一个不可变的字符序列
• StringBuffer是一个可变的字符序列

• C:一般方法

• hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx
• nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同,默认情况下，Scanner使用空格，回车等作为分隔符

###13.02_常见对象(StringBuffer类的构造方法)

• A:StringBuffer的构造方法：

• public StringBuffer():无参构造方法
• public StringBuffer(int capacity):指定容量的字符串缓冲区对象
• public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

• B:StringBuffer的方法：

• public int capacity():返回当前容量。 理论值（不掌握）
• public int length():返回长度（字符数）。 实际值

• C:案例演示

• 构造方法和长度方法的使用

###13.03_常见对象(StringBuffer的添加功能)

• A:StringBuffer的添加功能

• public StringBuffer append(String str);
  • 可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身
• public StringBuffer insert(int offset,String str);
  • 在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身

###13.04_常见对象(StringBuffer的删除功能)

• A:StringBuffer的删除功能

• public StringBuffer deleteCharAt(int index);
  • 删除指定位置的字符，并返回其本身
• public StringBuffer delete(int start,int end); //删除的时候包含头不包含尾
  • 删除从指定位置开始指定位置结束的内容，并返回本身

###13.05_常见对象(StringBuffer的替换和反转功能)

• A.StringBuffer的替换功能

• public StringBuffer replace(int start,int end,String str);
  • 从start开始到end用str替换，包含头不包含尾

• StringBuffer的反转功能

• public StringBuffer reverse();
  • 字符串反转

###13.06_常见对象(StringBuffer的截取功能及注意事项)

• A:StringBuffer的截取功能

• public String substring(int start);
  • 从指定位置截取到末尾
• publid String subtostring(int start,int end);
  • 截取从指定位置开始到结束位置，包括开始位置不包括结束位置

• B:注意事项

• 注意：返回类型不再是StringBuffer本身，而是String，所以要用String接收

###13.07_常见对象(StringBuffer和String的相互转换)

• A:String------>StringBuffer

• a.通过构造方法
• b.通过append()方法

    StringBuffer sb1 = new StringBuffer("heima");
	//通过构造方法将字符串转换为StringBuffer对象
	System.out.println(sb1);
	
	StringBuffer sb2 = new StringBuffer();
	sb2.append("heima");					
	//通过append方法将字符串转换为StringBuffer对象
	System.out.println(sb2);

• B:StringBuffer------>String

• a.通过构造方法
• b.通过toString()方法
• c.通过subString（0，length);

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

###13.08_常见对象(把数组转换成字符串)

• A:把数组中的数据按照指定格式拼接成一个字符串

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

 public static void main(String[] args) {
	int[] arr = {1,2,3};
	System.out.println(arrayToString(arr));
 }

/*
 * 将数组转换为字符串
 * 1,返回值类型String
 * 2,参数列表int[]
 */

public static String arrayToString(int[] arr) {
	StringBuffer sb = new StringBuffer();				//创建字符串缓冲区对象
	sb.append("[");										//将[添加到缓冲区
	
	
	//{1,2,3}
	for (int i = 0; i < arr.length; i++) {				//遍历数组
		//sb.append(arr[i] + ", ");						//这样做没有]
		if(i == arr.length - 1) {
			sb.append(arr[i]).append("]");				//[1, 2, 3]
		}else {
			sb.append(arr[i]).append(", ");				//[1, 2,
		}
	}
	return sb.toString();
}

###13.09_常见对象(字符串反转)

• A:把字符串反转

• 举例：
  • 键盘录入"abc"
• 输出结果：
  • “cba”
• 用StringBuffer的功能实现

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        //创建键盘录入对象
	    Scanner sc = new Scanner(System.in);				
	    //将键盘录入的字符串存储在line中
        String line = sc.nextLine();						
	
	    /*
        //将字符串转换为StringBuffer对象
        StringBuffer sb = new StringBuffer(line);	
        //将缓冲区的内容反转		
	    sb.reverse();										
	
	    System.out.println(sb.toString());*/
	
	    System.out.println(revString(line));
    }

    /*
     * 将字符串反转
     * 1,返回值类型String
     * 2,参数列表String line
     */

    public static String revString(String line) {
	    //将字符串转换为StringBuffer对象
        StringBuffer sb = new StringBuffer(line);			
	    //将缓冲区的内容反转
        sb.reverse();										
	
	    return sb.toString();
    }
}

###13.10_常见对象(StringBuffer和StringBulider的区别)

• A:StringBulider的概述

• 通过查看API了解一下StringBulider类

• 面试题

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

###13.11_常见对象(String和StringBuffer分别作为参数传递)

• A:形式参数问题

• String作为参数传递
• StringBuffer作为参数传递

• B:案例演示

• String和StringBuffer分别作为参数传递问题
• 基本数据类型的值传递不改变其值
• 引用数据类型的值传递改变其值
• String虽然是引用数据类型，但是它当做参数传递时和基本数据类型一样
• 因为String的值一旦初始化不可改变

###13.12_常见对象(数组高级冒泡排序原理图解)

• A:案例演示

• 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
• 冒泡排序：
  • 轻的上浮，沉的下降
  • 两个相邻位置相比较，如果前面的元素比后面的元素大就换位置

###13.13_常见对象(数组高级冒泡排序代码实现)

• A:案例演示

    /*
     * 冒泡排序
     * 1,返回值类型,void
     * 2,参数列表,int[] arr
     * 
     * 	第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比较4次
    	第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比较3次
    	第三次:arr[0]与arr[1],arr[1]与arr[2]比较2次
    	第四次:arr[0]与arr[1]比较1次
     */
    
    public static void bubbleSort(int[] arr) {
        //外循环只需要比较arr.length-1次就可以了
    	for (int i = 0; i < arr.length - 1; i++) {	
            //-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;*/
    				swap(arr,j,j+1);
    			}
    		}
    	}
    }
  

###13.14_常见对象(数组高级选择排序原理图解)

• A:案例演示

• 需求：对数组元素进行排序
• 选择排序：
  • 从0索引开始，依次和后面的元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

###13.15_常见对象(数组高级选择排序代码实现)

• A:案例演示

    /*
    * 选择排序
    * 1,返回值类型void
    * 2,参数列表int[] arr
    * 
    * 	第一次:arr[0]分别与arr[1-4]比较,比较4次
     	第二次:arr[1]分别与arr[2-4]比较,比较3次
        第三次:arr[2]分别与arr[3-4]比较,比较2次
        第四次:arr[3]与arr[4]比较,比较1次
    */
  
    public static void selectSort(int[] arr) {
    	//只需要比较arr.length-1次
        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;
    		    }
    	    }
        }
    }
  

###13.16_常见对象(数组高级二分查找原理图解)

• A:画图演示

• 二分查找
• 前提：数组元素有序

###13.17_常见对象(数组高级二分查找代码实现及注意事项)

• A:案例演示

• 数组二分查找代码

public class Demo2_Array {
/**
 * * A:案例演示
		* 数组高级二分查找代码
	* B:注意事项
		* 如果数组无序，就不能使用二分查找。
			* 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

 */
public static void main(String[] args) {
	int[] arr = {11,22,33,44,55,66,77};
	System.out.println(getIndex(arr, 22));
	System.out.println(getIndex(arr, 66));
	System.out.println(getIndex(arr, 88));
}

/*
 * 二分查找
 * 1,返回值类型,int
 * 2,参数列表int[] arr,int value
 */

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;			//返回-1
		}
	}
	return mid;
}
}

###13.18_常见对象(Arrays类的概述和方法使用)

• A:Arrays类概述

• 针对数组进行操作的工具类
• 提供了排序、查找等功能

• B:成员方法

• public static String toString(int[] a)
• public static void sort(int[] a)
• public static int binarySearch(int[] a,int key)

###13.19_常见对象(基本类型包装类的概述)

• A:为什么会有基本类型包装类

• 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

• B:常用操作

• 常用的操作之一：用于基本数据类型与字符串之间的转换

• C:基本类型和包装类的对应

    	* byte        Byte
    	* short       Short	
    	* int         Integer
    	* long        Long
    	* float       Float
    	* double      Double
    	* char        Character
    	* boolean     Boolean
  

###13.20_常见对象(Integer类的概述和构造方法)

• A:Integer类概述

• 通过JDK提供的API,查看Integer类的说明
• Integer类在对象中包装了一个基本类型int的值
• 该类提供了多个方法，能在int类型和String类型之间相互转换
• 还提供了处理int类型时非常有用的其他一些常量和方法

• B:构造方法

• public Integer(int value)
• public Integer(String s)

• C:案例演示

• 使用构造方法创建对象

###13.21_常见对象(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类的静态方法)

• B:String----->int

• a:String—Intrger—int
  • public static int parseInt(String s)

public class Demo3_Integer {
/**
 * * 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类的静态方法)
	* B:String -- int
		* a:String -- Integer -- int
			* public static int parseInt(String s)
	基本数据类型包装类有八种,其中七种都有parseXxx的方法
    可以将这七种的字符串表现形式转换成基本数据类型
 */
public static void main(String[] args) {
	
	//demo1();
	String s1 = "true";
	boolean b = Boolean.parseBoolean(s1);
	System.out.println(b);
	
	//String s2 = "abc";
	//char c = Character.p  //char的包装类Character中没有pareseXxx的方法
	//字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组
}

private static void demo1() {
	//int ----> String int转换成String
	int i = 100;
	String s1 = i + "";						//推荐用
	String s2 = String.valueOf(i);			//推荐用
	
	Integer i2 = new Integer(i);
	String s3 = i2.toString();
	
	String s4 = Integer.toString(i);
	System.out.println(s1);
	
	//String----> int String 转换int
	String s = "200";
	Integer i3 = new Integer(s);
	int i4 = i3.intValue();					//将Integer转换成了int数
	
	int i5 = Integer.parseInt(s);			//将String转换为int,推荐用这种
}

}

###13.22_常见对象(JDK5的新特性自动装箱和拆箱)

• A:JDK5的新特性

• 自动装箱：把基本类型转换为包装类类型
• 自动拆箱：把包装类类型转换为基本类型

• B:案例演示

• JDK5的新特性自动装箱和拆箱
• Integer ii = 100;
• ii += 200;

• C:注意事项

• 在使用时，Integer x = null;代码就会出现NullPointerException
• 建议先判断是否为空，然后再使用

public class Demo4_JDK5 {
 	public static void main(String[] args) {
   		 //int x = 100;
   		 //Integer i1 = new Integer(x);	//将基本数据类型包装成对象,装箱		
		 //int y = i1.intValue();		//将对象转换为基本数据类型,拆箱
	
		Integer i2 = 100;				//自动装箱,把基本数据类型转换成对象
		int z = i2 + 200;				//自动拆箱,把对象转换为基本数据类型
		System.out.println(z);
	
		Integer i3 = null;
		int a = i3 + 100;						
		//底层用i3调用intValue,但是i3是null,null调用方法就会出现
		//空指针异常java.lang.NullPointerException
		System.out.println(a);					
	}

}

###13.23_常见对象(Integer的面试题)

• A:案例演示

    public class Demo5_Integer {
  
    /**
     * @param args
     */
    public static void main(String[] args) {
    	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 = 127;
    	Integer i6 = 127;
    	System.out.println(i5 == i6);				//true
    	System.out.println(i5.equals(i6));			//true
    	System.out.println("-----------");
    
    	Integer i7 = 128;
    	Integer i8 = 128;
    	System.out.println(i7 == i8);               //false
    	System.out.println(i7.equals(i8));			//true
    	
    	/*
    	 * -128到127是byte的取值范围,如果在这个取值范围内,
    	 * 自动装箱就不会新创建对象,而是从常量池中获取
    	 * 如果超过了byte取值范围就会再新创建对象
    	 * 
    	 * public static Integer valueOf(int i) {
    	      assert IntegerCache.high >= 127;
    	      if (i >= IntegerCache.low && i <= IntegerCache.high)			//i>= -128 && i <= 127
    	      return IntegerCache.cache[i + (-IntegerCache.low)];
    	   return new Integer(i);
    	   }
    	 */
    }
  

  }