2.6JAVA中常见的类

发布时间：2024年01月24日

一、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 类<Integer> 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值中的较小值。

文章来源:https://blog.csdn.net/l20120/article/details/135711326
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！