Day13Java基础学习-CSDN博客

本文链接：https://blog.csdn.net/weixin_44400192/article/details/104151298

Day13

常见对象（StringBuffer类的概述）
（1） StringBuffer类的概述
通过JDK提供的API，查看StringBuffer类的说明。
线程安全的可变符序列。
（2） StringBuffer和String的区别
String是一个不可变的字符序列
StringBuffer是一个可变的字符序列
常见对象（StringBuffer类的构造方法）
（1） StringBuffer的构造方法
public StringBuffer():无参构造方法
public StringBuffer(int capacity):指定容量的字符串缓冲区对象
public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
（2） StringBuffer的方法
public int capacity():返回当前容量。理论值
public int length():返回长度（字符数）。实际值
（3）案例演示
构造方法和长度方法的使用

package com.heima.stringbuffer;

public class Demo1_StringBuffer {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		System.out.println(sb.length());  			//容器中的字符个数，实际值
		System.out.println(sb.capacity()); 			//容器的初始容量，理论值
		
		StringBuffer sb2 = new StringBuffer(10);	//10为给定的容器大小
		System.out.println(sb2.length());
		System.out.println(sb2.capacity());
		
		StringBuffer sb3 = new StringBuffer("heima");
		System.out.println(sb3.length());			//实际字符的个数
		System.out.println(sb3.capacity());  		//字符串的length + 初始容量
		
	}

}

常见对象（StringBuffer的添加功能）
（1） StringBuffer的添加功能
public StringBuffer deleteCharAt(int index);
*可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身。
public StringBuffer deleteCharAt(int start,int end);
*在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身。

package com.heima.stringbuffer;

public class Demo2_StringBuffer {
	/*StringBuffer是字符串缓冲区，当new的时候是在堆内存创建了一个对象，底层是一个长度为16的字符数组、
	 * 当调用添加的方法时，不会重新创建对象，在不断的向原缓冲区添加字符
	 */
	
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("1234");
		sb.insert(3, "heima"); 		//在指定位置添加元素，如果没有指定位置的索引就会报索引越界异常 
		
		System.out.println(sb);   
	}

	private static void Demo1() {
		StringBuffer sb = new StringBuffer(); 
		StringBuffer sb2 = sb.append(true);
		StringBuffer sb3 = sb.append("heima");
		StringBuffer sb4 = sb.append(100);
		
		System.out.println(sb.toString()); //StringBuffer类中重写了toString方法，显示的是对象的属性值
		System.out.println(sb2.toString());
		System.out.println(sb3.toString());
		System.out.println(sb4.toString());
	}

}

常见对象（StringBuffer的删除功能）
（1） StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身；
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身。

package com.heima.stringbuffer;

public class Demo3_StringBuffer {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		//sb.deleteCharAt(5); 		//当缓冲区中这个索引上没有元素的时候就会报索引越界异常
		sb.append("heima");
		//sb.deleteCharAt(4);   		//根据索引删除指定位置上的对应的字符
		//sb.delete(0, 2);				//删除的时候包含头，不包含尾

		sb.delete(0, sb.length()); 		//清空缓冲区
		
		sb = new StringBuffer();     	//不要用这种方式清空缓冲区，因为原来的会变成垃圾
		System.out.println(sb);

	}

}

常见对象（StringBuffer的替换和反转功能）
（1） StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str):从start开始到end用str替换。
（2） StringBuffer的反转功能
public StringBuffer reverse():字符串反转。

package com.heima.stringbuffer;

public class Demo4_StringBuffer {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("我爱总复习");
		sb.replace(0, 3, "bai");		//替换
		System.out.println(sb);
		
		sb.reverse();					//反转
		System.out.println(sb);
	}
}

常见对象（StringBuffer的截取功能及注意事项）
（1） StringBuffer的截取功能
public String subString(int start):从指定位置截取到末尾；
public String subString(int start,int end):截取从指定位置开始到结束位置，包括开始位置，不包括结束位置。
（2）注意事项
注意：返回值类型不再是StringBuffer本身。

package com.heima.stringbuffer;

public class Demo5_StringMethod {

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("woaiheima");
		//String str = sb.substring(4); //从第4个位置开始截取，直到末尾
		//System.out.println(str); 	
		
		String str2 = sb.substring(4,7); //包含头不包含尾
		System.out.println(str2);
	}

}

