自学Java基础知识第十二天

 

day12

1. System类(了解)

1. System类就是表示系统资源类型, JDK中没有给出System类型构造方法, 证明不能new对象, 类型中的成员,全部静态
2. System类型中的静态成员常量:

  

1) System.in : 表示标准输入流, 默认关联通过键盘进行录入,举例 : 使用在Scanner(System.in)

2) System.out : 表示标准的输出流, 默认输出到控制台, 举例 : System.out.println();

3) System.err :  err全称error表示错误,  表示标准错误流, 通常用于输出打印代码中的错误信息, 以红色字体突出显示打印  例如 : 异常

1. System类型中方法功能:

1) currentTimeMillis(): 静态方法, 表示获取到当前时间的毫秒值, 返回值类型long型

   a : 毫秒值是时间单位 : 1000毫秒 =  1秒

   b : java中,时间原点, 1970年1月1日 00:00:00 , 毫秒值为0

   c : 可以通过毫秒值获取,计算出代码的执行时间

代码

package com.ujiuye.system;

public class SystemDemo {

public static void main(String[] args) {

       // System.err.println("123");

       

       // System.out.println(10 / 0);

       // 方法调用的时机就是获取当前时间对应毫秒值

       long begin = System.currentTimeMillis();

       

       for(int i = 1; i <= 100000; i++) {

        System.out.println(i);

       }

       long end = System.currentTimeMillis();

       System.out.println(end-begin);

}

}

2. StringBuilder类

2.1 StringBuilder类型的概述

1. StringBuilder : 表示可变的字符序列, 称为字符串的缓冲区, 字符串生成器,来自于java.lang包

1. StringBuilder和String之间的比较:

  a : String类型 : 字符串常量, 字符串定义之后,不能进行修改,底层 private final char[] value; String类型中没有提供任何的功能修改value中的数据, 无法修改于是称为常量

  b : StringBuilder类型 : 可变的字符串, StringBuilder类型底层也是通过char[] value进行数据内容存储, 数组没有使用任何限制修饰, 可以进行修改, 可变字符存储

1. StringBuilder的使用场景:

  a : 当需要进行大量字符串数据拼接, String类型会在常量池中开辟很多的空间, 如此,比较浪费内存, 因此大量字符串拼接, String性能不好

  b : 于是StringBuilder类型的存在主要就是为了解决大量字符串拼接浪费内存的问题, 因为StringBuilder中的方法功能可以进行字符串的拼接, 拼接之后返回当前同一个StringBuilder类型对象本身, 因此节省内存空间

2.2 StringBuilder类型构造方法

 1. StringBuilder() : 创建出一个默认为16个字符大小的StringBuilder缓冲区对象

 2. StringBuilder(int number): 创建出一个初始容量可以存放number个字符的缓冲区对象

3. StringBuilder(String str) : 创建出的缓冲区对象初始容量str字符串长度+默认16大小

4.

5.

注意 : 每个字符串生成器都有一定的容量。只要字符串生成器所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区。如果内部缓冲区溢出，则此容量自动增大。

代码

package com.ujiuye.stringbuilder;

public class Demo01_StringBuilder构造方法 {

public static void main(String[] args) {

// 1. 创建出一个默认为16个字符大小的StringBuilder缓冲区对象

StringBuilder sb = new StringBuilder();

// 4. capacity() : 获取到当前字符串缓冲区容量大小

System.out.println(sb.capacity());// 16

// 5. length() : 获取到字符串缓冲区中包含的字符个数

System.out.println(sb.length());// 0

// 2. StringBuilder(int number): 创建出一个初始容量可以存放number个字符的缓冲区对象

StringBuilder sb1 = new StringBuilder(32);

System.out.println(sb1.capacity());// 32

// 3. StringBuilder(String str) : 创建出的缓冲区对象初始容量str字符串+默认16大小

StringBuilder sb2 = new StringBuilder("abcd");

System.out.println(sb2.capacity());// 20

System.out.println(sb2);// abcd

// 5. length() : 获取到字符串缓冲区中包含的字符个数

System.out.println(sb2.length());// 4

}

}

2.3 StringBuilder类中的添加功能

在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串生成器中。append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符。

