【JAVA】Java 常用类

Java 常用类

一、内部类

在一个类内部再定义一个完整的类

　　「采用内部类这种技术，可以隐藏细节和内部结构，封装性更好，让程序的结构更加合理！如果类很多且都暴露在外面，那么类与类之间的调用就会十分繁琐！」


1.成员内部类（非静态内部类）

package com.demo;

// 类文件名
public class Demo {
    // 成员变量
    private String demoName;

    // 成员方法
    public void demoMethod(){
        System.out.println("这个是外部类方法~");
        System.out.println(demoName);
    }

    // 内部类
    public class DemoInner{
        // 内部类成员变量
        private String innerDemoName;

        // 构造方法
        public DemoInner(){
            innerDemoName = "demo inner class";
        }

        // 成员方法
        public void demoMethod(){
            System.out.println("这个是内部类方法");
            System.out.println(innerDemoName);
        }
    }

    // 主方法
    public static void main(String[] args){
        Demo demo = new Demo();
        demo.demoMethod(); // 调用外部类方法

        // 这个类是内部类，已经不是独立的类了，因此不能像外部类一样直接创建！
        Demo.DemoInner demoInner = demo.new DemoInner(); // 同成员方法/变量 只是加了个前缀
        demoInner.demoMethod(); // 调用内部类方法
    }
}
示例

 

执行结果

 

2.局部内部类

package com.demo;

// 类文件名
public class Demo {
    // 成员变量
    private String demoName;

    public void disDemoMethod(){
        // 局部内部类
        class InnerClass{
            public void print(){
                System.out.println("这是一个局部内部类方法");
            }
        }

        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }

    // 主方法
    public static void main(String[] args){
        Demo demo = new Demo();
        demo.disDemoMethod(); // 调用disDemoMethod

    }
}
局部内部类 示例

 

执行结果

 

3.匿名内部类

 没有名字的内部类 「主要应用与接口的实现！」

 Tips：「它的实现类不需要去单独创建一个文件去写它的实现」

package com.demo;

public interface DemoInterface {
    public void demo();

    public void demoD(int x, int y);
}
接口
package com.demo;

// 实现类
public class DemoModel implements DemoInterface {
    @Override
    public void demo() {
        System.out.println("test");
    }

    @Override
    public void demoD(int x, int y){
        System.out.println(x+y);
    }

}
实现类
package com.demo;

// 匿名内部类
public class DemoAi implements DemoInterface {
    @Override
    public void demo(){
        System.out.println("moon");
    }

    @Override
    public void demoD(int x, int y){
        System.out.println(5*6);
    }
}
匿名内部类

 

    // 主方法
    public static void main(String[] args){
        DemoModel demoModel = new DemoModel();
        demoModel.demo();
        demoModel.demoD(1, 2);

        DemoAi demoAi = new DemoAi();
        demoAi.demo();
        demoAi.demoD(8,6);
    }

 

 执行结果

 

 

String类

通过String可以直接定义一个变量，这个变量可以直接就是字符串  <在包 java.lang.String>

1.构造方法

package com.str;

public class DemoString {

    // 字符串构造
    public void strBuild(){

        // 直接定义字符串
        String str1 = "this is strMethod~";
        System.out.println("直接定义字符串 输出str1 = " + str1);

        // 通过new String 对象
        String str2 = new String("new String");
        System.out.println("通过new String 对象 输出str2 = " + str2);

        // 通过字符数组进行构造
        char[] chars = {'a', 'b', 'c'};
        String str3 = new String(chars);
        System.out.println("通过字符数组进行构造 输出str3 = " + str3);

    };

    public static void main(String[] args){
        DemoString demoString = new DemoString();
        demoString.strBuild();
    }
}
DemoString.java

执行结果

 

2. 常用方法

package com.str;

public class DemoString {

    // 字符串方法
    public void strMethod(){
        String str = " My name is Phoenix~Phoenix~Phoenix";
        System.out.println("原字符串内容："+ str);
        System.out.println("字符串的长度=" + str.length());
    }

    public static void main(String[] args){
        DemoString demoString = new DemoString();
        demoString.strMethod();

    }
}

 

 执行结果：

 

        // 字符串替换
        System.out.println("将所有“Phoenix”字符串替换为“Young”, 替换后内容：" + str.replace("Phoenix", "Young"));    // 替换字符串中的字符/字符串
        System.out.println("将所有“Phoenix”字符串替换为“Young”, 替换后内容：" + str.replaceAll("Phoenix", "Young"));     //替换字符串中的字符串
        System.out.println("将首个“Phoenix”字符串替换为“Young”, 替换后内容：" + str.replaceFirst("Phoenix", "Young"));       //替换字符串中的首个字符串

 执行结果： 

 

        // 字符串查找
        System.out.println("输入位置9，查找字符串的单个字符：" + str.charAt(9) );
        System.out.println("返回字符e第一次出现在字符串str中的位置下标：" + str.indexOf("e"));
        System.out.println("从8位置查找字符e第一次出现在字符串str中的位置下标<-1表示未找到>：" + str.indexOf("e", 8));
        System.out.println("从后向前查找字符e第一次出现在字符串str中的位置下标<-1表示未找到>：" + str.lastIndexOf("e", 8));

 