常见对象（StringBuffer和String之间的相互转换）
（1） String — StringBuffer
*通过构造方法
*通过append()方法
（2） StringBuffer ----String
*通过构造方法
*通过toString()方法
*通过subString(0,length);

package com.heima.stringbuffer;

public class Demo6_StringBuffer {

	public static void main(String[] args) {
		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");
		System.out.println(sb2);						//通过append方法，将字符串转换成StringBuffer对象
	}

}

常见对象（把数组转成字符串）
（1）案例演示
需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：int[] arr = {1,2,3};
输出结果："[1,2,3]"
用StringBuffer的功能实现

package com.heima.test;

public class Test1 {
		/*
		 * 需求：把数组中的数据按照指定个格式拼接成一个字符串
			举例：int[] arr = {1,2,3};
			输出结果："[1,2,3]"

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

	}
	/*
	 * 将数组转换为字符串
	 * 1：返回值类型String
	 * 2:参数列表int[]
	 * 
	 * arrayToString 将数组转换成字符串
	 * array2ToString 2与to的发音是一样的，就用2替换了to,后来就成了一个书写习惯
	 */
	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("]");
			}else {
				sb.append(arr[i]).append(", ");
			}
			
		}
		return sb.toString();
	}

}

常见对象（字符串反转）
（1）案例演示
需求：把字符串反转
举例：键盘键入”abc”
输出结果：”cba”
用StringBuffer的功能实现

package com.heima.test;

import java.util.Scanner;

public class Test2 {
	/*
	 * 需求：把字符串反转
	举例：键盘键入”abc”
	输出结果：”cba”
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);  //创建键盘录入对象
		String line = sc.nextLine();		  //将键盘录入的字符串存储在line中
		
		/*StringBuffer sb = new StringBuffer(line);//将字符串转换为StringBuffer对象
		sb.reverse();							//将缓冲区的内容反转
		
		System.out.println(sb.toString());*/
		
		System.out.println(revString(line));
	}
	/*将字符串反转
	 * 1：返回值为String
	 * 2:参数列表String line
	 */
	public static String revString(String line) {
		StringBuffer sb = new StringBuffer(line);//将字符串转换为StringBuffer对象
		sb.reverse();							//将缓冲区的内容反转
		return sb.toString();
	}
}

常见对象(StringBuffer和StringBuilder的区别）

（1） StringBuilder的概述
通过查看API了解一下StringBuilder
（2）面试题：
String, StringBuffer, StringBuilder的区别
StringBuffer和StringBuilder的区别
StringBuffer是jdk1.0版本的，是线程安全的，效率低
StringBuilder是jdk1.5版本的，是线程不安全的，效率高

String, StringBuffer, StringBuilder的区别
String是一个不可变的字符序列
StringBuffer, StringBuilder是可变的字符序列
11. 常见对象（String和 StringBuffer分别作为参数传递）
（1）形式参数问题
String作为参数传递
StringBuffer作为参数传递
（2）案例演示
String和 StringBuffer分别作为参数传递问题

package com.heima.stringbuffer;

public class Demo7_StringBuffer {
	/*
	 * 基本数据类型的值传递，不改变其值；
	 * 引用数据类型的值传递，改变其值
	 * 
	 * String 类虽然是引用数据类型，但是当作参数传递时和基本数据类型是一样的，不该便其值
	 * 
	 */
	public static void main(String[] args) {
		String s = "heima";
		System.out.println(s);
		change(s);
		System.out.println(s);
		
		StringBuffer sb = new StringBuffer();
		sb.append("heima");
		change(sb);
		System.out.println(sb);  //StringBuffer可以变
	}
	private static void change(StringBuffer sb) {
		sb.append("itcast");
	}

	private static void change(String s) {
		s += "itcast";
	}
}

常见对象（数组高级冒泡排序原理图解）
（1）画图演示
需求：数组元素：{24，69，80，57，13}
请对数组元素进行排序。

冒泡排序法：轻的上浮，沉的下降。
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在最大索引处。
常见对象（数组高级冒泡排序代码实现）
（1）案例演示：数组高级冒泡排序法。

package com.heima.array;

public class Demo1_Array {

	public static void main(String[] args) {
		int[] arr = {24, 69, 80, 57, 13};
		bubbleSort(arr);
		print(arr);
	}
	/*
	 * 冒泡排序
	 * 1，返回值类型，void
	 * 2，参数类型，int[] arr
	 */
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) { 			 //只需要比较四次
			for(int j =1; j < arr.length - 1 - i; j++ ) {  //-1是为了防止索引越界,-i为了提高效率
				if(arr[j] > arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					
				}
			}
				
		}
	}
	/*
	 * 打印数组
	 * 1：返回值类型void
	 * 2:参数列表int[] arr
	 */
	public static void print(int[] arr) {
		for (int i = 0;i < arr.length; i++) {
			System.out.print(arr[i] + " ");
	
	}
	}
}

