笔记

笔记11

课程内容
	1、StringBuilder
	2、基本类型的包装类
	3、正则表达式

一、StringBuilder

1、StringBuilder是一个可变的字符序列，因为在类中提供了修改私有成员变量的方法	
	常用的方法append方法和insert方法，就是在StringBuilder对象本身上，进行修改操作
2、StringBuilde和String底层都是一样的，都是维护了一个字符数组，数组的私有的，外界无法访问，因为在StringBuilder和String中提供了对数组进行操作的方法。
	StringBuilder提供的操作方法就是对StringBuilder对象本身进行操作
	String中在String对象的基础上创建一个新的字符串对象
3、String类型和StringBuilder类型关系：都是用于描述字符串的
	String是不可变的字符序列，没有提供修改私有成员变量的方法，StringBuilder是可变的字符序列，提供了修改成员变量的方法
	String长度本身也是不能发生变化的，StringBuilder长度是可以进行变化的，可以认为StringBuilder是一个自动伸缩的容器，可以用于存储数组

构造方法

1、构造方法的作用：创建当前对象，将其他数据类型，转成当前类型
2、StringBuilder构造方法：
	StringBuilder();创建一个生成器，默认初始容量大小为16
	StringBuilder(int capacity)创建一个生成器，执行初始容量大小为capacity
	StringBuilder(String str)创建一个生成器，初始值就是str这些字符，初始大小
3、获取容积的方法
	capacity():获取当前生成器容器大小
	length():获取当前生成器中字符的个数

package com.ujiuye.demos;

public class Demo_1 {
//	构造方法
	public static void main(String[] args) {
//		空参构造
		StringBuilder sb = new StringBuilder();
//		获取容积大小
		System.out.println(sb.capacity());
//		StringBuilder(int capacity)
		StringBuilder sb1 = new StringBuilder(6);
		System.out.println(sb1.capacity());
		//length
		System.out.println(sb1.length());
		
		StringBuilder sb2 = new StringBuilder("java");
		System.out.println(sb2.capacity());//20
		System.out.println(sb2.length());//4
		
	}
}

添加方法

1、append(任意类型)：可以将任意数据类型，装成字符，添加到生成器中
2、insert(int offset，任意数据类型)可以将任意的数据类型，添加到指定的位置
	说明：（1）offset，的范围是0 -->字符个数的大小
	     (2)插入数据后，数据本身的索引就是参数中执行的offset

package com.ujiuye.demos;

public class Demo_2 {
	public static void main(String[] args) {
//		添加方法
		StringBuilder sb = new StringBuilder();
		
//		sb.append(1.2);
//		sb.append(true);
//		sb.append('a');
//		sb.append(1).append(1.3).append(true).append('l');
		sb.append("abcd");
		sb.append("abcd");
		sb.append("abcd");
		sb.append("abcd");
		sb.append("a");
		System.out.println(sb.capacity());
		System.out.println(sb);
		System.out.println("-----------------------------insert--------------------------");
//		insert方法
		StringBuilder sb1 = new StringBuilder();
		sb1.insert(0, 123);
		sb1.insert(3, true);
		sb1.insert(0,'O');
		System.out.println(sb1);
//		String str = "abc";
//		String substring = str.substring(2);
//		System.out.println(substring);
	}
}

删除方法

1、deleteCharAt(int index):删除的是执行索引的字符
2、delete(int start,int end):删除的是指定范围的字符，被删除的部分包含头不包含尾

package com.ujiuye.demos;

public class Demo_3 {
	public static void main(String[] args) {
//		删除功能
		StringBuilder sb = new StringBuilder("我爱北京天安门");
//		删除其中的一个字符
		sb.deleteCharAt(0);
		System.out.println(sb);
//		删除指定范围的字符串
		sb.delete(1, 3);
		System.out.println(sb);
	}
}

替换和反转方法

1、replace(int start,int end,String str)
	将字符串缓冲区中的从start开始到end - 1这部分的内容，替换成str
2、reverse：将原有的字符序列进行反转

