Java基础——Day16——包装类和StringBuffer/Builder

Day16笔记

一、包装类（掌握）

1.1 定义

• java中的一个专业名词
• 表示java中基本数据类型对应的引用数据类型
• 包装类提供一些方法，可以获取对应类型数据的常量、操作转换数据的方法

1.2 包装类分类

基本类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

二、Integer（掌握）

2.1 定义

• Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
• 此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

2.2 Integer对象创建

• Integer提供了创建对象的构造方法
• Integer(int num)
• Integer(String num)

package com.qf.pack;

public class Demo01 {
	public static void main(String[] args) {
		Integer i01 = new Integer(110);
		System.out.println(i01);
		System.out.println(i01.getClass());
		
		int i02 = 110;
		System.out.println(i02);
		// System.out.println(i02.getClass());
		
		Integer i03 = new Integer("220");
		System.out.println(i03);
		System.out.println(i03.getClass());
		
		// 创建Integer对象的时候可以传入字符串，但是字符串必须是数字字符串
		Integer i04 = new Integer("a");
		System.out.println(i04);
	}
}

2.3 Integer的字段

• 最大值
  • Integer.MAX_VALUE
• 最小值
  • Integer.MIN_VALUE

2.4 Integer常用方法

• 主要是类型之间互相转换的方法

package com.qf.pack;

public class Demo03 {
	public static void main(String[] args) {
		Integer i01 = new Integer(330);
		Integer i02 = new Integer(330);
		
		// 比较谁的大，返回0、1、-1
		int compareTo = i01.compareTo(i02);
		System.out.println(compareTo);
		
		// 字符串 ===》  Integer
		Integer i03 = Integer.decode("222");
		System.out.println(i03);
		System.out.println(i03.getClass());
		
		Integer i04 = new Integer("333");
		System.out.println(i04);
		System.out.println(i04.getClass());
		
		Integer i09 = Integer.valueOf("999");
		System.out.println(i09);
		
		// Integer ===》  字符串
		String s04 = i04.toString();
		System.out.println(s04);
		
		// Integer i06 = Integer.getInteger("777");
		// System.out.println(i06);
		
		
		// 字符串 ==》 int
		int i05 = Integer.parseInt("666");
		System.out.println(i05);
		
		
		// Integer ===》  int
		int i07 = i04.intValue();
		System.out.println(i07);
		
		// int ===》 Integer
		Integer i08 = Integer.valueOf(555);
		System.out.println(i08);
		System.out.println(i08.getClass());
		
		// 获取二进制的表示
		String binaryString = Integer.toBinaryString(60);
		System.out.println(binaryString);
		
		String hexString = Integer.toHexString(60);
		System.out.println(hexString);
		
	}
}

三、包装类的装箱和拆箱（掌握）

3.1 定义

• 装箱
  • 基本数据类型—》包装数据类型
• 拆箱
  • 包装数据类型—》基本数据类型

3.2 案例

package com.qf.pack;

public class Demo04 {
	public static void main(String[] args) {
		// 手动装箱：int ===》 Integer
		Integer i01 = new Integer(110);
		System.out.println(i01);
		
		// 手动拆箱: Integer ===> int
		int i02 = i01.intValue();
		System.out.println(i02);
		
		// 自动装箱:JDK5之后的版本实现了自定装箱和自动拆箱
		Integer i03 = 220;
		System.out.println(i03);
		System.out.println(i03.getClass());
		
		// 自动拆箱
		int i04 = i03;
		System.out.println(i04);
	}
}

四、String（重点掌握）

4.1 定义

• java中所有的字符串都是String的实例
• 字符串一旦创建，不能改变
• 如果改变的了值，就相当于把引用也改变了，就不再是原来的哪个字符串了

4.2 创建对象

​ String()
​ 初始化一个新创建的 String 对象，使其表示一个空字符序列。

		String(byte[] bytes) 
		          通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 
		String(byte[] bytes, Charset charset) 
		          通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 
		String(byte[] bytes, int offset, int length) 
		          通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。 
		String(byte[] bytes, int offset, int length, Charset charset) 
		          通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。 
		String(byte[] bytes, int offset, int length, String charsetName) 
		          通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。 
		String(byte[] bytes, String charsetName) 
		          通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 

		String(char[] value) 
		          分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。 
		String(char[] value, int offset, int count) 
		          分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 
		String(int[] codePoints, int offset, int count) 
		          分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。 
		          
		String(String original) 
		          初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 