1. append(Object obj) : 将参数类型转换成字符串, 末尾追加到字符串缓冲区中, 返回值类型器就是当前正在操作StringBuilder类型对象本身
2. insert(int index , Object obj) : 表示将参数obj添加到缓冲区指定的index索引位置处,返回值类型器就是当前正在操作StringBuilder类型对象本身

注意 : 如果insert方法功能的索引为sb.length(), 为缓冲区的实际最大索引值+1, 那么sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果,都表示末尾追加

代码

package com.ujiuye.stringbuilder;

public class Demo02_StringBuilder中添加功能 {

public static void main(String[] args) {

StringBuilder sb = new StringBuilder();

// 1.将参数类型转换成字符串, 末尾追加到字符串缓冲区中

sb.append(123);

sb.append(true);

// 方法返回值类型引用数据类型, 因此可以链式调用

sb.append("hello").append("78").append(990);

System.out.println(sb);// 123truehello

// 2. 表示将参数obj添加到缓冲区指定的index索引位置处

sb.insert(2, "添加");

System.out.println(sb);//12添加3truehello78990

// 则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果

sb.insert(sb.length(), "123");

System.out.println(sb);

}

}

2.4 StringBuilder类中的删除功能

1. deleteCharAt(int index) : 将指定索引index上的字符删除, 返回当前正在操作的StringBuilder类型对象本身

2. delete(int beginIndex, int endIndex) : 将beginIndex到endIndex-1之间字符序列全部删除, 返回当前正在操作的StringBuilder类型对象本身

代码

package com.ujiuye.stringbuilder;

public class Demo03_StringBuilder删除功能 {

public static void main(String[] args) {

        StringBuilder sb = new StringBuilder("abcdefg");

        

        sb.append("world");

        System.out.println(sb);// abcdefgworld

        

        // 1. deleteCharAt(int index) : 将指定索引index上的字符删除, 返回当前正在操作的StringBuilder类型对象本身

        sb.deleteCharAt(5);// 删除字符f, 返回sb对象本身

        System.out.println(sb);// abcdegworld

        

        // 2.delete(int beginIndex, int endIndex) : 将beginIndex到endIndex-1之间字符序列全部删除, 返回当前正在操作的StringBuilder类型对象本身

        sb.delete(3, 7);// degw

        System.out.println(sb);//abcorld

}

}

2.5 StringBuilder类中的替换和反转功能

1. replace(int beginIndex, int endIndex, String str) : 从beginIndex索引位置开始,到endIndex-1之间, 使用str字符串替换原有的字符序列内容,返回当前正在操作的StringBuilder类型对象本身

2. reverse() : 返回当前正在操作的StringBuilder类型对象本身

代码

package com.ujiuye.stringbuilder;

public class Demo04_StringBuilder替换反转功能 {

public static void main(String[] args) {

StringBuilder sb = new StringBuilder("helloworld");

// 1. replace(int beginIndex, int endIndex, String str) : 从beginIndex索引位置开始,到endIndex-1之间,

// 使用str字符串替换原有的字符序列内容,返回当前正在操作的StringBuilder类型对象本身

sb.replace(2, 6, "替换内容");// llow替换成 "替换内容"

System.out.println(sb);

// 2. reverse() : 将字符序列进行反转

sb.reverse();

System.out.println(sb);

}

}

2.6 StringBuilder与StringBuffer之间的比较

1. StringBuilder与StringBuffer都是可变的字符序列, 也都称为字符串缓冲区或者字符串生成器, 两个类中的方法功能完全一致

2. StringBuilder与StringBuffer:

  a : 在JDK中出现的版本不同

     StringBuffer从JDK1.0版本开始使用

     StringBuilder 从JDK1.5版本开始使用

  b : StringBuffer 线程安全的, 因此多了数据安全性的控制, 导致运行效率慢

    StringBuilder 是StringBuffer的简易替换, 因为线程不安全, 没有安全性控制, 导致运行效率快

2.7 String类型与StringBuilder类型作为方法参数

1. String类型作为方法参数传递

 

2.StringBuilder类型作为方法参数传递:

 

3. 基本数据类型包装类

3.1 基本数据类型包装类介绍

1. 基本数据类型有4类八种, 只能表示最简单, 最直接数据. 基本数据类型无法定义出方法功能, 实际开发中, 需要对基本数据类型进行方法封装和操作, 以及需要基本数据类型与其他类型数据的转换(基本类型与字符串之间的转换); 因此需要给每一种基本数据类型,设计出对应的引用数据类型包装类, 包装类中封装方法, 设计出转换功能.

 

