Java常用类学习_java实用类介绍的学习-CSDN博客

本文链接：https://blog.csdn.net/wode6sarah/article/details/120027100

Java常用类学习

常用类

1、String

String表示是字符串， Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例。字符串是不变的，它的值在创建后无法更改。

2、StringBuilder

一个可变的字符序列。此类提供与StringBuffer兼容的API，但不保证同步。此类设计用作StringBuffer替代品，用于单个线程使用字符串缓冲区的位置（通常情况下）。在可能的情况下，建议使用此类优先于StringBuffer因为在大多数实现中它会更快。

3、StringBuffer

线程安全，可变的字符序列。字符串缓冲区类似于String ，但可以进行修改。在任何时间点它都包含一些特定的字符序列，但序列的长度和内容可以通过某些方法调用来改变。

字符串缓冲区可供多个线程使用。这些方法在必要时进行同步，以便任何特定实例上的所有操作都表现得好像它们以某个串行顺序出现，这与所涉及的每个单独线程所进行的方法调用的顺序一致。

StringBuffer上的主要操作是append和insert方法，它们被重载以接受任何类型的数据。每个都有效地将给定的数据转换为字符串，然后将该字符串的字符追加或插入字符串缓冲区。 append方法总是在缓冲区的末尾添加这些字符; insert方法在指定点添加字符。

4、三者之间的效率

效率: StringBuilder>StringBuffer>String

建议:
     少量做字符串操作    String
     单线程环境下大量做字符串操作   StringBuilder
     多线程环境下大量做字符串操作   StringBuffer

String,StringBuilder,StringBuffer之间的区别:
 1)是否可变
 2)同步问题
 3)效率问题

 jdk8及之前,内部默认通过char[] 存储字符串中的字符数据
 jdk9之后优化,通过字节数组,为了节省内存提高效率

 注意:
     StringBuilder与StringBuffer的扩容机制: 原容量的2倍+2

常用方法举例

public class Class004_StringBuilderStringBuffer {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "poi";
        String s4 = "bcd";
        //字符串变量 进行拼接的时候,jdk4默认构建StringBuffer,append做拼接,最后转为字符串
        // jdk1.5到1.8,会默认构建StringBuilder对象,append做拼接进行拼接,最后转为字符串
        //jdk9之后,InvokeDynamic 动态执行 通过makeConcatWithConstants方法提供的默认策略是通过字节数组byte[]实现
        String s3 = s1+s2+s4;

        //StringBuilder() 构造一个字符串构建器，其中不包含任何字符，初始容量为16个字符。
        StringBuilder sb  = new StringBuilder();
        StringBuilder sb2  = new StringBuilder("abc");
        System.out.println(s3);

        //StringBuilder append(String str) 将指定的字符串追加到此字符序列。
        String str = null;
        System.out.println(sb);
        /*扩容机制: int newCapacity = (oldCapacity << 1) + 2; 每次扩容原容量的2倍+2 */
        System.out.println(sb.append(str));
        System.out.println(sb);
        sb.append(false);

        System.out.println(sb.capacity());
        System.out.println(sb.length());

        //StringBuilder delete(int start, int end) 删除此序列的子字符串中的字符。  结束索引不包含
        System.out.println(sb);
        System.out.println(sb.delete(2,4));
        System.out.println(sb);

        //StringBuilder insert(int offset, double d) 在指定索引为值插入数据
        sb.insert(2,true);
        System.out.println(sb);

        //StringBuilder reverse() 翻转
        System.out.println(sb);
        sb.reverse();
        System.out.println(sb);

        /*
        *   StringBuilder 与 String相互转换的问题
        *       1.通过构造器
        *               StringBuilder(String str)
        *               String(StringBuilder builder)
        *       2.toString()
        * */
        System.out.println(sb.toString());
    }
}

string常用方法