package com.ujiuye.demos;
public class Demo_4 {
//	替换和反转方法
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("I Love boy");
//		替换方法
		sb.replace(7, 10, "gril");
		System.out.println(sb);
//		反转方法 reverse();
		StringBuilder sb1 = new StringBuilder("123456");
		sb1.reverse();
		System.out.println(sb1);
//		
	}
}

练习

1、定义一个数组int[] arr = {1,2,3};
	使用String完成拼接
	使用StringBuilder完成拼接
	效果：[1,2,3]
2、定义一个String类型字符串，完成对String类型字符串的反转

package com.ujiuye.demos;

public class Demo_5 {
//	定义一个数组int[] arr = {1,2,3};
//	使用String完成拼接
//	使用StringBuilder完成拼接
//	效果：[1,2,3]
	public static void main(String[] args) {
		int[] arr = new int[10000];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i;
		}
		long start = System.currentTimeMillis();
		test_2(arr);
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}

	private static void test_2(int[] arr) {
		// 使用StringBuilder进行拼接
		StringBuilder sb = new StringBuilder("[");
		for (int i = 0; i < arr.length; i++) {
			sb.append(arr[i]).append((i == arr.length - 1) ? "]" : ",");
		}
		String string = sb.toString();
//		System.out.println(sb);
	}

	private static void test_1(int[] arr) {
		// 使用String拼接
		String str = "[";
		for (int i = 0; i < arr.length; i++) {
			str += arr[i];
			// 判断是否是最后一个元素，如果是最后一个拼接]如果不是拼接 ，
			if (i == arr.length - 1) {
				str += "]";
			} else {
				str += ',';
			}
		}
//		System.out.println(str);
	}
}

StringBuilder 和StringBuffer

1、共同点：	
	都是字符串的缓冲区，都是字符串的生成器，都是可变的字符序列
2、不同点：
	（1）出现的版本不同：	
		StringBuffer在jdk1.0的时候出现了
		StringBuilder在jdk1.5的时候出现
	（2）线程的安全性：
		StringBuffer是线程安全的，在多线程的环境下仍然能保证数据安全
		StringBuilder是线程不安全的，在多线程的环境下无法保证数据安全
	（3）效率不同：
		StringBuffer效率低
		StringBuilder效率高

String和StringBulider作为方法的参数

1、String作为方法的参数进行传递，无法修改原值。在被调用的方法中，修改引用指向对象，和主方法中的引用无关。

2、StringBuilder作为方法的参数进行传递，如果在被调用的方法中，修改的是StringBuilder的引用，那么不会修改原有数据中的内容

3、如果StringBuilder作为方法的参数进行传递，如果在被调用方法中通过该引用修改了对象的数据，那么原值就会发生改变

二、基本类型的包装类

1、基本的数据类型有八种，都是非常简单的数据
2、在这些类型中，只能表示简单的数据，不能包含一些操作数据的方法，没有办法存储描述这些数据的内容。
需要准备一个引用数据类型，能将基本数据类型进行包装，提供一些操作基本数据类型的方法，定义一些描述数据的类型。
3、基本数据类型的包装类
	byte               Byte
	short              Short
	int                Integer
	long               Long
	float              Float
	double             Double
	boolean            Boolean
	char               Character

Integer类型

1、各种包装类类型方法，特点基本相同，只要学习一个Integer类型，其他的能够触类旁通。
2、Integer类型对象中，底层就是维护了一个私有的成员变量，是一个int类型的字段，用于表示Integer对象要表示的数字
3、提供了在int，Integer，String类型之间的相互转换的方法，进制上转换的方法
4、提供了一些常量

Integer类型的构造方法

1、Integer(int i)：将一个基本数据类型的的int数，转换成Integer类型的对象
	把i这个int类型的变量，赋值给Integer对象中维护的私有的成员变量value
2、Integer(String num)：将一个字符串类型的数字，转换成Integer类型的对象
	转换的作用
	String---》Integer前提String类型的对象必须是数字类型的。

package com.ujiuye.demos;

