学习java第12天

Day12

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

一、System类

1、单词：系统，提供的很多使用系统资源的方法，提供了静态方法，直接使用就可以。
2、常用字段：
	System.in: 标准输入流，默认关联的是键盘。
	System.out:标准输出流，默认关联的是控制台
	System.err:标准的错误流：默认关联的是控制台，在eclipse中，该流打印的内容是红色的。
3、常用方法
	（1）gc();强制垃圾回收器，回收垃圾
	（2）currentTimeMillis() :获取系统的当前时间
	获取的是1970年1月1日，到现在的毫秒值
	作用：通过计算时间差，大概获取代码执行的时间

package com.offcn.demos;

import java.io.IOException;

public class Demo_1 {
//System类
	public static void main(String[] args) throws IOException {
		System.out.println();
//		System.in: 标准输入流
		/*
		 * InputStream is = System.in; int read = is.read(); int read2 = is.read();
		 * System.out.println(read); System.out.println(read2);
		 */
//		System.out 标准输出流
		System.out.println("123");
		System.out.println("123");
		System.out.println("123");
		System.out.println("123");
//		System.err:标准的错误流
		System.err.println("我是红色的");
//		常用方法
//		gc()
		for (int i = 0; i < 9; i++) {
			new Laji();
		}
		System.gc();
//		获取系统的当前时间
//		currentTimeMillis()
		long currentTimeMillis = System.currentTimeMillis();
		System.out.println(currentTimeMillis);
	}
}

二、StringBuilder

1、StringBuilder是一个可变的字符序列，它的内部拥有数组存储字符串的内容，进行字符串拼接的时候，直接在数组中加入新内容就可以了。
2、StringBuilder会自动维护数组的内容，实现自动的扩充。
3、字符串的生成器，字符串的缓冲区。
4、StringBuilder和String的关系：底层维护的都是字符数组
	String是不可变的字符序列，String中没有提供直接对该数组进行操作的方法
	StringBuilder是可变的字符学历，提供了可以直接对该字符数组进行操作的方法。
	在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串生成器中。append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符。 
	String长度不可以发生变化，StringBuilder是可以发生变化的，形象的理解为一个可以自动伸缩的字符容器。

构造方法

1、构造方法作用：String->StringBuilder StringBuffer --> StringBuilder
2、StringBuilder构造方法
	StringBuilder():创建一个生成器，初始容量为16
	StringBuilder(int capacity)：创建一个由自己指定容量大小的字符串生成器
	StringBuilder(String str) ：构造一个字符串生成器，并初始化为指定的字符串内容。
3、方法：
	capacity()返回当前容量。
	length();返回的是字符串生成器中字符的个数。

package com.offcn.demos;

public class Demo_2 {
	public static void main(String[] args) {
		String str = "i Love java";
		String str2 = str.substring(2,6);
		System.out.println(str2);
//		空参构造
		StringBuilder sb = new StringBuilder();//默认容量大小16
		System.out.println(sb.capacity());
		System.out.println(sb.length());
//		StringBuilder(int capacity) 
		StringBuilder sb1 = new StringBuilder(10);
		System.out.println(sb1.capacity());
		System.out.println(sb.length());
//		StringBuilder(String str) ：构造一个字符串生成器，并初始化为指定的字符串内容。
		StringBuilder sb2 = new StringBuilder("hello");
		System.out.println(sb2);
		System.out.println(sb2.capacity());//21 = 5 + 16
		System.out.println(sb2.length());// 5
	}
}

添加方法

1、append(任意类型)可以将任意类型转成字符串，追加到字符串生成器中
2、insert(int index) 方法则在指定的点添加字符。 
	 插入位置，0--length()范围之间

package com.offcn.demos;

public class Demo_3 {
//	append方法
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("java");
		/*
		 * sb.append("hello"); sb.append(123); sb.append(12.12);
		 */
		sb.append("hello").append(true).append('a');
		System.out.println(sb);
		System.out.println("-----------------------");
		StringBuilder sb1 = new StringBuilder();
		sb1.append("abcd");
		sb1.append("abcd");
		sb1.append("abcd");
		sb1.append("abcd");
		sb1.append("a");
		System.out.println(sb1.capacity());
		System.out.println(sb1.length());
		System.out.println(Integer.MAX_VALUE);
		System.out.println("------------insert-----------");
//		insert(int index)
		StringBuilder sb2 = new StringBuilder();
		sb2.insert(0, 123);
		System.out.println(sb2);
		sb2.insert(2,"java");
		System.out.println(sb2);
		
	}
}

