JavaAPI_常用类
API
API(Application Programming Interface)应用程序编程接口
- 语言中提供的类、接口；
- 对类、接口功能的说明文档。
基本数据类型包装类
Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。
即Java为每种基本类型提供了一个类，这些类被称为包装类。
/*
基本数据类型 对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
*/
这些包装类分别封装了一个相应的基本数据类型，并为其提供了一系列操作方法。
以Integer包装类为例：
public static void main(String[] args) {
int num = 10;//一个int型整数
//构造方法
Integer num1 = new Integer(10);//把int型整数作为参数包装到Integer类的对象中
System.out.println(num1.doubleValue());//输出转为double型
Integer num2 = new Integer("15");//将字符串类型的值转换为int型
System.out.println(num2);
/*
Integer类中提供很多的方法来对int类型进行操作
*/
//转换进制方法
System.out.println(Integer.toBinaryString(3));//十进制的整数转换为2进制
System.out.println(Integer.toHexString(17));//十进制的整数转换为16进制
System.out.println(Integer.toOctalString(12));//十进制的整数转换为8进制
System.out.println(Integer.MAX_VALUE);//int型常量保持的最大值
System.out.println(Integer.MIN_VALUE);//int型常量保持的最小值
System.out.println(Integer.BYTES);//用于表示二进制补码二进制形式的 int值的字节数。
System.out.println(Integer.SIZE);//用于表示二进制补码二进制形式的 int值的位数。
//比较方法
/*
Integer num3 = Integer.valueOf(23);//
Integer num4 = Integer.valueOf(22);
*/
Integer num3 = new Integer(23);//创建一个Integer对象
Integer num4 = new Integer(22);
System.out.println(num3==num4);//== 用于引用类型比较时，比较的是对象内存地址是否相等
System.out.println(num3.equals(num4));//equals()方法比较的是两个对象中具体包含的值是否相等 相等为true， 不相等为false
System.out.println(num3.compareTo(num4));//值为-1 0 1，前者大输出1，相等输出0，前者小输出-1
System.out.println(Integer.max(num3,num4));//取较大值
System.out.println(Integer.min(num3,num4));//取较小值
Integer n1 = new Integer(10);
int n2 = n1.intValue();//取出对象中包含的具体的值
long n3 = n1.longValue();
System.out.println(n3);
int n4 = Integer.parseInt("11");//parseInt(String s)将字符串参数解析为带符号的十进制整数。
System.out.println(n4);
//基本类型 转换为 引用类型
Integer num7 = Integer.valueOf(10);
Integer num8 = Integer.valueOf("10");
System.out.println(num7==num8);//true
//把数值转为字符串
System.out.println(num8.toString());
System.out.println(Integer.toString(10));
//引用类型 转换为 基本类型
int num5 = Integer.valueOf(num3);
int num6 = num4.intValue();
}
装箱和拆箱：
装箱
- 自动将基本类型装换为包装类类型
- 装箱的时候自动调用的是Integer的valueOf()方法
拆箱
- 自动将包装类类型装换为基本数据类型
- 拆箱的时候自动调用的是Integer的intValue()方法
public static void main(String[] args) {
//构造方法
Integer num1 = new Integer(10);//创建一个Integer对象,把int型整数作为参数包装到Integer类的对象中
Integer num2 = Integer.valueOf(10);//基本类型 转换为 引用类型
int num3 = num1.intValue();//取出对象中包含的具体的值
int num4 = Integer.parseInt("10");//parseInt(String s)将字符串参数解析为带符号的十进制整数。
/*
自动装箱：把基本类型转为引用类型
*/
int n = 10;
Integer n1 = n;//自动调用valueOf()方法，valueOf()：基本类型 转换为 引用类型
/*
自动拆箱：把引用类型转为基本类型
*/
int n2 = n1;//自动调用intValue()方法，intValue()：取出对象中包含的具体的值
/*
使用装箱（valueOf()） 在创建对象时，值如果在 -128~+127 之间，如果多个值相同，指向的是同一个地址；
如果值不在范围区内，则创建新对象。
使用 new + 构造方法() 不管制是否在此区间，都会创建新对象
*/
}
Object类
Object类是java中所有类的父类。
常用方法：
- 将对象输出时，会调用toString()方法
- 做比较时，会调用equals()方法，等同于 ==
public static void main(String[] args) {
/*
Object类是java中所有类的父类
*/
/*
将对象输出时，会调用 toString()方法
当类中没有定义toString()时，会默认调用父类(Object)中的toString。
父类(Object)中的toString,将对象地址转为16进制的字符串输出，可以在类中重写Object类中的toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
public native int hashCode();
native:调用本地方法，java语言不实现，调用操作系统实现
*/
//创建一个People类，并重写Object类中的toString()方法
People p = new People("jam",22);
//调用People类中重写后的toString()，输出想要的 字符串
System.out.println(p+"hello");
/*
Object类中的 equals() 比较对象地址是否相等，等同于 ==
public boolean equals(Object obj) {
return (this == obj);
}
*/
People p1 = new People("jam",22);
People p2 = new People("jam",22);
System.out.println(p1.equals(p2));
System.out.println(p1==p2);
/*
其他类基本上都是重写了 equals() 比较的是内容是否相等
*/
Integer a1 = 128;
Integer a2 = 128;
System.out.println(a1.equals(a2));//调用的是Integer类的equals(),比较的是值
System.out.println(a1==a2);//128不在Integer范围区内，会创建Integer对象
}
String类/StringBuffer类/StringBuilder类
String类
字符串是多个字符组成的字符序列，是常量（值是不能改变的）。
有两种创建形式：
- String s = “abc”;
2.使用 new + 构造方法()创建
public static void main(String[] args) {
/*
String s = "abc";
String s1 = "abc";
第一次创建时，在字符串常量池中检测有没有，有则指向，没有就在字符串常量池中创建一个对象，再指向对象
第二次创建时，字符串常量池中有，则直接指向
*/
String s = "abc";
String s1 = "abc";
System.out.println(s.equals(s1));//true,
System.out.println(s==s1);//true
/*
使用 new + 构造方法()创建
在堆中创建新对象，值存储在对内存的对象中
只要是new创建的对象，在内存中一定是独一无二的对象空间
*/
String s2 = new String("abc");
String s3 = new String("abc");
System.out.println(s2.equals(s3));//true
System.out.println(s==s3);//false
}
字符串值是常量，值不能改变，一旦改变就是在内存中重新创建一个新对象来保存这个新的值。
/*
private final char value[];
字符串底层是char数组存储，单个字符存储
final修饰 所以是常量不可改变
*/
String类中常用的方法：
1.判断功能的方法
public static void main(String[] args) {
/*
判断功能
*/
String s = "abcdefg";
String s1= "abcdefg";
System.out.println(s.equals(s1));//true 判断字符串值是否相等
System.out.println(s.equalsIgnoreCase("aBCD"));//不区分大小写，判断字符串是否相同
System.out.println(s.contains("a"));//判断字符串中是否包含子串
System.out.println(s.contains("abc"));
System.out.println(s.isEmpty());//判断字符串是否为空
System.out.println(s.startsWith("ab"));//判断字符串是否是以指定前缀开头
System.out.println(s.endsWith("fg"));//判断字符串是否是以指定后缀结尾
System.out.println("c".compareTo("a"));//2 比较值（ASCLL/Unicode值相减）大小，用于排序比较
System.out.println("a".compareTo("a"));//0
System.out.println("a".compareTo("c"));//-2
}
2.获取功能的方法
public static void main(String[] args) {
/*
获取功能
*/
String s2 = "abcdefgcd";
//字符串下标：012345678
System.out.println(s2.length());//返回字符串长度
System.out.println(s2.charAt(2));//返回指定下标出处的字符
System.out.println(s2.indexOf("d"));//从下标0处向后找，返回指定字符第一次出现的下标
System.out.println(s2.indexOf("v"));//如果字符串中不包含指定字符，则返回-1
System.out.println(s2.indexOf("c",3));//从指定位置(下标)向后找 字符首次出现的位置
System.out.println(s2.indexOf("d",s2.indexOf("d")+1));//返回指定字符第二次出现的下标
System.out.println(s2.lastIndexOf("c"));//从后往前找字符首次出现的位置
System.out.println(s2.lastIndexOf("c",5));//从指定位置向前找 字符首次出现的位置
System.out.println(s2.substring(2));//返回字符串从指定下标处开始到字符串结束的新字符串
System.out.println(s2.substring(2,6));//返回字符串从指定下标开始到制定下标结束的新字符串
}
3.替换功能的方法
/*
替换功能
*/
public static void main(String[] args) {
String s = "abcdefgbcfes";
System.out.println(s.replace('e','E'));//参数为两个字符，用后面的字符替换前面的字符
System.out.println(s.replace("bc","BC"));//用后面的字符串替换前面的字符串
System.out.println(s);//字符串的值不可改变
String s1 = "bcde1fbc3g";
System.out.println(s1.replaceAll("\\d","BC"));//"\\d" 用指定字符串字符串替换原字符串中的数字
System.out.println(s1.replaceFirst("\\d","BC"));//"\\d" 用指定字符串字符串替换原字符串中的第一个数字
String s2 = " ab c ";
System.out.println(s2.length());//长度为6
String s3 = s2.trim();//去除字符串两端的空格
System.out.println(s3.length());//长度为4
String s4 = s2.replace(" ","");
System.out.println(s4.length());
}
4.转换功能的方法
/*
转换功能方法：
*/
public static void main(String[] args) {
String s = "abc";
byte[] b = s.getBytes();//字符串转换为字节数组 编码 字符——>字节
String s1 = new String(b);//字节数组转换为字符串 解码 字节-->字符
System.out.println(s1);
String ss = "中文";
try {
//使用给定的字符集将该字符串编码为字节序列，
byte[] bb = ss.getBytes("gbk");//gbk 规定一个中文对应两个字节
System.out.println(Arrays.toString(bb));
//通过 给定的字符集 将字节序列 解码为字符串
String sb1 =new String(bb,"gbk");
System.out.println(sb1);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
try {
byte[] bb1 = ss.getBytes("utf-8");//utf-8 规定一个中文对应三个字节
System.out.println(Arrays.toString(bb1));
String sb2 =new String(bb1,0,3,"utf-8");//取从第0位开始的三个字节
System.out.println(sb2);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String s2 ="abc";
char[] c = s2.toCharArray();//字符串转换为字符数组
System.out.println(Arrays.toString(c));
String s3 = new String(c);//字符数组转换为字符串
System.out.println(s3);
String s4 = "abcdEFGH";
System.out.println(s4.toUpperCase());//字符串全部转大写
System.out.println(s4.toLowerCase());//字符串全部转小写
/*
String s5 = s4.concat("hello");
String s6 = s4+"I"+"am"+"OK";
concat() 连接方法 效率高于 “ ”+“ "
*/
String s5 = s4.concat("hello");//字符串连接 将指定的字符串连接到该字符串的末尾。
String s6 = s4+"I"+"am"+"OK";//字符串连接，效率最低的字符串拼接
String s7 = "ab:cvafa:asdf:asfd:s";
String[] s8 = s7.split(":");//将字符串用指定的字符分割为字符串数组
System.out.println(Arrays.toString(s7));
String s9= "ab5cvafa4asdf3asfd2s";
String[] s10 = s9.split("\\d");//将字符串用指定的正则表达式分割为字符串数组
System.out.println(Arrays.toString(s6));
}
StringBuffer类
当我们对字符串进行拼接是，每次拼接，都会构建一个新的String对象，既耗时又浪费空间。而StringBuffer就可以解决这个问题。
StringBuffer：线程安全的可变字符序列
package day16;
public class StringBufferDemo {
public static void main(String[] args) {
/*
StringBuffer类
线程安全 的可变字符序列
对字符串进行拼接，每次拼接，不会创建新对象
*/
/*
无参的构造方法，底层创建一个长度为16的char数组 char[] value;
*/
StringBuffer s1 = new StringBuffer();
//有参的构造方法
StringBuffer s2 = new StringBuffer(10);//参数为底层创建数组的容量，即数组长度
StringBuffer s3 = new StringBuffer("hello");//总长度为： 字符串长度+16
/*
大量的字符串拼接，建议使用StringBuffer,不会创建新的对象
*/
s3.append("world");//字符串的拼接
s3.append("asdmd");
// s3.insert(4,"xxx");//在指定位置插入新的字串
// s3.delete(0,4);//删除从指定起始位置到指定结束的字符串
// s3.deleteCharAt(3) ;//删除指定位置的字符
// s3.replace(0,5,"BB");//替换
// s3.reverse();//字符串逆序/字符串反转
// s3.substring(2);
s3.substring(2,6);
// System.out.println(s3.length());
System.out.println(s3);
System.out.println( s3.substring(2,6));
}
}
StringBuilder类
public static void main(String[] args) {
/*
StringBuilder 内容可变
StringBuffer 线程安全 内容可变
String 内容不可变
*/
StringBuilder s = new StringBuilder();
//方法与StringBuffer相同
s.append("hhh");
System.out.println(s);
}