• 案例

package com.qf.str;

import java.io.IOException;

public class Demo02 {
	public static void main(String[] args) throws IOException {
		/**
		 * 构造方法摘要 
			String() 
			          初始化一个新创建的 String 对象，使其表示一个空字符序列。 
			          
			          
			String(byte[] bytes) 
			          通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 
			String(byte[] bytes, Charset charset) 
			          通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 
			String(byte[] bytes, int offset, int length) 
			          通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。 
			String(byte[] bytes, int offset, int length, Charset charset) 
			          通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。 
			String(byte[] bytes, int offset, int length, String charsetName) 
			          通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。 
			String(byte[] bytes, String charsetName) 
			          通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 
			          
			          
			String(char[] value) 
			          分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。 
			String(char[] value, int offset, int count) 
			          分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 
			String(int[] codePoints, int offset, int count) 
			          分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。 
			          
			String(String original) 
			          初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 

		 */
		String s01 = new String();
		
		byte[] arrB = new byte[] {65,66,67,68,69,70,71};
		String s02 = new String(arrB);
		System.out.println(s02);
		
		String s03 = new String(arrB,"UTF-8");
		System.out.println(s03);
		
		String s04 = new String(arrB,2,2);
		System.out.println(s04);
		
		char[] arrC = new char[] {'a','b','c','d','e','f','g'};
		String s05 = new String(arrC);
		System.out.println(arrC);
		
		String s06 = new String(arrC,2,3);
		System.out.println(s06);
		
		String s07 = new String("Hello World!");
		System.out.println(s07);
		
	}
}

4.3 常用方法

package com.qf.str;

import java.util.Arrays;

public class Demo03 {
	public static void main(String[] args) {
		// 字符串拼接concat
		String s01 = "abc";
		String concat = s01.concat("xyz");
		System.out.println(concat);
		System.out.println(s01);
		
		// 修改
		String s02 = "abcdefghijklmnabcdefghijklmn";
		String replace = s02.replace("efg", "");
		System.out.println(replace);
		
		String replaceAll = s02.replaceAll("abc", "XXX");
		System.out.println(replaceAll);
		
		String replaceFirst = s02.replaceFirst("abc", "YYY");
		System.out.println(replaceFirst);
		
		// 拆分字符串
		String s03 = "abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmn";
		String[] split = s03.split("e");
		System.out.println(Arrays.toString(split));
		
		String[] split2 = s03.split("g", 3);
		System.out.println(Arrays.toString(split2));
		
		// 截取字符串
		String substring = s03.substring(10);
		System.out.println(substring);
		
		String substring2 = s03.substring(10, 20);
		System.out.println(substring2);
		
		// 判断是不是以XX结尾/开始
		String s04 = "abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmn";
		System.out.println(s04.startsWith("abc"));
		System.out.println(s04.endsWith("lmn"));
		
		
		// indexOf
		// lastIndexOf
		// charAt
		// getBytes
		// toUpperCase() 
		// toLowerCase() 
		// trim()
		// length
		// equals
		// valueOf
	}
}

五、StringBuffer（熟练）

5.1 定义

• 线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
• 可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

5.2 创建对象

package com.qf.sb;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 构造方法摘要 
			StringBuffer() 
			          构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。 
			StringBuffer(CharSequence seq) 
			          public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符。 
			StringBuffer(int capacity) 
			          构造一个不带字符，但具有指定初始容量的字符串缓冲区。 
			StringBuffer(String str) 
			          构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。 
		 */
		StringBuffer buffer01 = new StringBuffer();
		System.out.println(buffer01.length());
		System.out.println(buffer01.capacity());
		
		StringBuffer buffer02 = new StringBuffer(66);
		System.out.println(buffer02.length());
		System.out.println(buffer02.capacity());
		
		StringBuffer buffer03 = new StringBuffer("abcdefg");
		System.out.println(buffer03.length());
		System.out.println(buffer03.capacity());
	}
}

5.3 常用方法–增加