删除方法

1、delete(int start,int end),删除指定范围的一个子字符串
2、deleteCharAt(int index) 删除指定索引上的单个字符

package com.offcn.demos;

public class Demo_4 {
//	删除方法
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("我爱长沙");
		sb.delete(0, 2);//删除指定范围的一个子字符串
		System.out.println(sb);
//		deleteCharAt
		StringBuilder sb1 = new StringBuilder("我爱周杰伦");
		sb1.deleteCharAt(2);
		System.out.println(sb1);
	}
}

替换和反转的方法

1、replace(int start, int end, String str) 
将索引从start开始到end-1处的子字符串替换成str
2、reverse()将原有的字符串进行反转
	

package com.offcn.demos;

public class Demo_5 {
//	替换方法
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("I Love python");
		sb.replace(7, 13, "java");
		System.out.println(sb);
//		反转方法
		StringBuilder sb1 = new StringBuilder("abcdef");
		sb1.reverse();
		System.out.println(sb1);
		
	}
}

String和StringBuilder进行字符串拼接的时候效率比较

package com.offcn.demos;

public class Demo_6 {
//	String和StringBuilder进行字符串拼接的时候效率比较
	public static void main(String[] args) {
		int[] arr = new int[100000];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i;
		}
//		System.out.println(Arrays.toString(arr));
//		拼接为字符串，并返回[1,2,3,4,5,6]
		
		test_2(arr);
	}

	private static void test_2(int[] arr) {
		// 使用StringBUilder完成字符串的拼接
		long start = System.currentTimeMillis();
		StringBuilder sb = new StringBuilder("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				sb.append(arr[i]).append("]");
			} else {
				sb.append(arr[i]).append(",");
			}
		}
		String string = sb.toString();
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}

	private static void test_1(int[] arr) {
		// 使用的String完成字符串的拼接
		long start = System.currentTimeMillis();
		String str = "[";
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				str += arr[i] + "]";
			} else {
				str = str + arr[i] + ",";
			}
		}
		long end = System.currentTimeMillis();
		System.out.println(end - start);
		// System.out.println(str);
	}
}

StringBuffer和StringBuilder的区别

1、共同点：
	都是字符串的生成器，或者字符串的缓冲区，都是可变的字符序列，其中方法在使用的时候都是一样的
2、不同点
	（1）出现的版本不一样的
		StringBuffer 是jdk1.0出现了
		StringBuilder是jdk1.5出现的
	（2）线程安全性不同：
		StringBuffer是线程安全的
		StringBuilder是线程不安全的
	（3）效率不同
		StringBuffer效率就低
		StringBuilder效率高

String和StringBuilder作为方法的参数

1、String作为方法的参数，无法修改原值，在方法中修改的是引用的指向，和主方法中的声明的引用变量是没有关系的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2HXcNESw-1603007029853)(Day12.assets/image-20200921144551458.png)]

2、StringBuilder作为方法的参数，如果在方法中，修改的是StringBuilder类型引用的指向，那么主方法中的指向也是不会发生变化的，内容不会被修改

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LJGmS6L8-1603007029857)(Day12.assets/image-20200921145107691.png)]

3、StringBuilder作为方法的参数，如果在方法中，通过方法中的引用修改了该引用对象中的内容的时候，主方法中的引用指向是数据也会发生变化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KY30B4dr-1603007029859)(Day12.assets/image-20200921145950202.png)]

三、基本类型的包装类

1、基本类型一共四类八种，都是非常简单的数据类型，不能对数据进行操作
2、目的:为了增加基本类型的能力和功能，能够让基本数据类型，提供一些对数据进行操作的方法，定义一些对数据进行转换方式等功能。
3、实现：定义类将基本类型作为一个类型的成员变量，并在该类中提供很多对该成员变量操作的方法。
4、这个类型就是我们要说的包装类类型
5、基本类型的包装类
	byte        Byte
	short       Short
	int         Integer
	long        Long
	float       Float
	double      Double
	boolean     Boolean
	char        Character

Integer类型

1、各种包装类类型中的方法，特点基本都是相同的，所以不一个一个详细的介绍了，学习一个Integer就可以了，其他的根据Integer类型的特点去进行学习就可以了
2、Integer类型而言，维护了一个私有的基本类型的变量，是一个int类型的字段
3、提供了很多对维护的成员变量进行操作的方法
4、提供了一些常量

Integer类型的构造方法