执行结果：

 

        // 字符串截取
        System.out.println("从下标3开始截取到下标13字符串：" + str.substring(3, 13));

 

执行结果： 

 

        // 字符串拆分
        String[] spl = str.split(" ", 1);   //  limit 限制拆分几次， 特殊字符(| + * . ,)作为分割符可能无法正确切分, 需要加上转义符号 \\
        for(String s: spl){
            System.out.println("拆分后的单个字符：" + s);
        }

 

执行结果：

 

 

        // 转化 <数字转字符串>
        // String a = 12.236;  // java: 不兼容的类型: double无法转换为java.lang.String
        String aa = String.valueOf(12.863);
        System.out.println("数字转字符串：" + aa);
        int b = Integer.valueOf("8886");
        System.out.println("数字字符串转化数字：" + b);

 

执行结果：

 

        // 字母转换 // 只转化字符串中的字母，汉字不影响  // 非原字符串修改，产生新的字符串
        System.out.println("小写字母转大写:" + str.toUpperCase());
        System.out.println("大写字母转小写:" + str.toLowerCase());

 

执行结果：

 

        // 数组转字符串
        char[] ite = {'i', 's', 'b', 'a', 'b', 'y'};
        System.out.println("数组转字符串：" + new String(ite));

 

执行结果：

 

        // 格式化字符串
        String dateday = String.format("%d-%d-%d %d:%d:%d", 2023,5,8,15,21,31);
        System.out.println("格式化输出" + dateday);

 

执行结果：

 

        // 去除字符串前后空格
        System.out.println("去除字符串前后空格："+ str.trim());

 

执行结果：

 

        // 字符串比较
        String s1 = "hello";
        String s2 = "Hello";
        String s3 = "hello";
        System.out.println("比较字符串的地址:" + (s1 == s2.toLowerCase()));   // 对于引用类型，==比较的是地址; 对于基本类型变量，比较的是存储的值
        System.out.println("比较字符串的地址:" + (s1 == s3));
        System.out.println("直接比较大小关系：" + s1.compareTo(s2));
        System.out.println("忽略大小写进行比较：" + s1.compareToIgnoreCase(s2));

        System.out.println("s2转换为小写，比较是否相同：" + s1.equals(s2.toLowerCase()));
        System.out.println("比较是否相同：" + s1.equals(s2));
        System.out.println("忽略大小写进行比较是否相同：" + s1.equalsIgnoreCase(s2));

 

执行结果：

 

Date 及 Calendar 类 

 Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年

 1、构造方法

  　　Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。

　　  Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时

package com.common;

import java.util.Date;

public class DemoDate {

    public void DateBulid(){
        Date cst = new Date();
        System.out.println("系统当前的时间:" + cst);

        Date gmt = new Date(0);  // 60000 毫秒是一分钟
        System.out.println("距离 GMT 指定毫秒数的时间:" + gmt);   //Thu Jan 01 00:00:00 CST 1970
    }

    public static void main(String[] args) {
        DemoDate demoDate = new DemoDate();
        demoDate.DateBulid();
    }
}
DemoDate.java

 执行结果：

 

2、java.util.Date 常用方法

 

package com.common;

import java.util.Date;

public class DemoDate {

    public void DateBulid(){
        Date cst = new Date();
        System.out.println("系统当前的时间:" + cst);

        Date gmt = new Date(cst.getTime());  // 标准基准时间 60000 毫秒是一分钟
        System.out.println("距离 GMT 指定毫秒数的时间:" + gmt);   //Thu Jan 01 00:00:00 CST 1970
    }

    public void DateMethod(){
        Date d = new Date();
        Date dd = new Date(d.getTime()+60000);
        System.out.println("系统当前时间："+d);
        System.out.println("系统当期时间+1min："+dd);
        System.out.println("浅拷贝:" + dd.clone());

        System.out.println("获取时间毫秒数:" + d.getTime());
        System.out.println("比较日期大小：" + d.compareTo(dd));    //1:括号内日期比前面日期小  -1:括号内日期比前面日期大 0:两日期相等
        System.out.println("判断时间号内日期是否在比较日期之后:" + d.after(dd));
        System.out.println("判断时间号内日期是否在比较日期之前:" + d.before(dd));
        System.out.println("将Date对象转换为Instant对象<显示标准时间，时区相差8>:" + d.toInstant());
        System.out.println("将Instant对象转换为Date对象:" + dd.from(d.toInstant()));

    }