1. 基本数据类型与对应包装类

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

3.2 Integer类型

  基本数据类型对应的包装类封装形式, 方法功能设计,彼此之间很相似,于是学习一个使用最多的Integer类型, 其他类型同等使用; Integer类型中就是封装了一个基本数据类型int, 封装的功能都是围绕着int类型数据展开

3.2.1 Integer类型的构造(了解)

1. Integer(int value) : 将一个int类型整数转换成Integer类型对象
2. Integer(String s) : 将String类型表示的整数数据转换成Integer类型对象

代码

package com.ujiuye.integer;

public class Demo01_Integer类型构造 {

public static void main(String[] args) {

        Integer i = new Integer(12);

        System.out.println(i);// 12

        

        Integer i2 = new Integer("123");

        System.out.println(i2);// 123

        

        // 如果字符串无法转换成一个整数, 报出 : NumberFormatException异常

        Integer i3 = new Integer("小闹");

        System.out.println(i3);

}

}

3.2.2 Integer类型中的常用方法

1. xxxValue() : 将引用数据类型Integer转换成基本数据类型

   intValue() : 将Integer类型所表示的数据转换成int类型结果

doubleValue() : 将Integer类型所表示的数据转换成double类型结果

1. 静态方法功能:

1) parseInt(String s) : 将参数s所表示的整数直接转换成十进制int类型

2) parseInt(String s, int radix) : 将radix进制表示的s数据,转换成int类型整数

3) 将参数i所表示10进制转换成其他进制, 转换结果字符串类型

  

 

4) valueOf() : 将其他类型转换成Integer类型

 

代码

package com.ujiuye.integer;

public class Demo02_Integer中常用方法功能 {

public static void main(String[] args) {

Integer i = new Integer("12");

// 1. Integer类型转换成基本数据类型

int age = i.intValue();

System.out.println(age);// 12

double d = i.doubleValue();

System.out.println(d);// 12.0

// 2. 静态方法功能

// 字符串转基本数据类型

int age2 = Integer.parseInt("25");

System.out.println(age2 + 1);// 26

// 111数据是一个2进制的数据表示, 方法功能, 将2进制的111转换成对应的十进制整数结果

int re = Integer.parseInt("111",2);

System.out.println(re);// 7

// 3. 十进制转换成其他进制

String s1 = Integer.toBinaryString(10);

System.out.println(s1);// 1010

String s2 = Integer.toOctalString(10);

System.out.println(s2);//12

String s3 = Integer.toHexString(10);

System.out.println(s3);// a

// 4. 其他类型转化成Integer类型

Integer i4 = Integer.valueOf(15);

System.out.println(i4);// 15

// 5. 基本数据类型转换成字符串

String  ss = 5 + "";

String.valueOf(5);

}

}

3.3.3 Integer类型中的成员常量(了解)

1. MAX_VALUE : Integer类型能表示的整数最大值

2. MIN_VALUE : Integer类型能表示的整数最小值

3. SIZE: 表示int类型数据在内存中通过比特位计量方式占空间多大

  int类型--->4字节-->1个字节8个比特位

1. TYPE : Integer类型实际封装的数据类型,int

代码

package com.ujiuye.integer;

public class Demo03_Integer类型中的成员常量 {

public static void main(String[] args) {

System.out.println(Integer.MAX_VALUE);// 2147483647

        System.out.println(Integer.MIN_VALUE);// -2147483648

        System.out.println(Integer.SIZE);// 32

        System.out.println(Integer.TYPE);// int

}

}

3.3自动装箱和自动拆箱

 自动装箱和自动拆箱机制,从JDK1.5版本开始实行

1. 装箱 : 将基本数据类型封装成一个引用数据类型
2. 拆箱 : 将引用数据类型包装类中表示的基本数据类型获取到
3. 自动装箱 : 基本数据类型可以直接给对应的引用数据类型包装类进行赋值
4. 自动拆箱 : 引用数据类型包装类可以直接给基本数据类型进行赋值, 并且可以直接和基本数据类型进行运算

代码

package com.ujiuye.integer;