public class Demo_11 {	
	public static void main(String[] args) {
//		Integer类型的构造方法
		Integer in1 = new Integer(123);
		System.out.println(in1);
//		Integer(String str)
		Integer in2 = new Integer("123");
		System.out.println(in2 + 1);
	}
}	

Integer中的成员方法

1、xxxValue()方法：可以将Integer类型的对象，转成其他基本数据类型的数据
	intValue(),byteValue()....
2、常用的静态方法
	parseInt（String str）:将str以十进制的方式解读为一个int数
	parseInt(String s, int radix)将str按照指定的radix进制解析为一个int数字（十进制）
	toBinaryString(int i) 将十进制的i通过二进制进行表示  10进制--》2进制
	toOctalString(int i) 将十进制的i通过  八进制进行表示  10进制--》8进制
	toHexString(int i) 将十进制的i通过  十六进制进行表示  10进制--》16进制
	toString(int i, int radix) ：将任意一个十进制的数字，转成任意进制的字符串表示
	valueOf(String s, int radix)将str以指定的radix进制进行解析

package com.ujiuye.demos;

public class Demo_12 {
//	Integer类型中的成员方法
	public static void main(String[] args) {
//		xxxValue()方法
		Integer in1 = new Integer(129);
		byte byteValue = in1.byteValue();
		System.out.println(byteValue);
		System.out.println(in1.floatValue());
		System.out.println(in1.doubleValue());
		System.out.println(in1.longValue());
		System.out.println(in1.shortValue());
		System.out.println("-----------------------------------");
//		常用的静态方法
//		parseInt（String str）:将str以十进制的方式解读为一个int数
		System.out.println(Integer.parseInt("888"));
//		parseInt(String s, int radix):将str按照指定的radix进制解析为一个int数字（十进制）
		System.out.println(Integer.parseInt("11", 2));
		System.out.println(Integer.parseInt("a", 13));
		System.out.println("-=================10进制--》2进制==================");
//		toBinaryString(int i);将十进制的i通过二进制进行表示  10进制--》2进制
		System.out.println(Integer.toBinaryString(8));
		System.out.println("-=================10进制--》8进制==================");
//		toOctalString(int i) 将十进制的i通过  八进制进行表示  10进制--》8进制
		System.out.println(Integer.toOctalString(64));
//		toHexString(int i) 将十进制的i通过  十六进制进行表示  10进制--》16进制 
		System.out.println("-=================10进制--》16进制==================");
		System.out.println(Integer.toHexString(484));// 1 * 16 ^2 + e * 16 + 4 + 16^0
//		                                                    256  + 224 + 4 = 484
		System.out.println("---------------------------------------------------");
//		toString(int i, int radix) ：将任意一个十进制的数字，转成任意进制的字符串表示
		System.out.println(Integer.toString(10000, 9));
		System.out.println(Integer.toString(10000, 36));//将十进制转为其他进制的字符串
		System.out.println("======================");
//		valueOf(String s, int radix)将str以指定的radix进制进行解析
		System.out.println(Integer.valueOf("7ps", 36));//其他进制转为 十进制的Integer类型的数据
//		0 1 2 3 4 5 6 7 8 9 a b c d e f g
	}
}

Integer类型的常量

1、MAX_VALUE:int类型的最大值
2、MIN_VALUE:int类型的最小值
3、SIZE：int类型在内存中的位数
4、TYPE：int类型字节码对象

package com.ujiuye.demos;

public class Demo_13 {
	public static void main(String[] args) {
//		Integer类型中的常量
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		System.out.println(Integer.SIZE);
		System.out.println(Integer.TYPE);
	}
}

自动拆箱和自动装箱（jdk1.5）

1、装箱和拆箱
	装箱：将基本的数据类型，封装成包装类类型的对象，这个过程就是装箱使用构造方法即可
	拆箱：将包装类类型对象转成基本的数据类型，这个过程就是拆箱，使用intValue()即可
2、自动装箱和自动拆箱
	自动装箱：可以直接使用基本的数据类型，给引用的数据类型进行赋值
	自动拆箱：可以直接使用包装类对象，给基本数据类型赋值；或者是包装类类型对象直接参与算数运算