package com.qf.sb;

public class Demo02 {
	public static void main(String[] args) {
		/**
		 * 增
		 * 	append
		 * 		在sb对象的末尾追加
		 * 	insert
		 * 		在sb、对象指定位置插入数据
		 * 删改查
		 */
		
		StringBuffer buffer01 = new StringBuffer("abcdefg");
		
		// append
		buffer01.append(true);
		System.out.println(buffer01);
		
		buffer01.append(12.345);
		System.out.println(buffer01);
		
		buffer01.append('h');
		System.out.println(buffer01);
		
		buffer01.append("HelloWorld");
		System.out.println(buffer01);
		
		buffer01.append(new char[] {'m','n','b','v'});
		System.out.println(buffer01);
		
		System.out.println("==================================");
		
		// insert
		StringBuffer buffer02 = new StringBuffer("abcdefg");
		
		buffer02.insert(2, true);
		System.out.println(buffer02);
		
		buffer02.insert(2, new char[] {'m','n','b','v'});
		System.out.println(buffer02);
		
		
	}
}

5.4 常用方法–删除

package com.qf.sb;

public class Demo03 {
	public static void main(String[] args) {
		/**
		 * 增
		 * 删
		 * 	delete
		 * 		删除指定区间元素
		 * 	deleteCharAt
		 * 		删除指定位置元素
		 * 改查
		 */
		
		StringBuffer buffer01 = new StringBuffer("abcdefghijklmn");
		
		StringBuffer deleteCharAt = buffer01.deleteCharAt(13);
		System.out.println(buffer01);
		System.out.println(deleteCharAt);
		
		// deleteCharAt = buffer01.deleteCharAt(13);
		System.out.println(buffer01);
		System.out.println(deleteCharAt);
		
		// 包含头，不包含尾
		buffer01.delete(3, 9);
		System.out.println(buffer01);
		
	}
}

5.5 常用方法–修改

package com.qf.sb;

public class Demo04 {
	public static void main(String[] args) {
		/**
		 * 增删
		 * 改
		 * 	 StringBuffer replace(int start, int end, String str) 
			          使用给定 String 中的字符替换此序列的子字符串中的字符。 
			 StringBuffer reverse() 
			          将此字符序列用其反转形式取代。 
			 void setCharAt(int index, char ch) 
			          将给定索引处的字符设置为 ch。 
			 void setLength(int newLength) 
			          设置字符序列的长度。 
			 void trimToSize() 
			          尝试减少用于字符序列的存储空间。 
		 * 查
		 */
		StringBuffer buffer01 = new StringBuffer("abcdefghijklmn");
		buffer01.replace(0, 3, "ABCXXX");
		System.out.println(buffer01);
		
		buffer01.reverse();
		System.out.println(buffer01);
		
		buffer01.reverse();
		System.out.println(buffer01);
		
		buffer01.setCharAt(buffer01.length()-1, 'N');
		System.out.println(buffer01);
		
		System.out.println(buffer01.capacity());
		
		buffer01.trimToSize();
		System.out.println(buffer01.capacity());
		System.out.println(buffer01.length());
		
		buffer01.setLength(10);
		System.out.println(buffer01);
	}
}

5.6 常用方法–查看

package com.qf.sb;

import java.util.Arrays;

public class Demo05 {
	public static void main(String[] args) {
		/**
		 * 增删改
		 * 查
		 * 	 int capacity() 
			          返回当前容量。 
			 char charAt(int index) 
			          返回此序列中指定索引处的 char 值。 
			 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
			          将字符从此序列复制到目标字符数组 dst。 
			 int indexOf(String str) 
			          返回第一次出现的指定子字符串在该字符串中的索引。 
			 int indexOf(String str, int fromIndex) 
			          从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 
			 int lastIndexOf(String str, int fromIndex) 
			          返回最后一次出现的指定子字符串在此字符串中的索引。 
			 int length() 
			          返回长度（字符数）。 
			 String substring(int start) 
			          返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 
			 String substring(int start, int end) 
			          返回一个新的 String，它包含此序列当前所包含的字符子序列。 
			 String toString() 
			          返回此序列中数据的字符串表示形式。 
			 void trimToSize() 
			          尝试减少用于字符序列的存储空间。 
		 */
		
		StringBuffer buffer01 = new StringBuffer("abcdefghijklmn");
		System.out.println(buffer01.charAt(6));
		
		char[] arrC = new char[24];
		// 截取sb对象的内容放入char数组
		buffer01.getChars(3, 13, arrC, 3);
		System.out.println(Arrays.toString(arrC));
		
		System.out.println(buffer01.indexOf("g"));
		System.out.println(buffer01.indexOf("gg"));
		
		System.out.println(buffer01.indexOf("g",10));
		
		System.out.println(buffer01.substring(3, 10));
		
		// sb对象和字符串互转的操作
		System.out.println(buffer01.toString());
	}
}	