1、Integer(int i)	:将一个基本类型的数据，封装成成一个Integer类型的对象   int ----> Integer
2、Integer(String s) :将一个字符串类型的数字，包装成一个包装类类型对象   String ---> Integer
注意：字符串类型的数字eg “12312321”，”2343“

package com.offcn.demos;

public class Demo_12 {
//	Integer类型
	public static void main(String[] args) {
//		构造方法   int ----->  Integer类型
		int i = 234;
		
		Integer in1 = new Integer(i);
		Integer in2 = new Integer("1231");
		System.out.println(in2);
	}
}	

Integer类型中的成员方法

1、xxxValue()方法  能够将Integer类型的对象，转成需要的其他的基本数据类型
2、常用的静态方法
	    将任意进制的字符串数字，解析为一个十进制jint类型的数字
	parseInt(String s) 将一个字符串数字转成一个十进制int类型的数字   String --->int
	parseInt(String s, int radix) 将一个字符串数字按照指定的进制解析为一个十进制int类型的数字
	valueOf(String s, int radix)可以将字符串数字s按照指定的进制radix解析为一个Integer类型
		十进制数字转成其他进制的数字字符串
	toBinaryString(int i) 将一个十进制的数字转成二进制的数字字符串
	toHexString(int i) 将一个十进制的数字转成十六进制的数字字符串
	toOctalString(int i) 将一个十进制的数字转成八进制的数字字符串
		可以将十进制的数字转成任意进制的字符串
	toString(int i ,int radix)将一个十进制的数子，转成指定进制radix进制的字符串

package com.offcn.demos;

public class Demo_13 {
	public static void main(String[] args) {
//		Integer中的常用的成员方法
		Integer in1 = new Integer(129); // Integer--->转成其他的基本数据类型
		byte byteValue = in1.byteValue();
		System.out.println(byteValue);
		double d = in1.doubleValue();
		System.out.println(d);
//		parseInt
		String str = "520";
		System.out.println(str + 1);
		int i = Integer.parseInt(str);// 将数字字符串转成一个十进制int类型的数字
		System.out.println(i + 1);
//		parseInt(String s, int radix) 
		int parseInt = Integer.parseInt("10010010",2);
		System.out.println(parseInt);
//		toBinaryString(int i) 将一个十进制的数字转成二进制的数字字符串
		String binaryString = Integer.toBinaryString(4);// 10 --->2
		System.out.println(binaryString);
//		toOctalString(int i) 10 --->8
		String octalString = Integer.toOctalString(18);
		System.out.println(octalString);
//		toHexString(int i)   10 ---> 16
		String hexString = Integer.toHexString(15);
		System.out.println(hexString);
//		toString(int i, int radix) 讲一个十进制的数子，转成指定进制radix进制的字符串
		String string = Integer.toString(18,36);
		System.out.println(string);
		int parseInt2 = Integer.parseInt("i", 36);
		System.out.println(parseInt2);
//		valueOf(String s, int radix)可以将字符串数字s按照指定的进制radix解析为一个Integer类型
		Integer valueOf = Integer.valueOf("i",36);
		System.out.println(valueOf);
	}
}

Integer类型的常量

1、MAX_VALUE:int类型的最大值
2、MIN_VALUE：int类型的最小值
3、SIZE：int类型在内存中的位数
4、TYPE：int在方法区中的字节码对象int
有9个预先定义好的Class对象代表8个基本数据类型和void ，它们被java虚拟机创建，和基本类型有相同的名字

package com.offcn.demos;

public class Demo_14 {
	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);
	}
}

自动装箱和自动拆箱

针对的是包装类类型
1、装箱和拆箱
	装箱：将基本的数据类型封装成包装类类型，这个过程就形象的称为装箱。		基本类型---》 包装类
	拆箱：从包装类类型，将基本的数据类型进行取出，这个过程形象的称为拆箱。    包装类----》基本类型
2、自动装箱和自动拆箱
	自动装箱：可以直接使用基本类型的数据，赋值给引用类型的包装类类型
	自动拆箱,可以直接将包装类类型的引用赋值给基本类型的变量，或者直接参与和基本数据类型的运算
3、出现的版本：jdk1.5

package com.offcn.demos;

public class Demo_15 {
	public static void main(String[] args) {
//		自动装箱和拆箱
//		装箱  基本类型----》包装类类型
		int i = 10;
		Integer in1 = new Integer(i);
//		拆箱  包装类类型----》基本类型
		in1.intValue();
//		自动装箱，可以直接使用基本类型的数据，赋值给引用类型的包装类类型
		Integer in2 = 123;
//		自动拆箱,可以直接将包装类类型的引用赋值给基本类型的变量，或者直接参与和基本数据类型的运算
		int m = in1;
		System.out.println(m);
		System.out.println(in1 + 1);//
	}
}

