新手小白学JAVA API Object String StringBuffer/StringBuilder
1 前言
亲爱的小伙伴萌,目前我们看到的是Java基础部分的一个新的部分API,这是个啥,又能做啥呢?
其实可以概括成一句话:帮助我们站在巨人的肩膀上,实现更加高效的开发,那么我们来一探究竟吧~
2 什么是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.StringBuilder/StringBuffer;
正则表达式
包装类等等 –
那么接下来我们会学习一些常用的类,帮助大家完成"基建工程",首先第一位选手就是传说中的Object类
3 Object
3.1概念
Object类是所有Java类的祖先,也就是说我们所说的”顶级父类”
它存在于java.lang.Object,这个包不需要我们手动导包
需要注意的是:每个类都使用Object作为超类.所有对象(包括数组)都实现这个类的方法.
在不明确给出超类的情况下,Java会自动把Object类作为要定义类的超类.
3.2 常用方法介绍
toString()
本方法用于返回对应对象的字符串表示
hashCode()
本方法用于返回对应对象的哈希码值
小贴士:哈希码值的得出是通过一种算法,意在让不同的对象具有不同的哈希码值,用于区分不同的对象.
但是有时候也存在不同对象哈希码值相同的特殊情况,我们称之为”哈希碰撞”现象
equals()
本方法用于指示其他某个对象是否与当前对象”相等”
3.3 练习: Object类练习
创建包: cn.tedu.api
创建类: TestObject.java
package cn.tedu.api;
import java.util.Objects;
/**本类用于测试顶级父类Object*/
//总结:
//1.如果想要查看对象的属性值,需要重写toString()
// 否则使用的就是Object的默认实现,打印的是对象的地址值
//2.如果要判断两个对象间的所有属性值相同,比较结果为true,就需要重写equals()
// 否则使用的就是Object的默认实现,通过==比较的是两个对象的地址值,不是属性
public class TestObject {
public static void main(String[] args) {
//4.创建对象进行测试
Student s = new Student("海绵宝宝",3);
Student s2 = new Student("海绵宝宝",3);
/*测试toString():返回的是该对象的字符串表示*/
/*查看源码的方式:按住Ctrl键,移到目标位置,鼠标点击即可*/
//5.打印s对象
//5.1测试1打印的是cn.tedu.api.Student@1b6d3586,是地址值,因为Object默认实现:
//return getClass().getName() + "@" + Integer.toHexString(hashCode());
//5.2测试2打印的是Student{name='海绵宝宝', age=3},是重写toString()以后的结果
System.out.println(s);
/*测试hashcode()*/
//6.测试hashCode()
System.out.println(s.hashCode());//460141958
//7.测试equals()
//7.1第一次测试执行结果是false
//底层:用了==进行对象间的比较,==比较的是两个对象的地址值,s和s2是两个对象,地址值不同
//public boolean equals(Object obj) { return (this == obj);}
//需求:比较s与s2对象,如果属性值相同,就认为是同一个对象,并让equals()返回true
//7.2第二次测试执行结果是true
System.out.println(s.equals(s2));
}
}
//1.创建学生类
class Student{
//2.定义属性
String name;//姓名
int age;//年龄
//3.生成构造方法
//右键-Generate-Constructor-按住Shift可以全选属性
//3.1定义无参构造
public Student() {
}
//3.2定义全参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//6.添加重写的toString()
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
}
4 String
4.1 特点
String是一个封装char[]数组的对象,字符串不可变
通过下图中的底层实现可以看出:被final修饰,是常量
String str = “abc”; 等效于：char data[] = {‘a’, ‘b’, ‘c’};
4.2 创建String对象的方式
方式一:
String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
方式二: String str = “abc”;
- 如果是第一次使用字符串，java会在字符串堆中常量池创建一个对象。
- 再次使用相同的内容时，会直接访问堆中常量池中存在的对象。
4.3 常见方法
length()-查看字符串的长度
charAt()—获取指定下标处位置上的字符
lastIndexOf()-某个字符最后一次出现的位置
substring()-截取子串,如果参数有两个左闭右开[1,5)
equals()-判断两个串是否相等,注意String重写了Object的此方法,所以内容相同就返回true
startsWith()-判断是不是以参数开头
endsWith()–判断是不是以参数结尾
split()—以指定字符分割
trim()-去掉首尾两端的空格
getBytes()-把串转换成数组
toUpperCase()-变成全大写
toLowerCase()-变成全小写
String.valueOf(10)-把int类型的10转换成String类型
4.4 练习:String常用方法练习
创建包: cn.tedu.api
创建类: TestString.java
package cn.tedu.api;
/*本类用于测试String类的用法*/
public class TestString {
public static void main(String[] args) {
//1.创建String对象方式一
/*1.字符串底层维护的是char[].存放在堆中*/
char[] value = {
'a','b','c'};
String s1 = new String(value);
String s11 = new String(value);
//2.创建String对象方式二
/*2.此种方式创建,底层也会new String(),存放在堆中常量池,效率高*/
String s2 = "abc";
String s22 = "abc";
//3.测试
/*3.==比较的是地址值
Object中equals()的默认实现比较的也是==地址值
但String类对此方法做了重写,比较的就是字符串的具体内容*/
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1 == s11);//false,没有高效效果
System.out.println(s2 == s22);//true,有高效的效果
}
}
创建包: cn.tedu.api
创建类: TestString2.java
package cn.tedu.api;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Locale;
/*本类用于测试String常用方法*/
public class TestString2 {
public static void main(String[] args) {
//1.创建字符串--堆中常量池,有高效效果
String s = "abc";
char[] value = {
'a','b','c','b'};
String ss = new String(value);
//2.测试常用方法
System.out.println(s.charAt(1));//b,获取下标为1处位置上的字符
String s2 = s.concat("cxy");//拼接字符串,但是并不影响本串的值
System.out.println(s2);//abccxy,如果想多次使用,可以再定义一个变量保存拼接结果
System.out.println(s);//abc,串s本身的值没有被影响
System.out.println(s.endsWith("y"));//false,判断是否以指定元素结尾
System.out.println(s.startsWith("a"));//ture,判断是否以指定元素开头
System.out.println(ss.equals(s));//true,String重写了,比较的是串本身的内容
System.out.println(s == ss);//false,比较的是地址值,一个高效在堆中常量池,一个不是,地址值不同
System.out.println(s.getBytes());//[B@1b6d3586,把字符串转化成byte[],所以打印数组地址值
System.out.println(s.indexOf("b"));//1,获取b字符在串中第一次出现的下标值
System.out.println(ss.lastIndexOf("b"));//3,获取b字符在串中最后一次出现的位置
System.out.println(ss.length());//4,获取指定字符串的长度
String s3 = "a b c d e";
/*本方法的作用是根据指定元素分割字符串,返回值类型是String[]*/
System.out.println(s3.split(" "));//[Ljava.lang.String;@4554617c
System.out.println(Arrays.toString(s3.split(" ")));//使用数组工具类打印数组具体元素
System.out.println(s3.substring(3));// c d e,从下标为3的位置处开始截取剩下的字符串
System.out.println(s3.substring(1,5));// b c,截取的[1.5)的字符串,含头不含尾
System.out.println(s3.toUpperCase());//A B C D E,把串变成全大写
System.out.println(s3.toLowerCase());//a b c d e,把串变成全小写
s3 = " abced ";
System.out.println(s3.trim());//abced,去除数据首尾两端的空格
System.out.println(String.valueOf(10));//10,把int10转成成String类型
System.out.println("20"+10);//2010,String与int数据进行了拼接
System.out.println(String.valueOf(10)+10);//1010,把int10转成成String类型
System.out.println(10+10);//20,int10+int10=int20
}
}
5 StringBuilder/StringBuffer
5.1 特点
- 封装了char[]数组
- 是可变的字符序列
- 提供了一组可以对字符内容修改的方法
- 常用append()来代替字符串做字符串连接”+”
- 内部字符数组默认初始容量是16：super(str.length() + 16);
- 如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
- StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全
5.2 常见方法
append()
5.3 练习3：测试字符串连接
创建包: cn.tedu. api
创建类: TestString2.java
需求: 测试+拼接字符串的效率
package cn.tedu.api;
/**本类用于测试字符串拼接的效率*/
public class TestString3 {
public static void main(String[] args) {
//method();//完成通过"+"进行拼接
method2();//优化"+"拼接
}
public static void method2() {
//1.定义字符串
String str = "abcdefghijklmnopqrstuvwxyz";
//2.将指定的字符串拼接10000次
/**优化1:String-->StringBuffer/StringBuilder*/
StringBuffer sb = new StringBuffer();//创建工具类对象1
StringBuilder sb2 = new StringBuilder();//创建工具类对象2
//2.2拼接10000次
/**4.可以添加一个计时功能*/
//4.1获取系统当前时间作为开始时间
long t1 = System.currentTimeMillis();//ms
for(int i = 0; i < 10000 ; i++) {
/**优化2:+ -->append() */
//result = result + str;
sb.append(str);
//sb2.append(str);
}
//4.2获取系统当前时间作为结束时间
long t2 = System.currentTimeMillis();//ms
//3.打印拼接好的字符串
//注意:eclipse控制台显示数据有限制,都打印在同一行了,所以控制台看不出来打印的内容
//可以通过全选,复制拿出来看数据是否拼接成功
//4.3打印拼接总共花费的总时长
System.out.println(sb.toString());//打印拼接的结果
System.out.println(t2-t1);
}
public static void method() {
//1.定义字符串
String str = "abcdefghijklmnopqrstuvwxyz";
//2.将指定的字符串拼接10000次
//2.1定义变量,用来保存最终拼接的结果
String result ="";
//2.2拼接10000次
/**4.可以添加一个计时功能*/
//4.1获取系统当前时间作为开始时间
long t1 = System.currentTimeMillis();//ms
for(int i = 0; i < 10000 ; i++) {
result = result + str;
}
//4.2获取系统当前时间作为结束时间
long t2 = System.currentTimeMillis();//ms
//3.打印拼接好的字符串
//注意:eclipse控制台显示数据有限制,都打印在同一行了,所以控制台看不出来打印的内容
//可以通过全选,复制拿出来看数据是否拼接成功
System.out.println(result);
//4.3打印拼接总共花费的总时长
System.out.println(t2-t1);
}
}
6 拓展
6.1 ==和equals的区别
1.当使用比较时，如果相比较的两个变量是引用类型，那么比较的是两者的物理地值（内存地址），如果相比较的两个变量都是数值类型，那么比较的是具体数值是否相等。
2.当使用equals()方法进行比较时，比较的结果实际上取决于equals()方法的具体实现
众所周知，任何类都继承自Object类，因此所有的类均具有Object类的特性，比如String、integer等，他们在自己的类中重写了equals()方法，此时他们进行的是数值的比较，而在Object类的默认实现中，equals()方法的底层是通过来实现的。
6.2 练习: ==与equals测试
创建包: cn.tedu.api
创建类: Test.java
package cn.tedu.api;
/**本类用于测试==与equlas的区别*/
public class Test{
public static void main(String[] args) {
Person p1 = new Person("凹凸曼",16);
Person p2 = new Person("凹凸曼",16);
System.out.println(p1 == p2);//false,new了两个对象,p1和p2保存的地址值不同
System.out.println(p1.name == p2.name);//true,name是String类型,保存在常量池中,值是同一个
System.out.println(p1.age == p2.age);//true,age是int基本类型,保存的值都是18
//第一次测试:结果false,使用的是Object默认的逻辑,也是用==来比较的
//第二次测试:结果true,重写equals()后,就会使用子类重写后的功能,也就是说此时比较的不再是地址,而是类型&属性值
System.out.println(p1.equals(p2));
}
}
//1.创建Person类
class Person {
String name;
int age;
public Person() {
System.out.println("我是手动添加的无参构造");
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
//需求:比较两个对象的属性值,如果属性值都一样,就是"同一个对象",要求equals返回true
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
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;
}
}
6.3 StringBuilder和StringBuffer的区别
1.在线程安全上 :
–StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
–StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
2. 在执行效率上，StringBuilder > StringBuffer > String
3.源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。