public class Class003_StringMethod {
    public static void main(String[] args) {
        String  str = "jintianyusumanleme";

        //int indexOf(String str) 返回指定子字符串第一次出现的字符串中的索引。
        System.out.println(str.indexOf("n"));
        //int indexOf(String str, int fromIndex) 从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
        System.out.println(str.indexOf("n",4));
        //int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。
        System.out.println(str.lastIndexOf("n"));
        //int lastIndexOf(String str, int fromIndex) 返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。
        System.out.println(str.lastIndexOf("n"));
        System.out.println(str.lastIndexOf("n",12));
        //int length() 返回此字符串的长度。
        System.out.println(str.length());

        //String intern() 返回字符串对象的规范表示。  对于任何两个字符串s和t ， s.intern() == t.intern()是true当且仅当s.equals(t)为true 。
        String str1 = new String("haha");
        String str2 = new String("haha");
        System.out.println(str1==str2);
        System.out.println(str1.intern()==str2.intern());

        //boolean isBlank() 如果字符串为空或仅包含 white space代码点，则返回 true ，否则 false 。
        System.out.println("".isBlank());
        System.out.println("   ".isBlank());
        System.out.println("    ".isBlank());
        //boolean isEmpty() 返回 true ，当且仅当， length()是 0 。
        System.out.println("".isEmpty());
        System.out.println("   ".isEmpty());
        System.out.println("    ".isEmpty());

        //String repeat(int count) 返回一个字符串，其值为此字符串的串联重复 count次。
        System.out.println("abc".repeat(3));

        //String replace(CharSequence target, CharSequence replacement) 将此字符串中与文字目标序列匹配的每个子字符串替换为指定的文字替换序列。
        System.out.println(str.replace("an","AN"));

        //String[] split(String regex)  根据参数分隔符分隔字符串,返回字符串数组
        System.out.println(Arrays.toString(str.split("an")));

        //username=zhangsan&password=123
        String[] arr = "username=zhangsan&password=123".split("&");
        System.out.println(Arrays.toString(arr));

        for(String s:arr){
            String[] arr2 = s.split("=");
            System.out.println(arr2[1]);
        }

        /*
        String strip() 返回一个字符串，其值为此字符串，并删除了所有前导和尾随 white space 。
        String stripLeading() 返回一个字符串，其值为此字符串，并删除了所有前导 white space 。
        String stripTrailing() 返回一个字符串，其值为此字符串，并删除所有尾随 white space 。
        String trim() 返回一个字符串，其值为此字符串，删除了所有前导和尾随空格，其中space被定义为其代码点小于或等于 'U+0020' （空格字符）的任何字符。
         */
        System.out.println(" ");  //半角空格
        System.out.println("　");  //全角空格
        System.out.println("　棒棒糖的爱 ".trim());  //只识别半角空格
        System.out.println("　棒棒糖的爱 ".strip());  //全角空格与半角空格都能识别

        //String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。
        System.out.println(str);
        System.out.println(str.substring(3));
        //String substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串。
        System.out.println(str.substring(3,5));

        //char[] toCharArray() 将此字符串转换为新的字符数组。
        System.out.println(Arrays.toString(str.toCharArray()));

        //String toLowerCase() 使用默认语言环境的规则将此 String所有字符转换为小写。
        //String toUpperCase() 使用默认语言环境的规则将此 String所有字符转换为大写。
        System.out.println(str.toUpperCase());

        //static String valueOf(boolean b) 返回 boolean参数的字符串表示形式。
        System.out.println(String.valueOf(false));

    }
}

public class Class002_StringMethod {
    public static void main(String[] args) {
        String  str = "nitiannikaixileme";
        //char charAt(int index) 返回指定索引处的 char值。
        char ch = str.charAt(4);
        System.out.println(ch);
        //int codePointAt(int index) 返回指定索引处的字符（Unicode代码点）。
        System.out.println(str.codePointAt(4));
        //int codePointBefore(int index)

        //int compareTo(String anotherString) 按字典顺序比较两个字符串。
        //返回值: 0->this==anotherString   负数: this<anotherString     正数->this>anotherString
        System.out.println(str.compareTo("nitiannikaixileme"));
        //int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，忽略大小写差异。
        System.out.println(str.compareToIgnoreCase("Nitiannikaixileme"));

        //String concat(String str) 将指定的字符串连接到此字符串的末尾。
        System.out.println(str.concat("hahaha"));
        System.out.println(str);

        //boolean contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时，才返回true。
        System.out.println(str.contains("ni"));

        //boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。
        System.out.println(str.endsWith("me"));
        //boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开头。
        System.out.println(str.startsWith("ni"));
        //boolean startsWith(String prefix, int toffset) 测试从指定索引开始的此字符串的子字符串是否以指定的前缀开头。
        System.out.println(str.startsWith("ni",6));
    }
}