四、正则表达式

1、本质上就是一个单纯的字符串
2、作用：可以表示一类字符串，表示一类字符串的规格和格式
3、好处：可以使用很简单字符串，去表示一类的字符串或者复杂的字符串
4、缺点：写出正则正确率不高

正则表达式的好处

1、需要：
	键盘录入一个字符串，判断是否是一个合法的qq号
2、满足的条件
	必须全都是数字
	必须在10-13位
	不能以0开头

package com.offcn.demos;

import java.util.Scanner;

public class Demo_17 {
	public static void main(String[] args) {
		/*	1、需求：
			键盘录入一个字符串，判断是否是一个合法的qq号
			2、满足的条件
			必须全都是数字
			必须在10-13位
			不能以0开头*/
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个qq号");
		String qq = sc.nextLine();
//		正则实现qq号的校验
		String regex = "[1-9][0-9]{9,12}";
		boolean matches = qq.matches(regex);
		System.out.println(regex);

		if (matches) {
			System.out.println("合法");
		} else {
			System.out.println("不合法");
		}

		/*if(isAllNum(qq) && isLength(qq) && isStartZero(qq)) {
			System.out.println("合法");
		}else {
			System.out.println("不合法");
		}*/

	}

//	定义一个方法，判断qq这个字符串是否全都是数字
	public static boolean isAllNum(String str) {
		for (int i = 0; i < str.length(); i++) {
			char ch = str.charAt(i);
//			判断一个字符是否是数字
			if (!(ch >= '0' && ch <= '9')) {
				return false;
			}
		}
		return true;
	}

//	定义一个方法，判断qq是否是10-13位
	public static boolean isLength(String str) {
		return str.length() >= 10 && str.length() <= 13;
	}

//	定义一个方法判断qq是否以0开头，如果是0开头返回false
	public static boolean isStartZero(String str) {
		return !str.startsWith("0");
	}
}

正则表达式的字符类

1、普通的字符串就是一个正则表达式，只不多只能表达自己本身，无法匹配一类字符串
2、定义的正则表达式本身就是字符串，只有和一些特定的方法进行结合使用才能发挥正则表达式的作用
使用String类中的matches方法
3、字符类型：表示的是单个字符，使用符号是[]
4、eg：
	[abc]:只能是a或者b或者c中的一个字符
	[^abc]:除了a,b,c 中其他的任意的一个字符
	[a-zA-Z0-9]:大小写字母和数字中的任意一个字符
	只要用了中括号，无论中括号里面写了多少个字符，都只能表示单个的字符

package com.offcn.demos;

public class Demo_18 {
	public static void main(String[] args) {
//		String regex = "[^abc]";
		String regex = "[a-zA-Z0-9]";
		System.out.println(regex);
//		只有和matches方法结合起来才能发挥正则的作用
		System.out.println("a".matches(regex));// 让字符串a和regex进行正则的匹配
		System.out.println("abc".matches(regex));
		System.out.println("s".matches(regex));
		System.out.println("0".matches(regex));
	}
}

预定义字符类

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

package com.offcn.demos;

public class Demo_19 {
	public static void main(String[] args) {
//		预定义字符类
//		String regex = ".";//任意单个字符
//		String regex = "\\.";// \.才表示具体的一个.
//		String regex = "\\D";// \d          表示的是任意单个数字字符
//		String regex = "\\W";// 表示的是[a-zA-Z0-9_]中的任意一个字符
		String regex = "\\S";
		System.out.println("a".matches(regex));
		System.out.println("P".matches(regex));
		System.out.println("1".matches(regex));
		System.out.println("$".matches(regex));
		System.out.println(" ".matches(regex));
	}
} 

个字符
\s 表示一个空格
\S 除了空格以外的任意单个字符

```java
package com.offcn.demos;

public class Demo_19 {
	public static void main(String[] args) {
//		预定义字符类
//		String regex = ".";//任意单个字符
//		String regex = "\\.";// \.才表示具体的一个.
//		String regex = "\\D";// \d          表示的是任意单个数字字符
//		String regex = "\\W";// 表示的是[a-zA-Z0-9_]中的任意一个字符
		String regex = "\\S";
		System.out.println("a".matches(regex));
		System.out.println("P".matches(regex));
		System.out.println("1".matches(regex));
		System.out.println("$".matches(regex));
		System.out.println(" ".matches(regex));
	}
}