2.6JAVA中常见的类
一、Java中常用类的学习
1.1什么是常用类，为什么要学习常用类
实际开发中我们需要用到大量的类，而有的类是jdk已经帮我们开发好了，我们可以直接使用的类，可以大大的节省我们设计类的时间，提高开发效率。这些经常使用到的JDK类，就是Java的常用类。
1.2如何使用Java常用类
要使用Java中类，无非也就是使用类中的成员，包括：实例变量、类变量、实例方法、类方法、构造方法等。
1.2.1实例变量
需要通过对象调用，就叫实例变量
1.2.2类变量
通过类名.变量名直接调用
1.2.3实例方法
需要通过对象调用\，所以，先通过new类名(...)调用构造方法创建对象,然后通过创建好的对象调用实例方法。
例如：
调用String类中的charAt(int index)方法
1.2.4类方法
直接通过类名.方法名调用
1.2.5构造方法
直接new类名(...)调用构造方法创建对象
注意：
Java中的类有很多，方法也有很多可以用 ctrl+o查看当前类有哪些方法，但是太多了根本记不住，我们会用百度和API查询到就好了，不用记的
2.字符串相关类
String类，StringBuffer类，StringBuiler类
2.1什么是字符串
双引号之间的数据就是String数据类型中的常量，它在JAVA中属于引用数据类型。
2.2学习字符串的哪些东西
-
学习字符串类String、StringBuilder、StringBuffer的底层原理，进而掌握使用场景。
-
学习字符串类String、StringBuilder、StringBuffer类的常用方法
2.3使用字符串类
2.3.1String类
根据API查询我们可以知道
2.3.1.1字符串常量池
(1) 当第一次使用String str = "A"; 的方式赋值，会将该字符串值【对象】放入到常量池
(2) 当再次使用String str = "A"; 的方式会先检查常量池是否有"A"值，
① 如果存在直接引用
② 如果不存在，会创建"A"放入常量池
(3) 字符串拼接
① 常量方式拼接，并直接使用赋值符号赋值，会检查常量池
② 变量方式拼接，不会检查常量池
String s1 = "A"+"BC";// 使用常量拼接,会检查常量区是否有拼接好的"ABC",如果有不会创建
String str = "A";
String s2 = str + "BC";// 使用变量拼接，不会检查常量区，而直在常量池接创建对象注意：\常量池的使用是为了提高程序执行效率，因为在Java中字符串常量使用非常频繁，所以，为了节省创建字符串对象的时间，使用了常量。其实，常量对于我们开发没有影响，我们只关心代码的执行效果。
2.3.1.2String类的常用方法
import java.util.Arrays;
public class Str_method {
public static void main(String[] args) {
// 常用方法：
// 1.char charAt(int index) 返回 char指定索引处的字符。 不能超过下标范围
String str = "我qunianmailegebiao";
System.out.println(str.charAt(4));
// 2.String concat(String str) 将指定的字符串连接到该字符串的末尾。 相当于：+
String i1 = "nihao";
System.out.println(str.concat(i1));
/*
* 3.boolean contains(CharSequence s) 判断当前对象是否包含连续的参数s。s可以是以下三个子类的对象
* CharSequence接口，包含下面子类：String、StringBuffer、StringBuilder
*/
System.out.println(str.contains("qun"));
// 4.boolean endsWith(String suffix) 判断当前字符串是否以指定的后缀suffix结尾。（参数必须连续）
// 5.boolean startsWith(String prefix) 判断当前字符串是否以指定的前缀prefix开头。 （参数必须连续）
str = "速度与激情8.avi";
System.out.println(str.endsWith(".mp4"));
System.out.println(str.startsWith("黄"));
/*
* 8.void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
* srcBegin：字符串开始下标
* srcEnd：字符串结束下标(不包含)
* dstBegin：数组dst的下标
* 将此字符串中的字符复制到目标字符数组dst中。 (含头不含尾)[srcBegin,srcEnd)
*/
str = "abceeeabcdefg";
char[] i2 = new char[5];
str.getChars(3,5,i2,3);
System.out.println(Arrays.toString(i2));
// 9.int indexOf(String s) 返回s第一次在当前对象str中出现的索引 ，-1表示没有找到（注意：这里s必须也是匹配连续的字符串）
System.out.println(str.indexOf("d"));
// 10.int indexOf(String s, int fromIndex) 返回s在当前对象指定下标fromIndex后第一次出现的索引 (str是作为一个整体匹配下标的)
System.out.println(str.indexOf("d", 4));
// 11.int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。
// 12.int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向前搜索。
System.out.println(str.lastIndexOf("e"));
// 13.boolean isEmpty() 当 length()为 0时，返回 true 。
System.out.println(str.isEmpty());
// 14.int length() 返回此字符串的长度。
// 15.boolean matches(String regex) 判断当前字符串对象是否匹配给定的正则表达式regex，通常用来进行权限限制，字符格式限制 一般用了做校验：如，用户名和密码的合法性
str = "abc";
/*
* 16.String replace(CharSequence target, CharSequence replacement) 将当前字符串中的target替换为replacement,通常用来和谐用语
* 父接口：CharSequence
* 该接口的实现类：String、StringBuffer、StringBuilder
*/
str = "WQNMLGB，你个DSB，我CNM";// WQNMLGB/DSB/CNM：和谐用语
System.out.println(str.replace("NM", "**"));
/**
* replace()和replaceAll()，replaceFirst()区别
* replace()只能匹配String、StringBuffer、StringBuilder对象
* replaceAll()和replaceFirst()可以匹配正则表达式，更灵活
* 如：
*/
// 17.String replaceAll(String regex, String replacement) regex是正则表达式，将当前字符串中的regex全部替换为replacement
str = "abc.efdg";
// regex = "\\.";// 正则表达式中的.表示匹配任意一个字符
// regex = "\\.";// 正则表达式中的\\.表示匹配一个.
// 18.String replaceFirst(String regex, String replacement) 将当前字符串中的第一个regex替换为replacement
// 19.String[] split(String regex) 将当前字符串对象按照给定的正则表达式regex分割为String[]
str = "172.168.11.65;192.168.11.66;172.168.11.69;169.168.11.169;";
// 请将当前str中所有的ip地址打印出来
System.out.println(Arrays.toString(str.split(";")));
// 20.CharSequence subSequence(int beginIndex, int endIndex) 从当前字符串中beginIndex和endIndex之间截取子串（含头不含尾）
System.out.println(str.subSequence(4, 7));
// 21.String substring(int beginIndex) 从当前字符串中截取beginIndex到最后的子串
// 22.String substring(int beginIndex, int endIndex) 从当前字符串中beginIndex和endIndex之间截取子串（含头不含尾）
str = "172.168.11.65;192.168.11.66;172.168.11.69;169.168.11.169;";
// 请将字符串中ip是172开头的 最后一段打印出来
/*
* 思路：
* 1. 将字符串str先进行按照;分割
* 2. 遍历字符串数组，判断字符串以172开头的
* 3. 在以172的字符串中，再截取最后一个.后面的字符，打印
*/
String[] arr = str.split(";");
for (String e:arr) {
if(e.contains("172")){
System.out.println(e.substring(11));
}
}
// 从最后一个点截取剩余字符串 ：String substring(int beginIndex)
// 23.char[] toCharArray() 将此字符串转换为新的字符数组。 方便遍历当前所有的字符
str = "abcdef";
char[] chars = str.toCharArray();
System.out.println(chars);
// 24.String toUpperCase() 将此字符转换为全大写 一般用于验证码
// 25.String toLowerCase() 将此字符转换为全小写 一般用于验证码
System.out.println(str.toUpperCase());
// 26.String trim() 将当前字符串对象中字符前面和后面的空格去除 用了避免用户的一些不当输入
// 27.static String valueOf(Object obj) 将其他类型转换为String对象
}
}
2.3.1.3String小结
-
String 字符串类，底层是基于char[]变量, 一旦创建长度就固定不变了,适用于字符串不经常增删改的操作的场景。
父接口：CharSequence，该接口的实现类：String、StringBuffer、StringBuilder。
-
将其他类型转换为String类型不同方式效率对比：【掌握】
toString() > String.valueOf(Object obj) > +
因为+号，底层先将字符串对象转换为StringBuilder对象，然后调用StringBuilder对象的append追加字符串方法，再调用toString方法，转换为String对象
2.3.2StringBuilder类
. StringBuilder概述:
StringBuilder基于可变的char[]，默认长度是16个，适用于频繁操作（增删改插）字符串的场景，该类是线程不安全的。
StringBuilder：
1）是一个字符串缓冲区，其实就是一个容器；
2）长度是可变的，任意类型都可以。注意：是将任意数据都转成字符串进行存储；
3）容器对象提供很多对容器中的数据操作的功能，比如添加，删除，修改，查询；
4）所有的数据最终都会变成一个字符串；
和数组最大的不同就是数组存储完可以单独操作每一个元素，每一个元素都是独立的。
字符串缓存区，所有存储的元素都会被转成字符串，而且变成了一个更长的字符串。
2. StringBuilder类的常用方法
-
构造方法:
1.1 对于StringBuilder()构造方法，其初始容量为16个字符表示，如果存在StringBuilder的数据超过了16个字符，这个容器可以自动扩容(容器空间自动变大)。（经常使用）
解释：StringBuilder底层体现就是一个字符数组，StringBuilder类的对象将数组封装起来，然后对外提供很多便捷方法，而数组本身是没有什么太多方法的。如果外界将数据存放到底层的数组中，如果底层数组空间存放不下外界传递过来的值，那么jvm会基于原来存在的数组在创建一个新的数组，长度是原来数组的一倍，然后jvm将原来数组的数据全部复制（遍历数组，将数据添加到新的数组中）到新的数组中，然后在数组后面的空间中给数组添加新的值，如果还是存不下在创建一个新的数组。
1.2 对于StringBuilder(int capacity)构造函数来说，capacity表示容器的容量，如果在开发中想自己设置缓冲区大小，可以通过此构造函数来实现；
/*
* 构造方法：
* 1.StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。
2.StringBuilder(CharSequence seq) 构造一个包含与指定的相同字符的字符串构建器 CharSequence 。
3.StringBuilder(int capacity) 构造一个没有字符的字符串构建器，
由 capacity参数指定的初始容量。 指定长度capacity可以节省了数组扩容时间
4.StringBuilder(String str)构造一个初始化为指定字符串内容的字符串构建器。
*
*/
StringBuilder sb = new StringBuilder();// 创建一个默认16个长度的char[]数组
StringBuilder sb2 = new StringBuilder("abc");// 创建一个19个长度的char[]数组任何容器：它都围绕容器中的数据的 增 删 改 查\ 而设计的方法。
成员方法
/*
* 常用方法：
* 1. StringBuilder append(Object obj) 在队尾添加字符串
* 2. StringBuilder delete(int start, int end) 删除指定起始和结束位置之间的字符（含头不含尾）
* 3. StringBuilder deleteCharAt(int index) 删除指定下标处的字符
* 4. StringBuilder insert(int offset, Object obj) 在指定下标处插入一个任意类型数据
* 5. StringBuilder reverse()将字符串翻转
* 6. void setCharAt(int index, char ch) 修改指定下标处的字符为ch
7. void setLength(int newLength) 设置字符串长度是newLength
8. trimToSize() 将所有没有使用的数组空间去除 。 如果使用setLength,该方法无效
* 9. int capacity() 返回当前容量。(理论值)
10.public int length()返回长度(实际值，即已经存储的字符个数)
*/
// append方法
sb.append(true).append("abc");// 因为append方法返回值类型是StringBuilder，所以可以接着调用方法
System.out.println("sb = " + sb);// trueabc
// delete方法
sb.delete(0, 3);// 含头不含尾【下标】
System.out.println(sb);
// 3. StringBuilder deleteCharAt(int index) 删除指定下标处的字符
sb.deleteCharAt(0);
System.out.println(sb);
// insert
sb.insert(0,true).insert(0,"狼牙棒").insert(0, new Object());
System.out.println(sb);
// reverse()
sb.reverse();
System.out.println(sb);
// setCharAt()
sb.setCharAt(0, '插');// 将下标0处的字符修改为 插
System.out.println(sb);
// setLength()
// sb = new StringBuilder();
sb.setLength(1000);
System.out.println("设置后的长度：" + sb.length());
System.out.println("容量：" + sb.capacity());
System.out.println(sb);
// int capacity() 返回当前容量。
sb = new StringBuilder("abcd");//长度20
int capacity = sb.capacity();
System.out.println("容量：" + capacity);
System.out.println("==================");
// trimToSize() 将所有没有使用的数组空间去除
sb.trimToSize();
capacity = sb.capacity();
System.out.println("容量：" + capacity);
System.out.println("长度：" + sb.length());
sb = new StringBuilder();
System.out.println("容量：" + sb.capacity());
System.out.println("长度：" + sb.length());2.3.3StringBuffer类
-
StringBuffer概述
StringBuffer类，功能上基本上跟StringBuilder类相同，只是StringBuffer是线程安全的，相比较StringBuilder而言StringBuffer效率更低一点,要做线程处理。
-
StringBuffer中的常用方法参考StringBuilder
2.3.4. String、StringBuilder、StringBuffer小结和使用场景
String 字符串类，底层是基于final char[], 一旦创建长度就固定不变了,适用于字符串不经常增删改的操作的场景。
StringBuilder: 基于可变的char[]，默认长度是16个，适用于频繁操作（增删改插）字符串的场景，
该类是线程不安全的。
StringBuffer:基于可变的char[]，默认长度是16个，适用于频繁操作（增删改插）字符串的场景，
该类是线程安全的。
如果是单线程和多线程没有线程安全要求，用StringBuilder。
如果是多线程有线程安全要求，用StringBuffer
如果不经常操作字符串用 String节省空间
StringBuffer和StringBuilder扩容机制：当要添加的字符串大于 > 当前字符数组的长度的时候扩容，扩容是： 原来长度*2+2 的方式扩容
3.包装类
3.1为什么要使用包装类
既然有了int干嘛还需要一个Integer，感觉差不多
1) Integer类（字段，方法），在这个类中把int的位数，最大值，最小值写成常量了
2) Integer类中提供了一些有用的方法：例如int-String之间的转换，和其它的数据类型的转换
常用方法
/*
* 调用Integer类中的常量字段： 调用方式：类名.字段名
* static int BYTES 用于表示二进制补码二进制形式的 int值的字节数。
static int MAX_VALUE 一个持有最大值一个 int可以有2 31 -1。
static int MIN_VALUE 的常量保持的最小值的 int可以具有，-2 31。
static int SIZE 用于表示二进制补码二进制形式的 int值的位数。
static 类 TYPE 类原始类型 int的 类实例。
*/
// 调用Integer类中的常量: static int MAX_VALUE
System.out.println(Integer.MAX_VALUE);// 2147483647
System.out.println(Integer.MIN_VALUE);// -2147483648
/*
* 因为当前类中有非static方法，所以需要创建对象
* 构造方法：
* 1.Integer(int value) 将int参数转换为Integer对象
2.Integer(String s) 将String参数s转换为对应的Integer对象，注意，必须保证字符串只能是数字，负责会报错NumberFormatException。
*/
Integer integer = new Integer(128);
System.out.println(integer);//123
// 构造方法:2.Integer(String s) 使用
Integer integer2 = new Integer("123");//NumberFormatException数字格式异常，通常是将字符串转换为数值类型的时候，有非数字的字符的时候发生该错误
System.out.println(integer2);
// 调用普通方法：1. static修饰的 => 类名.方法名(....) 2. 非static修饰的 => 对象名.方法名(....)
// 1. byte byteValue() 将当前的Integer对象转换为byte类型。 如果超出表示范围，会强制转换
byte byteValue = integer.byteValue();//转换的时候，如果超过byte表示范围，会以二进制方式进位
System.out.println(byteValue);
// 2. static int max(int a, int b) 返回两个 int的较大值，就像调用 Math.max一样 。
int max = Integer.max(1, 2);
System.out.println("最大值：" + max);
// 3. static int min(int a, int b) 返回两个 int的较小值，就像调用 Math.min一样 。
/*
* 4. static int parseInt(String s) 将字符串参数转换为有正负的十进制整数。
* 如果参数s有有非数字相关的字符，会报NumberFormatException数字格式异常，通常是将字符串转换为数值类型的时候，有非数字的字符的时候发生该错误
*/
// 5. static int sum(int a, int b) 根据+运算符将两个整数相加。
// 6. static String toHexString(int i) 将int类型的十进制值转换为十六进制的值
// 7. static Integer valueOf(String s) 将String类型转换为Integer类型 自动装箱拆箱
1) 自动装箱 ： Integer i1 = 123;
2) 自动拆箱 ： int i2 = i1;
3) 手动装箱： int i2 = new Integer(123);
4) 手动拆箱： int i2 = i1.intValue();
享元模式
/* [-128~127]缓存,对象Integer的对象!当采用赋值方式,会先到缓存中查找是否有值缓存着,如果有,直接使用引用地址 */
Integer i1 = 20;
Integer i2 = 20;
System.out.println(i1 == i2);// true此处不存在拆箱比较值，比较的是对象的地址
/* 但凡是new 都会在堆内存中,创建一个新的对象,对象的地址值不一样 */
Integer i3 = new Integer(20);
Integer i4 = new Integer(20);
System.out.println("i3 == i1 "+(i3 == i1));//false
System.out.println(i3 == i4);//false
/* 赋值范围超过缓存值的范围,享源模式中没有缓存值，则会自动创建对象 */
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);
/* 上面比较的都是Integer 对象 */
System.out.println(i1.equals(i2));// true
System.out.println(i1.equals(i3));// true
System.out.println(i3.equals(i4));// true
/* 在强化,对象值比较还是用equals(),java中Integer 已经覆写了equals() */4.数学相关类
/*
* Math中常量： 调用常量：类名.常量名
* 类名.常量名：
static double E
static double PI
*/
System.out.println(Math.PI);
// 调用方法：调用方法（都是static修饰的）
// 1. static double abs(double a)返回值为 double绝对值。
// 2. static double ceil(double a) 天花板，向上取整
System.out.println(Math.ceil(3.14));//4.0
// 3. static double floor(double a) 地板，向下取整
System.out.println(Math.floor(3.14));//3.0
// 4. static long/int round(double a) 四舍五入
System.out.println(Math.round(3.45));//4
// 5. static double max(double a, double b)返回两个 double值中的较大值。
// 6. static double min(double a, double b)返回两个 double值中的较小值。