JAVA学习笔记11_Java语言基础（StringBuffer和基本类型包装类）

最新推荐文章于 2022-04-23 20:09:32 发布

学习路上的孟仔仔

最新推荐文章于 2022-04-23 20:09:32 发布

阅读量166

点赞数

分类专栏： JAVA

JAVA 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

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

* A:StringBuffer类概述
    * 通过JDK提供的API，查看StringBuffer类的说明
    * 线程安全的可变字符序列
* B:StringBuffer和String的区别
    * String是一个 不可变的字符序列
    * StringBuffer是一个可变的字符序列

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

* A:StringBuffer的构造方法：
* public StringBuffer():无参构造方法
* public StringBuffer(int capacity):指定容量的字符串缓冲区对象

* public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

package com.heima.stringbuffer;

public class Demo1_StringBuffer {

	/**
	 * * A:StringBuffer的构造方法：
			* public StringBuffer():无参构造方法
			* public StringBuffer(int capacity):指定容量的字符串缓冲区对象
			* public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
		* B:StringBuffer的方法：
			* public int capacity()：返回当前容量。	理论值(不掌握)
			* public int length():返回长度（字符数）。 实际值
		* C:案例演示
			* 构造方法和长度方法的使用
	 */
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		System.out.println(sb.length());			//容器中的字符个数,实际值 0
		System.out.println(sb.capacity());			//容器的初始容量,理论值  16
		
		StringBuffer sb2 = new StringBuffer(10);
		System.out.println(sb2.length());//0
		System.out.println(sb2.capacity());//10
		
		StringBuffer sb3 = new StringBuffer("heima");
		System.out.println(sb3.length());			//实际字符的个数  5
		System.out.println(sb3.capacity());			//字符串的length + 初始容量    21
		
	}

}

* B:StringBuffer的方法：
* public int capacity()：返回当前容量。理论值(不掌握)
* public int length():返回长度（字符数）。实际值

###10.03_常见对象(StringBuffer的添加功能）

* A:StringBuffer的添加功能

* public StringBuffer append(String str):

* 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

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是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组

当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区添加字符

所以输出结果为：

trueheima100

trueheima100

trueheima100

* public StringBuffer insert(int offset,String str):

* 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

StringBuffer sb = new StringBuffer("1234");
		sb.insert(3, "heima");						//在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常
		
		System.out.println(sb);

输出：123heima4

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

* A:StringBuffer的删除功能

* public StringBuffer deleteCharAt(int index):

* 删除指定位置的字符，并返回本身

* public StringBuffer delete(int start,int end):

* 删除从指定位置开始指定位置结束的内容，并返回本身

 
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		//sb.deleteCharAt(5);					//当缓冲区中这个索引上没有元素的时候就会报StringIndexOutOfBoundsException
		sb.append("heima");
		//sb.deleteCharAt(4);					//根据索引删除掉索引位置上对应的字符    heim
		//sb.delete(0, 2);						//删除的时候是包含头,不包含尾                ima
		//System.out.println(sb);
		//sb.delete(0, sb.length());				//清空缓冲区
		//System.out.println(sb);
		
		//sb = new StringBuffer();				//不要用这种方式清空缓冲区,原来的会变成垃圾,浪费内存
		System.out.println(sb);
	}

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

* A:StringBuffer的替换功能

* public StringBuffer replace(int start,int end,String str):

* 从start开始到end用str替换

StringBuffer sb = new StringBuffer("heima");
		sb.replace(0, 3, "bai");					//替换
		System.out.println(sb);

* B:StringBuffer的反转功能

* public StringBuffer reverse():

* 字符串反转

sb.reverse();
System.out.println(sb);

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

* A:StringBuffer的截取功能

* public String substring(int start):

* 从指定位置截取到末尾

* public String substring(int start,int end):

* 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
* B:注意事项

* 注意:返回值类型不再是StringBuffer本身

public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("woaiheima");
		String str = sb.substring(4);
		System.out.println(str);
		
		System.out.println(sb);
		
		String str3 = sb.substring(4, 7);
		System.out.println(str3);
	}

输出结果：

heima
woaiheima
hei

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

* A:String -- StringBuffer

* a:通过构造方法

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

* b:通过append()方法

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

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

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

* A:案例演示

package com.heima.test;

public class Test1 {

	/**
	 * * 需求：把数组中的数据按照指定个格式拼接成一个字符串
	* 
			举例：
				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[]
	 * arrayToString 将数组转换为字符串
	 */
	
	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();
	}
}

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

package com.heima.test;

import java.util.Scanner;

public class Test2 {

	/**
	 * * A:案例演示
	* 
			需求：把字符串反转
				举例：键盘录入"abc"		
				输出结果："cba"
				
			用StringBuffer的功能实现	
	 */
	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();
	}
}

###10.10_常见对象(StringBuffer和StringBuilder的区别)

* A:StringBuilder的概述
    * 通过查看API了解一下StringBuilder类