5、Arrays

Arrays是操作数组的工具类

package com.yjxxt.arrays02;

import java.util.Arrays;

/*
    Arrays 操作数组的工具类
        静态工厂
    数组: 存储多个数据
    变量: 存储单个数据
 */
public class Class001_Arrays {
    public static void main(String[] args) {
        int[] arr1  = {3,1,4,2,5};
        int[] arr2  = {3,1,4,2,5};
        int[][] arr3  = {{3,2,1},{4,5},{6}};
        int[][] arr4  = {{3,2,1},{4,5},{6}};

        //static String toString(boolean[] a)  返回指定数组内容的字符串表示形式。 -> 一维数组
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr3));
        System.out.println(Arrays.toString(arr4));

        //static String deepToString(Object[] a) 返回指定数组的“深层内容”的字符串表示形式。-->多维数组
        System.out.println(Arrays.deepToString(arr3));

        //static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。
        System.out.println(Arrays.equals(arr1,arr2));
        System.out.println(arr1==arr2);

        //static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定的数组彼此 深度相等 ，则返回 true 。
        System.out.println(Arrays.deepEquals(arr3,arr4));

        char[] arr = {'a','b','c'};
        System.out.println(arr1);
        System.out.println(arr);

        /*
            static int[] copyOf(int[] original, int newLength) 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
                截取   newLength<原数组长度original.length   新数组实现了对原数组中数据的截取效果
                拷贝   newLength = 原数组长度original.length  新数组中的数据与数组中的数据 Arrays.equals方法比较,相等,实现了原封不动的拷贝
                填充   newLength > 原数组长度original.length  把原数组中数据数据拷贝到新数组中索引为0的位置开始,省略空间通过默认值填充
               特点:
                 永远对于原数组都是从索引为0的位置开始拷贝
         */
        System.out.println(Arrays.toString(Arrays.copyOf(arr1,3)));
        System.out.println(Arrays.toString(Arrays.copyOf(arr1,5)));
        System.out.println(Arrays.copyOf(arr1,5)==arr1);
        System.out.println(Arrays.toString(Arrays.copyOf(arr1,10)));

        //static int[] copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到新数组中。
        System.out.println(Arrays.toString(Arrays.copyOfRange(arr1,1,4)));

        //以上两个方法copyOf,copyOfRange,新数组对象都是方法内部自动构建的,不是我们构建的

        /*
            static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置开始复制到目标数组的指定位置。
                src : 原数组
                srcPos : 原数组中要拷贝的数据的其实索引
                dest : 目标数组| 新数组
                destPos : 新数组中的其实索引
                length : 拷贝数据的长度
         */
        int[] arr5 = new int[10];
        System.out.println(Arrays.toString(arr5));
        System.arraycopy(arr1,1,arr5,6,3);
        System.out.println(Arrays.toString(arr5));

        /*
        static void fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。
        static void fill(int[] a, int fromIndex, int toIndex, int val) 将指定的int值分配给指定的int数组的指定范围的每个元素。  结束索引不包含
         */
        Arrays.fill(arr5,100);
        System.out.println(Arrays.toString(arr5));
        Arrays.fill(arr5,3,5,1000);
        System.out.println(Arrays.toString(arr5));

        //static void sort(int[] a) 将指定的数组按升序排序。
        //static void sort(int[] a, int fromIndex, int toIndex) 按升序对数组的指定范围进行排序。
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));

        String[] arr6 = {"c","bc","ab","a","b","abc"};
        Arrays.sort(arr6);
        System.out.println(Arrays.toString(arr6));

        /*
        static int binarySearch(int[] a, int key) 使用二进制搜索算法在指定的int数组中搜索指定的值。
            返回值: 数据所在的索引位置  如果不存在返回 -插入点-1
        static int binarySearch(int[] a, int fromIndex, int toIndex, int key) 使用二进制搜索算法搜索指定值的指定数组的范围。
         */
        System.out.println(Arrays.binarySearch(arr1,14));  //-6
    }
}