    public static void main(String[] args) {
        DemoDate demoDate = new DemoDate();
        demoDate.DateMethod();  // 常用方法
        System.out.println("");
        demoDate.DateBulid(); // 构造方法

    }
}
DemoDate.java

 

执行结果

 

java.util.Calendar  <Calendar是一个抽象类不能像Date类直接通过new创建。通过内部的getInstance方法创建>

 3、java.util.Calendar 常用方法

 

package com.common;

import java.util.Calendar;
import java.util.Date;

public class DemoDate {


    public void DateUtilMethod(){
        Date d = new Date();
        Date dd = new Date(d.getTime()+60000);
        System.out.println("系统当前时间："+d);
        System.out.println("系统当期时间+1min："+dd);
        System.out.println("浅拷贝:" + dd.clone());

        System.out.println("获取时间毫秒数:" + d.getTime());
        System.out.println("比较日期大小：" + d.compareTo(dd));    //1:括号内日期比前面日期小  -1:括号内日期比前面日期大 0:两日期相等
        System.out.println("判断时间号内日期是否在比较日期之后:" + d.after(dd));
        System.out.println("判断时间号内日期是否在比较日期之前:" + d.before(dd));
        System.out.println("将Date对象转换为Instant对象<显示标准时间，时区相差8>:" + d.toInstant());
        System.out.println("将Instant对象转换为Date对象:" + dd.from(d.toInstant()));

    }

    public void DateCalendarMethod(){
        Calendar instance = Calendar.getInstance(); // 默认toString

        System.out.println("默认："+ instance);
        System.out.println("返回Date类：" + instance.getTime());
        System.out.println("传入Calendar类定义的常量<日>，返回对应信息:" + instance.get(Calendar.DAY_OF_MONTH));

    }

    public static void main(String[] args) {
        DemoDate demoDate = new DemoDate();
        demoDate.DateCalendarMethod();  // java.util.Calendar常用方法
//        demoDate.DateUtilMethod();  // java.util.Date常用方法
        System.out.println("");
        demoDate.DateBulid(); // 构造方法

    }
}
DemoDate.java

 

执行结果

 


4、SimpleDateFormat  日期格式化

y 年; M 月; d 日; H 时; m 分; s 秒

构造方法

无参构造方法public SimpleDateFormate()：使用默认模式和日期格式
带参构造方法public SimpleDateFormate(String pattern)：使用给定的模式和默认的日期格式

 

 

常用方法

 

package com.common;

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

public class DemoDate {

    public void DateFormatMethod(){
        String d = "2023年05月09日 09:15:31";
        Date datea = new Date();
        // 格式化
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        SimpleDateFormat simpleDateFormatPattern = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        System.out.println(simpleDateFormat.format(datea));
        System.out.println(simpleDateFormatPattern.format(datea));
        // 从给定字符串的开始解析文本以生成日期
        try {
            datea = simpleDateFormatPattern.parse(d);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(datea);


    }

    public static void main(String[] args) {
        DemoDate demoDate = new DemoDate();
        demoDate.DateFormatMethod();  // java.sql.Date常用方法

        System.out.println("");

    }
}
DemoDate.java

 

执行结果

 

 

 

BigDecimal类

BigInteger 和 BigDecimal 都能实现大数字的运算，不同的是 BigDecimal 加入了小数的概念

构造方法

BigDecimal(double val)：实例化时将双精度型转换为 BigDecimal 类型。
BigDecimal(String val)：实例化时将字符串形式转换为 BigDecimal 类型。

 

 

常用方法

     

 

package com.common;

import java.math.BigDecimal;
import java.util.Scanner;

public class DemoDecimal {
    public void DecMethod(){
        // 扫描输入文本
//        Scanner scanner = new Scanner(System.in);
//        System.out.println("请输入数字：");
//        // 保存用户输入的数字
//        double num = scanner.nextDouble();
//        // 使用输入的数字创建BigDecimal对象
//        BigDecimal bigDecimal = new BigDecimal(num);

        // 创建BigDecimal对象
        BigDecimal db = new BigDecimal(999.99);

        // 加法
//        System.out.println(bigDecimal.add(new BigDecimal(99.543)));
        System.out.println("加法:" + db.add(new BigDecimal(5)));
        System.out.println("减法:" + db.subtract(new BigDecimal(99.5)));
        System.out.println("乘法:" + db.multiply(new BigDecimal(0.5)));
        System.out.println("除法(保留2位):" + db.divide(new BigDecimal(5), 2, BigDecimal.ROUND_CEILING));
        System.out.println("除法(保留6位):" + db.divide(new BigDecimal(5), 6, BigDecimal.ROUND_CEILING));


    }