package com.ujiuye.demos;
public class Demo_14 {
//	自动装箱和自动拆箱
	public static void main(String[] args) {
//		装箱     基本数据类型---》包装类类型
		Integer in1 = new Integer(123);
//		拆箱      包装类类型----> 基本数据类型
		int intValue = in1.intValue();
		System.out.println(intValue);
//		自动装箱
		Integer in2 = 520;
		System.out.println(in2);
//		自动拆箱
		int i = in2;
		System.out.println(i);
		System.out.println(in2 + 100);
	}
}

三、正则表达式

1、概述：
	本质上就是一个字符串
2、作用：不仅表示的是一个字符串，还可以表示一类字符串，表示一类字符串的规则或者格式。
3、好处：可以使用特别简单的代码，表示非常复杂的规则
4、坏处：写出正则的表达式的正确率不高

正则表达式的好处

1、需要：
	键盘录入一个字符串，判断是否是一个合法的qq号码
合法qq号码的条件；
	必须是5 - 12位
	必须全都是数字
	0不能开头
	

没有使用正则
package com.ujiuye.demos;

import java.util.Scanner;

public class Demo_15 {
	public static void main(String[] args) {
//		键盘录入一个字符串，判断是否是一个合法的qq号码
//		合法qq号码的条件；
//		必须是5 - 12位
//		必须全都是数字
//		0不能开头
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入qq号");
		String qq = sc.nextLine();
		if (isAllNum(qq) && isLength(qq) && isZeroStart(qq)) {
			System.out.println("qq号合法");
		}else {
			System.out.println("qq号不合法");
		}
	}

//	判断qq号是否在5-12位
	public static boolean isLength(String str) {
		return str.length() >= 5 && str.length() <= 12;
	}

//	全都是数字
	public static boolean isAllNum(String str) {
		for (int i = 0; i < str.length(); i++) {
			if (!(str.charAt(i) >= '0' && str.charAt(i) <= '9')) {
				return false;
			}
		}
		return true;
	}

//	0不能开头
	public static boolean isZeroStart(String str) {
		return !str.startsWith("0");
	}
}

使用正则
package com.ujiuye.demos;
import java.util.Scanner;
public class Demo_15 {
	public static void main(String[] args) {
//		键盘录入一个字符串，判断是否是一个合法的qq号码
//		合法qq号码的条件；
//		必须是5 - 12位
//		必须全都是数字
//		0不能开头
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入qq号");
		String qq = sc.nextLine();

		String regex = "[1-9][0-9]{4,11}";
		if (qq.matches(regex)) {
			System.out.println("qq号合法");
		} else {
			System.out.println("qq号不合法");
		}
	}
}

正则表达式的字符类

1、普通的字符串就是正则表达式，但是只能表示自己本身，无法匹配一类字符串的
2、判断某个字符串是否和某个正则表达式匹配，使用String类型的matches()
3、字符类型：表示单个字符，使用的符号是[]
	只要使用了中括号，那么无论里面写了多少内容，都表示的单个字符
4、方括号的表达式
	[abc];a或者b或者c中的一个
	[^abc]:除了a，b，c中的任意一个字符
	[a-zA-Z]就是a到z或者A到Z中的任意一个字符

package com.ujiuye.demos;

public class Demo_16 {
//	正则表达式的字符类
	public static void main(String[] args) {
		/*String regex = "[abc]";// 只能是a或者b或者c
		System.out.println("a".matches(regex));
		System.out.println("ab".matches(regex));*/
		/*String regex = "[^abc]";// 不是abc中的任意一个字符
		System.out.println("a".matches(regex));
		System.out.println("ab".matches(regex));
		System.out.println("@".matches(regex));
		System.out.println("$".matches(regex));*/
//		String regex = "[a-zA-Z]";
		String regex = "[1-9]";
		System.out.println("a".matches(regex));
		System.out.println("ab".matches(regex));
		System.out.println("A".matches(regex));
		System.out.println("0".matches(regex));
	}
}

预定义的字符类