6、Math

Math是操作数学相关的工具类

package com.yjxxt.math04;
/*
    Math :
        数学相关类
        静态工厂
 */
import static java.lang.Math.PI;
import static java.lang.Math.round;
public class Class001_Math {
    public static void main(String[] args) {
        //static double abs(double a) 返回 double值的绝对值。
        System.out.println(Math.abs(-3.3));

        //static double ceil(double a)  向上取整 >=参数,离参数最近的整数
        System.out.println(Math.ceil(2.1));
        System.out.println(Math.ceil(-2.1));
        System.out.println(Math.ceil(3.0));
        //static double floor(double a) 返回小于或等于参数且等于数学整数的最大值（最接近正无穷大） double 。
        System.out.println(Math.floor(2.1));
        System.out.println(Math.floor(-2.1));
        System.out.println(Math.floor(3.0));

        //static int max(int a, int b) 返回两个 int值中较大的 int 。
        //static int min(int a, int b) 返回两个 int值中较小的 int 。
        System.out.println(Math.max(1.1,2.2));

        //static double pow(double a, double b) 返回第一个参数的值，该值是第二个参数的幂。
        System.out.println(Math.pow(2,3));

        /*
            static double random() 返回带有正号的 double值，大于或等于 0.0且小于 1.0 。
            [0.0,1.0)
            总结公式:
                随机整数 [min,max) -> (int)(Math.random()*(max-min)+min)  [0.0,1.0)*(max-min)->[0.0,max-min)+min->[min,max)
                随机整数 [min,max] -> (int)(Math.random()*(max-min+1)+min)

            Random 类  -> java.util包下  可以生成随机数
            随机数: 伪随机数
         */
        //[5,9)
        System.out.println((int)(Math.random()*(9-5)+5));
        System.out.println((int)(Math.random()*(9-5)+5));
        System.out.println((int)(Math.random()*(9-5)+5));
        System.out.println((int)(Math.random()*(9-5)+5));
        System.out.println((int)(Math.random()*(9-5)+5));
        System.out.println((int)(Math.random()*(9-5)+5));
        System.out.println((int)(Math.random()*(9-5)+5));
        System.out.println((int)(Math.random()*(9-5)+5));

        //static long round(double a) 返回与参数最接近的 long ，并将关系四舍五入为正无穷大。-> 针对于小数点后1位小数
        System.out.println(Math.round(3.5));
        System.out.println(round(3.49));

        //PI
        //静态导入
        System.out.println(Math.PI);
        System.out.println(PI);
    }
}

7、Date

Date是操作日期时间相关的工具类

package com.yjxxt.date05;

import java.util.Date;

/*
    Date 日期类型
        精确到ms数
 */
public class Class001_Date {
    public static void main(String[] args) {
        //Date() 分配 Date对象并对其进行初始化，使其表示分配时间，测量 Date到毫秒。
        Date date = new Date();
        System.out.println(date);
        //long getTime() 返回自此 Date对象表示的1970年1月1日00:00:00 GMT以来的毫秒数。
        System.out.println(date.getTime());

        //Date(long date) 分配 Date对象并初始化它以表示自标准基准时间（称为“纪元”）以来的指定毫秒数，即1970年1月1日00:00:00 GMT。
        Date date2 = new Date(1630401891077L);
        System.out.println(date2);

        //boolean after(Date when) 测试此日期是否在指定日期之后。
        //boolean before(Date when) 测试此日期是否在指定日期之前。
        System.out.println(date.after(date2));  //true
        System.out.println(date.before(date2));  //false
    }
}

SimpleDateFormat 日期格式转换器

package com.yjxxt.date05;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    SimpleDateFormat 日期格式转换类-> 转换器
        可以指定一个模板: 格式模板|默认格式
        可以实现日期对对象与指定格式字符串之间的转换
        format(Date) -> 日期对象转为字符串
        parse(String) -> 字符串转为日期对象
 */