* B:面试题： String,StringBuffer,StringBuilder的区别
    * StringBuffer和StringBuilder的区别
         StringBuffer是jdk1.0版本的,是线程安全的,效率低
          StringBuilder是jdk1.5版本的,是线程不安全的,效率高

    * String和StringBuffer,StringBuilder的区别
                 String是一个不可变的字符序列
            StringBuffer,StringBuilder是可变的字符序列

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

* A:形式参数问题
* String作为参数传递

* StringBuffer作为参数传递

回忆：

基本数据类型的值传递,不改变其值

引用数据类型的值传递,改变其值

重点：

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

* B:案例演示

* String和StringBuffer分别作为参数传递问题

package com.heima.stringbuffer;

public class Demo7_StringBuffer {
	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";
	}

}

输出结果：

heima
heima
---------------------
heima
heimaitcast

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

冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

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

public static void main(String[] args) {
		int[] arr = {24, 69, 80, 57, 13};
		bubbleSort(arr);
		print(arr);
	}

public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {			//外循环只需要比较arr.length-1次就可以了
			for (int j = 0; j < arr.length - 1 - i; j++) {		//-1为了防止索引越界,-i为了提高效率
				if(arr[j] > arr[j+1]) {
					swap(arr,j,j+1);
				}
			}
		}
	}

public static void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}

/*
	 * 换位操作
	 * 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;
	}

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

* A:画图演示
* 选择排序
* 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

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

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; j++) {
				if(arr[i] > arr[j]) {
					swap(arr,i,j);
				}
			}
		}
	}

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

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

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

* A:案例演示

* 数组高级二分查找代码

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

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

###10.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)

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, 9));	//-插入点-1
	}

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

* A:为什么会有基本类型包装类
    * 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
* B:常用操作
    * 常用的操作之一：用于基本数据类型与字符串之间的转换。
* C:基本类型和包装类的对应
*
        byte             Byte
        short            Short
        int                Integer
        long            Long
        float            Float
        double            Double
        char            Character

boolean Boolean

	public static void main(String[] args) {
		System.out.println(Integer.toBinaryString(60));
		System.out.println(Integer.toOctalString(60));
		System.out.println(Integer.toHexString(60));
	}

输出结果

111100
74
3c

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

* A:Integer类概述
    * 通过JDK提供的API，查看Integer类的说明

    * Integer 类在对象中包装了一个基本类型 int 的值,
    * 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
    * 还提供了处理 int 类型时非常有用的其他一些常量和方法
* B:构造方法
    * public Integer(int value)
    * public Integer(String s)
* C:案例演示

  public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		
		Integer i1 = new Integer(100);
		System.out.println(i1);
		
		//Integer i2 = new Integer("abc");			//java.lang.NumberFormatException数字格式异常
		//System.out.println(i2);				//因为abc不是数字字符串,所以转换会报错
		
		Integer i3 = new Integer("100");
		System.out.println(i3);
	}

输出结果：

2147483647
-2147483648
100
100

###10.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类的静态方法)

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

* B:String -- int
* a:String -- Integer -- int

* public static int parseInt(String s)

		//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,推荐用这种

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

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

    * Integer ii = 100;

* ii += 200;

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调用方法就会出现
		System.out.println(a);					//空指针异常java.lang.NullPointerException
	}

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

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

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

package com.heima.wrapclass;


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);
		    }
		 */
	}

}

总结互相抓换的方法：

1.字符数组变成字符串

直接利用构造方法即可

2.字符串转换为字符数组

 String line = sc.nextLine();  
 char[] arr = line.toCharArray();//转换成字符数组

按照索引提取字符串中的某个字符

 char c = s.charAt(i);／／获取按位置索引的字符

3.string变为stringbuffer（构造方法或者 append（）方法）

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

4.stringbuffer变为string

StringBuffer sb = new StringBuffer("heima");
		
String s1 = new String(sb);						//通过构造将StringBuffer转换为String

		
String s2 = sb.toString();						//通过toString方法将StringBuffer转换为String

		
String s3 = sb.substring(0, sb.length());		                //通过截取子字符串将StringBuffer转换为String

5.string变为int（Integer类的paseInt方法）

String s = "200";
int i5 = Integer.parseInt(s);			       //将String转换为int,推荐用这种

6.int变为string（直接用+ 或者用String类的valueof）

int i = 100;
String s1 = i + "";			        //推荐用
String s2 = String.valueOf(i);			//推荐用

学习路上的孟仔仔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA学习笔记11_Java语言基础（StringBuffer和基本类型包装类）

###10.01_常见对象(StringBuffer类的概述)* A:StringBuffer类概述 * 通过JDK提供的API，查看StringBuffer类的说明 * 线程安全的可变字符序列 * B:StringBuffer和String的区别 * String是一个不可变的字符序列 * StringBuffer是一个可变的字符序列 ###10.02_常见对象(Stri...
复制链接

扫一扫