5.7 StringBuffer(JDK1.0)和StringBuilder(JDK 1.5)

• 速度
  • StringBuilder比较快
• 安全性
  • StringBuffer比较安全

六、BigDecimal（掌握）

6.1 定义

• 使用这个对象表示浮点型数据
• 可以进行加减乘除等运算
• 可以控制因浮点运算产生数据误差的情况

6.2 案例

package com.qf.bd;

import java.math.BigDecimal;

public class Demo01 {
	public static void main(String[] args) {
		System.out.println(10.0 / 3);
		System.out.println(1.0 - 0.9);
		BigDecimal bd01 = new BigDecimal("1.0");
		System.out.println(bd01);
		BigDecimal bd02 = new BigDecimal("0.9");
		System.out.println(bd02);
		
		BigDecimal add = bd01.add(bd02);
		System.out.println(add);
		
		BigDecimal subtract = bd01.subtract(bd02);
		System.out.println(subtract);
		
		System.out.println(bd01.multiply(bd02));
		
		// 没有确定的结果会报错,需要指定小数的位数，取舍的规则
		BigDecimal divide = bd01.divide(bd02, 3, BigDecimal.ROUND_HALF_UP);
		System.out.println(divide);
	}
}

七、Math（熟练）

7.1 定义

• 数学运算相关的类
• Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

7.2 常用方法

package com.qf.math;

public class Demo02 {
	public static void main(String[] args) {
		/**
		 * 	abs(double a) 
          		返回 double 值的绝对值。
		 * 	cbrt(double a) 
          		返回 double 值的立方根。
          	floor(double a) 
          		返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
          	ceil(double a) 
          		返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
          	max(double a, double b) 
          		返回两个 double 值中较大的一个。
          	min(double a, double b) 
          		返回两个 double 值中较小的一个。
          	pow(double a, double b) 
          		返回第一个参数的第二个参数次幂的值。
          	random() 
          		返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
          	round(double a) 
          		返回最接近参数的 long。
          	sqrt(double a) 
          		返回正确舍入的 double 值的正平方根。
		 */
		// 输出10个31--66之间的随机整数
		for (int i = 0; i < 100; i++) {
			System.out.println(Math.random());
		}
	}
}

八、System（熟练）

8.1 定义

• System 类包含一些有用的类字段和方法。它不能被实例化。

8.2 常用字段和方法

• 常用字段

字段摘要 
static PrintStream err 
          “标准”错误输出流。 
static InputStream in 
          “标准”输入流。 
static PrintStream out 
          “标准”输出流。 

• 常用方法

package com.qf.math;

public class Demo03 {
	public static void main(String[] args) {
		/**
		 * exit(int status) 
          	终止当前正在运行的 Java 虚拟机。 
		   void gc() 
          	运行垃圾回收器。 
		 */
		
		show();
		
		System.out.println(System.currentTimeMillis());
        
		for (int i = 0; i < 10; i++) {
			new Stu("zhangsan===" + i, 23 + 1);
			// 手动调用
			System.gc();
		}
		
		System.out.println("main方法运行结束");
		
	}
	
	public static void show() {
		for (int i = 0; i < 100; i++) {
			if (i == 66) {
				// break;
				// return;
				// System.exit(0);
			}
			System.out.println(i);
		}
		
		System.out.println("show方法运行结束");
	}
}


class Stu{
	String name;
	int age;
	
	public Stu(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println(this.name + "被当做垃圾回收啦啦啦啦");
	}
}

九、Date

十、SimpleDateFormat

加粗样式