public class Demo04_自动装箱和自动拆箱 {

public static void main(String[] args) {

         //1. 自动装箱

 Integer i = 12;

 System.out.println(i);// 12

 

 // 2. 自动拆箱

 int w = i;

 System.out.println(w);// 12

 

 /*

  *  1) Integer类型的变量i, 自动拆箱, 变成int类型数据12

  *  2) 12 + 6 = 18

  *  3) 将整数结果18进行自动装箱, 变成Integer类型变量i

  *

  * */

 i = i + 6;

 System.out.println(i);// 18

}

}

4. 正则表达式

4.1 正则表达式的概述

1. 正则表达式 : 本质就是一个字符串, 可以这个字符串可以表示并不是自己本身, 表示一类字符串的规则
2. 正则表达式 : 主要功能就是验证字符串的合法性
3. 正则表达式优势和弊端:

1) 优势 : 使用简单字符串规则,验证比较复杂的数据

2) 弊端 : 写出正确的正则表达式比较难

4.2 字符类

1. 字符类 : 表示每次匹配一个字符规则, 使用[]表示, 需要匹配一个符合[]中所罗列出的其中一个字符

   

1. 常用字符类:

1) String类型中, 有一个方法功能 : matches(String regex)

      

2) [abc] : 字符串需要是a或者b或者c中的其中一个字符

3) [^abc]: 字符串只要不是a或者b或者c中的其中一个字符, 效果[abc]的取反

4) [a-zA-Z0-9] : 连续字母大小写数字,可以使用-进行连接,表示范围

代码

package com.ujiuye.regex;

public class Demo01_字符类 {

public static void main(String[] args) {

        String regex = "[abc]";

        String s = "a";

        

        System.out.println(s.matches(regex));// true

        System.out.println("d".matches(regex));// false

        System.out.println("-a".matches(regex));// false

        

        String regex1 = "[^abc]";

        System.out.println("d".matches(regex1));// true

        System.out.println("a".matches(regex1));// false

        

        System.out.println("--------------------");

        

        String regex2 = "[a-z]";

        System.out.println("k".matches(regex2));// true

        System.out.println("A".matches(regex2));// false        

}

}

4.3 预定义字符类

 预定义字符类表示匹配一个字符,其实就是字符类的简写形式

注意 : 正则表达式中, 本身有含义, 表示转义, 将之后数据转换成普通数据 , 因此预定义字符类使用,需要\

1. .  : 表示匹配任意一个字符
2. d : 表示[0-9]任意一个字符匹配
3. D : 表示[^0-9], 表示匹配一个不是0-9的任意字符
4. s : 表示匹配一个空白字符
5. S : 表示匹配一个非空白字符
6. w : 表示[a-zA-Z0-9_]
7. W : 表示[^a-zA-Z0-9_]

代码

package com.ujiuye.regex;

public class Demo02_预定义字符类 {

public static void main(String[] args) {

       String regex = ".";

       

       System.out.println("6".matches(regex));// true

       System.out.println("?".matches(regex));// true

       System.out.println("-1".matches(regex));// false

       System.out.println("----------------");

       

       String regex1 = "\d";// [0-9]

       System.out.println("6".matches(regex1));// true

       System.out.println("a".matches(regex1));// false

       

       System.out.println("+++++++++++++++");

       

       String  regex2 = "\s";

       System.out.println(" ".matches(regex2));// true

       

       System.out.println("++++++++++++++++++");

       

       String regex3 = "\w";

       System.out.println("_".matches(regex3));// true

       System.out.println("*".matches(regex3));// false      

}

}

4.4 数量词

1. 不论字符类或者预定义字符类,都只能匹配一个字符规则; 于是如果需要匹配多个字符规则,需要使用数量词,当有了数量词之后,匹配1个,多个...

 

1. 数量词只针对于紧挨着数量词本身,并且在数量词前面的字符有效

1. 案例 : 定义出一个QQ号码验证规则

1) 全数字

2) 0不开头

3) 长度5-15位之间

代码

package com.ujiuye.regex;

public class Demo03_数量词 {

/*3.案例 : 定义出一个QQ号码验证规则

1)全数字

2)0不开头

3)长度5-15位之间*/

public static void main(String[] args) {

         String regex = "[1-9][0-9]{4,14}";

         System.out.println("012345".matches(regex));// false

         System.out.println("432".matches(regex));

         System.out.println("48907".matches(regex));

         System.out.println("48970a".matches(regex));

}

}