    public static void main(String[] args) {
        DemoDecimal demoDecimal = new DemoDecimal();
        demoDecimal.DecMethod();
    }
}
DemoDecimal.java

 

执行结果

 

 

Math类

 

package com.common;

import java.math.BigDecimal;
import java.util.Scanner;

public class DemoDecimal {

    public void MathMethod(){
        System.out.println("圆周率 π ="+ Math.PI);
        System.out.println("自然常数 E = "+ Math.E);
        System.out.println("----------------------- 分割线 -----------------------");

        System.out.println("-19 绝对值："+ Math.abs(-19));
        System.out.println("12.368 向上取整："+ Math.ceil(12.368));
        System.out.println("12.348 向下取整："+ Math.floor(12.348));
        System.out.println("----------------------- 分割线 -----------------------");

        System.out.println("（5, 8）最大值：" + Math.max(5, 8));
        System.out.println("（5, 8, 7）最大值：" + Math.max(5, Math.max(8, 7)));
        System.out.println("（5, 8）最小值：" + Math.min(5, 8));
        System.out.println("2的8次幂：" + Math.pow(2, 8));
        System.out.println("正平方根：" + Math.sqrt(5));
        System.out.println("----------------------- 分割线 -----------------------");

        System.out.println("随机数：" + Math.random()); // [0.0,1.0)
        System.out.println("0-9区间内的随机数：" + ((int) (Math.random()*9)));
        System.out.println("四舍五入：" + Math.round(12.356f));
        System.out.println("四舍五入：" + Math.round(12.356d));
        System.out.println("----------------------- 分割线 -----------------------");

    }

    public static void main(String[] args) {
        DemoDecimal demoDecimal = new DemoDecimal();
        demoDecimal.MathMethod();
    }
}
DemoDecimal.java

 

执行结果

 

 

System类

 1. 静态成员变量

package com.common;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class DemoSys {

    public void sysMethod(){
        // 标准输出流
        System.out.println("标准输出流");

        // 标准输入流
        System.out.println("请输入字符，并按Entry结束：");
        int s;
        // read() 方法是 InputStream 类拥有的方法
//        try {
//            s = System.in.read();
//            while (s != '\r'){  // 判断是否为回车
//                System.out.print((char) s);
//                s = System.in.read(); // 读入一个字符
//            }
//        }catch (IOException io){
//            System.out.println("异常："+ io);
//        }finally {
//            System.err.println();
//        }

        // 把 System.in 声明为 InputStreamReader 类型的实例
        try {
           InputStreamReader in = new InputStreamReader(System.in, "GB2312");
           s = in.read();
           while(s != '\r') {
               System.out.print((char) s);
               s = in.read();
           }
        }catch (Exception e) {
           System.out.println(e);
        }
    }

    public static void main(String[] args) {
        DemoSys demoSys = new DemoSys();
        demoSys.sysMethod();

    }
}
DemoSys.java

 

执行结果

 

2.常用方法

getRuntime() 返回当前应用程序的运行环境对象。
exec(String command) 根据指定的路径执行对应的可执行文件。
freeMemory() 返回 Java 虚拟机中的空闲内存量。。 以字节为单位
maxMemory() 返回 Java 虚拟机试图使用的最大内存量。
totalMemory() 返回 Java 虚拟机中的内存总量

 

 

 

 

 参考地址：https://blog.csdn.net/m0_58761900/article/details/125014074

 

字符串格式化说明符

说明符适用于输出
%a 浮点数 (除了BigDecimal) 浮点数的十六进制输出
%b 任何类型 如果为非空则为“true”，为空则为“false”
%c 字符 Unicode字符
%d 证书(包括byte, short, int, long, bigint) 十进制整数
%e 浮点数 科学计数的十进制数
%f 浮点数 十进制数
%g 浮点数 十进制数，根据值和精度可能以科学计数法显示
%h 任何类型 通过hashCode()方法输出的16进制数
%n 无 平台相关的换行符
%o 整数(包括byte, short, int, long, bigint) 八进制数
%s 任何类型 字符串
%t 日期/时间 (包含long, Calendar, Date 和TemporalAccessor) %t是日期/时间转换的前缀。后面还需要跟其他的标识，请参考下面的日期/时间转换。
%x 整数(包含byte, short, int, long, bigint) 十六进制字符串
posted @ 2023-05-09 14:16  Phoenixy  阅读(109)  评论(0)  编辑  收藏  举报