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