1、有一些字符类型经常使用，所以就提前在正则表达式中进行定义，称为预定义字符类
2、罗列：
	.    表示的任意单个字符，\.表示的是一个确定的.字符串
	\d   表示数字字符
	\D   表示非数字字符
	\s   表示空格字符
	\S   表示的非空格字符
	\w   [a-zA-Z0-9_]
	\w	 表示除了\w以外的所有字符

package com.ujiuye.demos;

public class Demo_17 {
	public static void main(String[] args) {
//		预定义字符类
		/*		String regex = ".";
		//		String regex = "\\.";//才是一个确定的.
				System.out.println("a".matches(regex));
				System.out.println(".".matches(regex));
				System.out.println("@".matches(regex));
				System.out.println("3".matches(regex));
				System.out.println("_a".matches(regex));*/
		/*		String regex = "\\d";
				String regex = "\\D";
				System.out.println("11".matches(regex));
				System.out.println("a".matches(regex));
				System.out.println("3".matches(regex));
				System.out.println("4".matches(regex));
				System.out.println("5".matches(regex));
		*/
		/*//		String regex = "\\s";
				String regex = "\\S";
				System.out.println(" ".matches(regex));
				System.out.println("a".matches(regex));
				System.out.println("3".matches(regex));
				System.out.println("s4".matches(regex));
				System.out.println("5".matches(regex));*/
//		String regex = "\\w";
		String regex = "\\W";
		System.out.println("_".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("3".matches(regex));
		System.out.println("s4".matches(regex));
		System.out.println("@".matches(regex));
	}
}

数量词

1、无论是字符类型还是预定义字符类型都只能表示的是单个的字符，无法表示0个字符，也无法表示多个字符
需要使用一个数量词来修饰字符的个数
2、在使用数量词的时候，数量词修饰的内容一定是要紧挨着，只会修饰在该数量次前面紧挨着的字符
3、分类：
	模糊的数量词
	精确的数量词
4、模糊的数量词
	x？   表示x这个字符，出现0次或者1次
	x+    表示的x这个字符，出现1次或者多次
	x*    表示的x这个字符，出现0次，1次或者多次
   精确的数量词
   	x{n}  表示的是x这个字符，恰好出现n次
   	x{n,} 表示的是x这个字符，至少出现n次
   	x{n，m}表示的是x这个字符，至少出现n次，至多出现m次

package com.ujiuye.demos;

public class Demo_18 {
	public static void main(String[] args) {
//		模糊的数量词
//		String regex = "[abc]?";
//		String regex = "[abc]+";
//		String regex = "[abc]*";
//		System.out.println("a".matches(regex));
//		System.out.println("".matches(regex));
//		System.out.println("abaacacaca".matches(regex));
//		String regex = "[abc]?\\d*\\s";
//		System.out.println("a ".matches(regex));
//		System.out.println("123 ".matches(regex));
//		System.out.println("a2423 ".matches(regex));
//		精确的数量词
//		String regex = "[abc]{7}\\d*";
//		String regex = "\\w{6,}\\d+";
		String regex = "\\w{6,8}\\d+";
		System.out.println("abcbcbc13123".matches(regex));
		System.out.println("abcbbcs".matches(regex));
		System.out.println("abcbbcsgf123".matches(regex));
		
	}
}

字符串中和正则表达式有关的三个方法

1、boolean matches(String regex)：判断当前字符串是否和参数正则表达式匹配
2、String[] split(String str):使用指定的正则表达式切割当前字符串
3、replaceAll(String regex,String replacement)；将调用者字符串中的所有匹配regex正则子串，全部替换成replacement新串

package com.ujiuye.demos;

public class Demo_19 {
	public static void main(String[] args) {
		String str = "I Love java";
		String regex = " ";
		String[] split = str.split(regex);
		for (int i = 0; i < split.length; i++) {
			System.out.println(split[i]);
		}
//		replactAll
		String str1 = "I 520 Love 8888 java";
		String regex1 = "\\d+";
		String replaceAll = str1.replaceAll(regex1,"HELLO");
		System.out.println(replaceAll);
	}
}