常见对象（数组高级选择排序原理图解）
（1）画图演示
需求：数组元素：{24，69，80，57，13}
请对数组元素进行排序。

选择顺序：从0开始索引，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
常见对象（数组高级选择排序代码实现）
（1）案例演示：数组高级选择排序代码

package com.heima.array;

public class Demo1_Array {

	public static void main(String[] args) {
		int[] arr = {24, 69, 80, 57, 13};
		bubbleSort(arr);
		//seleceSort(arr);
		print(arr);
	}
	/*
	 * 冒泡排序
	 * 1，返回值类型，void
	 * 2，参数类型，int[] arr
	 */
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) { 			 //只需要比较四次
			for(int j =1; j < arr.length - 1 - i; j++ ) {  //-1是为了防止索引越界,-i为了提高效率
				if(arr[j] > arr[j+1]) {
					/*int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;*/
					swap(arr, j ,j + 1);
					
				}
			}
				
		}
	}
	/*选择排序
	 * 1：返回值类型void
	 * 2：参数列表int[] arr
	 */
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {  //五个数，只需要比较arr.length-1次
			for (int j = i + 1; j < arr.length - 1 ; j++) {
				if(arr[i] > arr[j]) {
					/*int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;*/
					swap(arr, i ,j );
				}
			}
		}
	}
	/*
	 * 换位操作
	 * 1：返回值类型，void
	 * 2:参数列表int[] arr.int i ,int j
* 如果某个方法，只针对本类使用，不想让其他类使用就定义为私有
	 */
private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	/*
	 * 打印数组
	 * 1：返回值类型void
	 * 2:参数列表int[] arr
	 */
	public static void print(int[] arr) {
		for (int i = 0;i < arr.length; i++) {
			System.out.print(arr[i] + " ");
	}
	}
}

常见对象（数组高级二分查找原理图解）
（1）画图演示
*二分查找
*前提：数组元素有序
常见对象（数组高级二分查找代码实现及注意事项）
（1）案例演示：数组高级二分查找代码
（2）注意事项：如果数组无序，就不能使用二分查找。
因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

package com.heima.array;
public class Demo2_Array {
	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;
		}
}

常见对象（Arrays类的概述和方法使用）
（1） Arrays类的概述
针对数组进行操作的数据类。
提供了排序，查找等功能。
（2）成员方法

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

package com.heima.array;

import java.util.Arrays;

public class Demo3_Arrays {
	/*
	 * public static String toString(int[] a) 
	 * public static void sort(int[] a)
	 * public static int binarySearch(int[] a,int key)
	 *  
	 * toString的源码:
	 * public static String toString(int[] a) {
        if (a == null)						//如果传入的数组是null
            return "null";					//返回null
        int iMax = a.length - 1;			//iMax最大索引
        if (iMax == -1)						//如果是数组中没有元素
            return "[]";					//返回[]

        StringBuilder b = new StringBuilder();//线程不安全，效率高
        b.append('[');						  //将[添加到字符串缓冲区
        for (int i = 0; ; i++) {			  //遍历数组，判断语句没有默认是true
            b.append(a[i]);					  //把第一个元素添加进字符串缓冲区
            if (i == iMax)					 //如果索引等于最大索引值
                return b.append(']').toString();//将]添加到字符串缓冲区，再在转换成字符串并返回
            b.append(", ");  				  	//如果不等于最大索引就将，添加到缓冲区
        }
    }
    
    
    binarySearch的源码：
     private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;			//最小索引0
        int high = toIndex - 1;			//最大索引数组长度为-1

        while (low <= high) {			//最小索引小于等于最大索引可以循环判断
            int mid = (low + high) >>> 1; //求出中间索引值，（最小+最大）/2
            int midVal = a[mid];		//通过中间索引，获取中间值

            if (midVal < key) 			//中间索引对应的值小于查找的值
                low = mid + 1;			//最小索引变化
            else if (midVal > key)		//中间索引对应的值大于查找的值
                high = mid - 1;			//最大索引变化
            else
                return mid; // key found //找到了
        }
        return -(low + 1);  // key not found.//-插入点-1
    }
	 */
	public static void main(String[] args) {
		int[] arr = {33,22,11,44,66,55};
		System.out.println(Arrays.toString(arr));  //数组转字符串
		
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));  //排序
		
		int[] arr2 =  {11,22,33,44,55,66};
		System.out.println(Arrays.binarySearch(arr2, 22));
		System.out.println(Arrays.binarySearch(arr2, 66));
		System.out.println(Arrays.binarySearch(arr2, 88));  //-插入点-1
		
	}

}