public class Class002_SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        //构建一个默认转换格式的转换器
        SimpleDateFormat simple = new SimpleDateFormat();

        Date date = new Date();
        System.out.println(simple.format(date));

        //构建指定格式的转换器
        SimpleDateFormat simple2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
        System.out.println(simple2.format(date));
        //2028-01-31 17:37:03 048
        System.out.println(simple2.parse("2028年01月31日 17:37:03 048"));
    }
}

上面几个常用类需要重复练习，多敲

8、枚举类

枚举类是可以表示一种事物的所有可能，所有的实例，比如每周几天，一年几个月，一年几个季节

enum这是所有Java语言枚举类型的公共基类

枚举的属性都是默认public static final修饰，所以属性都是常量，不变的，命名需要大写

枚举类的构造器都是私有的，默认是private修饰，所有的枚举类都默认自动继承了Enum类

package com.yjxxt.enum06;

import java.util.Arrays;

/*
    Enum 枚举类
        可以表示一种事物的所有可能,所有的实例

     1.定义枚举类型通过enum关键字
     2.枚举类中的字段,都作为当前枚举类型的实例存在,默认修改符为  public static final
     3.构造器默认私有化
     4.定义所有的枚举类默认继承自java.lang.Enum,这是所有Java语言枚举类型的公共基类。
     5.枚举类中可以定义成员,根据需求定义
 */
public class Class001_Enum {
    public static void main(String[] args) {
        WDay sun = WDay.SUN;
        //使用枚举中的字段
        WeekDay mon = WeekDay.MON;
        //String name() 返回此枚举常量的名称，与其枚举声明中声明的完全相同。
        System.out.println(mon.name());
        //int ordinal() 返回此枚举常量的序数（它在枚举声明中的位置，其中初始常量的序数为零）。
        System.out.println(mon.ordinal());
        // values() 获取当前枚举类型的所有实例返回一个数组
        WeekDay[] days = mon.values();
        System.out.println(Arrays.toString(days));

        //switch
        switch(mon){
            case MON:
                System.out.println("星期一");
                break;
            case SUN:
                System.out.println("星期天");
                break;
        }

        WeekDay s = WeekDay.SUN;
        s.info();
    }

    @Override
    public String toString() {
        return super.toString();
    }
}

//一周中的天数
enum WeekDay{
    //枚举类中的字段
    //MON,SUN;
    MON("星期一"),SUN("星期天");

    //成员变量
    private String dayName;

    private WeekDay(){}
    //带参构造为成员变量初始化信息
    private WeekDay(String dayName){
        this.dayName = dayName;
    }

    //成员方法
    public void info(){
        System.out.println(dayName+"太开心了!!!!!");
    }
}


class WDay{
    public static final WDay MON = new WDay();  //星期一
    public static final WDay SUN = new WDay();  //星期天

    //私有的构造器
    private WDay(){}
}

包装类

基本类型的包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

包装类的自动拆装箱

自动拆装箱:
    自动装箱 : 基本 -> 引用
    自动拆箱 : 包装 -> 基本

有了基本数据类型为什么还要存在包装类?
    1.类中可以提供很多成员,实现不同的需求
    2.集合等中存储数据只能存储引用数据类型的数据
    3.引用数类型的默认值可以为null,也可以赋值为0,基本数据类型类型0,0.0..无法区分多种状态

为什么有了包装类还要提供基本数据类型?
     基本数据类型8中是最长用的数据类型,基本数据类型不需要new对象,直接表示对应的常量值,对于内存的节约利用率更好,效率更高

总结

Integer类型存在缓冲区对象，能表示的数据值在-128~127之间，但必须是自动装箱得到的Integer对象才能够使用到的缓冲区对象–>Integer.valueOf方法的内部源码

总结

当2个int做比较，只要int的数据值相等就相等，这时==比较的是数据值
两个new Integer（）比较肯定时不相等的，因为new对象后创建了新的地址，在堆内存中地址时不相同的
int与Integer或者new Integer（）比较时，只要数据值相等它们就相等，因为Integer或者new Integer（）在比较时会发生自动拆箱，再去和int比较
Integer与new Integer（）肯定不相等，因为创建了新的地址
2个Integer比较，只要数据值在-128~127之间就相等，超出范围就不相等，超出范围就相当与new Integer

注意