011-API学习-正则表达式-object-string-string builder-string Buffer
1.API概念
API(Application Programming Interface,应用程序接口)是一些预先定义定义的函数,目的是提供访问程序与开发人员基于某软件可以访问的一些功能集,但是又无需要访问源码或者理解内部工作机制的细节.
API是一种通用功能集,有时候公司会将API作为公共开放系统,也就是公司制定自己的系统接口标准,当需要进行系统整合,自定义和程序等应用操作的时,公司所有成员都可以通过改接口标准调用源代码.
Java.util包是java的工具包,包含各种使用工具类/集合类/日期时间工具等等各种常用的工具包
import java.util.Scanner;
import java.util.Arrays;
java.lang包是java的核心,包含了java基础类,包括基本Object类/class类/String类/基本数学类等最基础的类
这个包无需导入,默认会自动导入
import java.lang.Object
import java.lang.String
import java.lang.StringBulider/String Buffer;
正则表达式
包装类等等
2.Object类
Object类是所有类的祖先,也就是我们说的顶级父类,常用方法to String\hashCode()\equals()
练习
package Object;
public class Test1_Object {
public static void main(String[] args) {
}
}
class Student{
String name;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
int age;
public Student() {}
public Student(String name,int age) {
super();
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
3.String
3.1特点
String 是一个封装char[]数组的对象,字符串不可改变
通过下面的底层实现可以看出:被final修饰,是常量
String str = “abc”;等效于: char date [] = {‘a’,‘b’,‘c’};
3.2创建String对象的方式
方式一:
String (char [] value )分配一个新的String,使其表示字符数组参数中当前包含的字符序列
方式二:
String str = “abc”;
- 如果是第一次使用字符串,java会在字符串常量池创建一个对象
- 再次使用相同的内容时候,会直接访问常量池中存在的对象
3.3测试方法
package Object;
import java.util.Arrays;
public class Test2_String {
public static void main(String[] args) {
char[] value = { 'a', 'b', 'c' };
String s1 = new String(value);
String s2 = "abcafghhjhk";
System.out.println(s1 == s2);//false
System.out.println(s2.charAt(2));//c
System.out.println(s2.concat("money"));//尾部添加
System.out.println(s2.endsWith("y"));//是否以"y"结尾
System.out.println(s1.equals(s2));//是否相等,equals比较的是内容,String底层重写了equals方法
System.out.println(s2.getBytes());//转化成为字节输出
System.out.println(s2.indexOf("o"));//字母o首次出现的位置
System.out.println(s2.lastIndexOf("h"));//字母h最末次出现的位置
System.out.println(s2.replaceFirst(s2, "2333"));//正则表达式替换
s2 = "a b c d e";
System.out.println(s2.split(" "));//地址值
System.out.println(Arrays.toString(s2.split(" ")));//分割后的表达式,去空
System.out.println(s2.substring(1));//切割从下标1到最尾端字符串并输出
System.out.println(s2.substring(1, 3));//切割下标1-3字符串输出
System.out.println(s2.toLowerCase());//全部转为小写
System.out.println(s2.toUpperCase());//全部转为大写
String s3 = "ABCDE";
System.out.println(s2.compareTo(s3));// 这个方法不熟悉,需要重点看
String s4 = " asdfgh ";
System.out.println(s4.trim());//去掉两端空格
System.out.println(String.valueOf(10));//把int类型10转为String类型字符串"10"
System.out.println(String.valueOf(10) + 10);//字符串String+int---->String
}
}
4.StringBuilder/ String Buffer
4.1特点
- 封装了char[]数组
- 是可变的字符序列
- 提供了一组对字符内容修改的方法
- 常用append()来代替字符串做字符串做字符串拼接"+"
- 内部字符数组默认吃食容量是16:super(str.length()+16);
- 如果大于16会尝试扩容,新数组大小原来的变成2倍+2,容量如果还是不够,直接扩充到需要的容量大小.int newCapacity = value.length * 2 + 2;
- String Buffer1.0出道,线程安全,StringBuilder1.5出道线程不安全效率更高.
4.2常用方法
append()
4.3练习3:测试字符串连接
package api_String;
public class StringAppendTest {
public static void main(String[] args) {
// method();//完成通过"+"进行拼接
method2();//完成通过Stringbuffer和StringBuilder的拼接
}
public static void method2() {
String str = "abcdefghrgklmnopqrstuvwxyz";//定义字符串
StringBuffer sb = new StringBuffer();
StringBuilder sb2 = new StringBuilder();
long t3 = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
// sb.append(str);//拼接10000次
sb2.append(str);
}
long t4 = System.currentTimeMillis();
// System.out.println(sb.toString());
System.out.println(sb2.toString());
System.out.println(t4 - t3);
}
public static void method() {
String str = "abcdefghrgklmnopqrstuvwxyz";
long t1 = System.currentTimeMillis();//获取初始时间
String result = " ";
for (int i = 0; i < 10000; i++) {
result = str + result;
}
long t2 = System.currentTimeMillis();//获取最终时间
System.out.println(result);
System.out.println(t2 - t1);
}
}
5正则表达式
5.1概述
正确的正则表达式规范
常用来判断用户输入的内容是否符合格式的要求,注意是严格区分大小写的.
5.2常见语法
5.3String提供了支持正则表达式的方法
Matches(正则)—当前字符串能否匹配正则表达式
replaceAll(正则,子串):替换子串
spilt(正则):拆分字符串
5.4练习:测试输入省份证号码
package api_String;
import java.util.Scanner;
public class Test_Regex {
public static void main(String[] args) {
System.out.println("请输入您的身份证号:");
String input = new Scanner(System.in).nextLine();
//身份证的规律:一般都是18位,前17位都是数字,自哦吼一位可能是数字,也可能是X
String regex = "[0-9]{17}[0-9X]";
if(input.matches(regex)) {
System.out.println("输入正确");
System.out.println("您是"+input.substring(6, 10)+"年"+input.substring(11,12)+"月份生的");
}else {
System.out.println("输入不正确,请重新输入");
}
}
}
6 包装类
把基本类型进行包装,提供更加完善的功能
基本类型是没有任何功能的,只是一个变量,记录值,而包装类可以有更加丰富的功能.
6.1基本类型与包装类型的对应关系
6.2Number
数字包装类的抽象父类
提供了各种获取值的方式.
6.2.1子类
6.2.2常用的方法
6.3Integer
6.3.1创建对象
1.new.Integer(5);
2.Integer.valueOf(5);
在Integer类中,包含256个Integer缓存对象,范围是-128到127
使用valueOf()时候,如果指定范围内的值,访问缓存对象,而不兴建;如果指定范围外的值,直接新建对象.
6.3.2常见方法
static int parseInt(String s):将字符串参数作为有符号的十进制整数进行解析
6.3.3练习:Number之Integer
package api_String;
public class Test_Number {
public static void main(String[] args) {
Integer i0;
Integer i1 = new Integer(127);
/**
* Integer有一个高效的效果(-128~127之间) 因为静态的valueOf()相同的数据只会缓存一次,后续再存都会使用已经存过的数据
*/
Integer i2 = Integer.valueOf(127);
Integer i3 = Integer.valueOf(127);
Integer i4 = Integer.valueOf(300);
Integer i5 = Integer.valueOf(300);
System.out.println(i1);
System.out.println(i1 == i2);// false,比较的是地址值
System.out.println(i2 == i3);// true,是Integer,并且这两单个对象都是通过valueOf获得的,底层的地址值都是相同的,并且是在-128~127范围内,相同数据只会存储一次
System.out.println(i4 == i5);// false,是Integer,但是不在(-128~127范围里面)所以存了两次,2个对象
}
}
在上面的Integer的练习当中需要关注高效Integer的两个使用前提条件:
- 这两个数据都是通过Integer.ValueOf的方法来进行获取的,如果有一个是通过new Integer的方式,一个是通过Integer.ValueOf的方式获取的,那么它们一个存放在堆中,一个存放在栈中,地址值不可能相等,无法构成高效条件;
- 在Integer.valueOf方法使用后,数值的范围应该在-128~127之间,静态的valueOf(),相同的数据只会存一次,后续再存都会使用已经存过的数据.
6.4Double
6.4.1创建对象
1.new Double(3.14)
2. Double.valueOf(3.14)//这种方式的new没有任何区别
6.4.2方法
Double.parseDouble();
6.4.3练习:Number之Double
package api_String;
public class Test_Double {
public static void main(String[] args) {
Integer i1 = new Integer(5);
Double d1 = new Double(3.4);
Double d2 = Double.valueOf(3.14);
Double d3 = Double.valueOf(3.14);
System.out.println(d1 == d2);// false
System.out.println(d3 == d2);// false,只有Integer包装类有高效的效果
// 测试常用方法
System.out.println(i1.parseInt("456") + 1);// 457执行了加法运算,把String类型的456转化成了Int类型的
// System.out.println(i1.parseInt("455.7")+1);//NumberFormatException,数据格式异常
System.out.println(d1.parseDouble("2.2") + 1);// 3.2执行了加法运算,把String类型的2.2转为了Double类型
}
}
7.自动装箱和自动拆箱
7.1概述
自动装箱:把基本类型包装成为对应的包装类型的过程
Integer a = 5;//a是引用类型,引用了包装对象的地址
编译器会完成对象的自动装箱: Integer a = Integer.valueOf(5);
自动拆箱:从包装类型的值,自动变成基本类型的值
int i = a ;//a现在是包装类型,没有办法给变量赋值,需要把5取出来
编译器会完成自动拆箱: int i = a.intValue();
7.2练习:自动装箱与自动拆箱
package api_String;
public class Test_Box {
public static void main(String[] args) {
Integer i11 = new Integer(127);
Integer i22 = Integer.valueOf(127);
/**
* 自动装箱:编译器会自动把基本类型int数据5,包装成为包装类型Integer,然后交给i1保存
* 自动装箱底层发生的代码:Integer.valueOf(5); valueOf()的方向:int---->Integer
*/
Integer i1 = 5;// 不会宝座,这个现象就是自动拆箱
/**
* 自动拆箱:编译器会自动把包装类型的5,拆掉箱子,变回到基本类型数据5 自动拆箱底层发生的代码:i1.intValue()
* intValue()的方向:Integer--->int
*/
int i2 = i1;// 不会报错,这个现象就是自动拆箱
}
}
8.拓展
8.1==和equals的区别
- 当使用==比较时,如果比较的是两个变量都会引用类型,那么比较的是两者之间的物理地址值(内存地址),如果相比较的两个变量都是数据类型,那么比较的是具体数值是否相等;
- 当时用equals()方法进行比较时,比较的结果实际上取决于equals()方法的具体实现
- 众所周知,任何类都继承Object类,因此所有的类均具有Object类的特性,例如String\integer等,它们在自己的类当中重写了equals()方法,此时他们进行的是数值的比较,而在Object类的默认实现中,equals()方法的底层是通过==来实现的
package api_String;
public class Person {
public String name;
int age;
public Person() {
System.out.println("我是手动添加的无参构造");
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null)
if (other.name != null)
return false;
else if (!name.equals(other.name)) {
return false;
}
return true;
}
}
8.3StringBuilder和StringBuffer的区别
- 在线程安全上::StringBuffer是旧版就提供的,线程安全的,从JDK1.0就有;
StringBuilder是JDK1.5提供的,线程不安全的; - 在执行效率上:StringBuilder>StringBuffer>String
- 源码体现:本质上都是在调用父类抽象类AbstractStringBulider来干活,只不过Buffer把代码加了同步关键字,使得程序可以保证线程安全问题.
- abstract class AbstractStringBuilder implements Appendable,CharSequence