常见对象（基本类型包装类的概述）
（1）为什么会有基本类型包装类
*将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
（2）常用操作（之一）：用于基本数据类型与字符串之间的转换。
（3）基本类型与包装类的对应。

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

package com.heima.wrapclass;
public class Demo1_Integer {
	public static void main(String[] args) {
		System.out.println(Integer.toBinaryString(60));
		System.out.println(Integer.toOctalString(60));
		System.out.println(Integer.toHexString(60));
	}
}

常见对象（Integer类的概述和构造方法）
（1） Integer 类的概述
通过JDK提供的API，查看Integer类的说明

Integer类在对象中包装了一个基本类型int的值。
该类提供了多个方法，能在int类型和Stringl类型之间互相转换。
还提供了处理int类型时非常有用的其他一些常量和方法。
（2）构造方法
public Interger(int value)
public Interger(String s)
（3）案例演示
使用构造方法创建对象

package com.heima.wrapclass;
public class Demo2_Integer {
	public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);  //Int的最大值
		System.out.println(Integer.MIN_VALUE);  //Int的最小值
		
		Integer i1 = new Integer(100);
		System.out.println(i1);
		
		//Integer i2 = new Integer("abc");  		//数字格式异常
		//System.out.println(i2);				    //因为abc不是数字字符串，所以会报错
		
		Integer i3 = new Integer("100");		
		System.out.println(i3);   					//输出100

	}

}

常见对象（String 和int类型的相互转换）
（1） int – String

和””进行拼接
public static String valieOf(int i)
int – Integer – String(Integer类的toString方法())
public static String toString(int i)(Integer类的静态方法）
（2） String – int
String – Integer – int
public static int parseInt(String s)

package com.heima.wrapclass;
		/*
		 * 基本数据类型有八种，其中其中都有parseXxx的方法，可以将这七种转换成基本数据类型
		 */
public class Demo3_Integer {

	public static void main(String[] args) {
			String s1 = "true";
			boolean b = Boolean.parseBoolean(s1);
			System.out.println(b);
			
			//String s2 = "abc";
			//char c = Character.p;   //char的包装类中没有parseXxx的方法。
									//字符串到字符的转换通过toCharAray()就可以把字符串转换成字符数组
	}

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

}

常见对象（JDK5的新特性自动装箱和拆箱）
（1） JDK5的新特性
*自动装箱：把基本类型转换为包装类型
*自动拆箱：把包装类型转换为基本类型
（2）案例演示
JDK5的新特性自动装箱和拆箱
Integer ii = 100；
ii +=200；
（3）注意事项
*在使用时，Integer x = null;代码就会出现NullPointerException
*建议先判断是否为null，然后再使用。

package com.heima.wrapclass;

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 c = i2 + 200;			  //自动拆箱，将对象转换成基本数据类型
		System.out.println(c);
		
		Integer i3 = null;
		int a = i3 + 100;  			  //底层用i3调用intValue,但是i3是null，null调用会出现空指针异常
		System.out.println(a);
	}

}

常见对象（Integer的面试题）
（1）Integer的面试题
看程序些结果

package com.heima.wrapclass;

public class Demo5_Integer {

	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 = 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);
		System.out.println(i7.equals(i8));//true,两个对象值同
		System.out.println("..............");
		
		/*
		 * -128到+127为byte的取值范围，如果在这个取值范围内自动装箱就不会新创建对象，而是从常量池中获取，
		 * 如果超过了byte的范围，就需要重新创建对象
		 */
		

	}

}