Java通识基础22：核心类（那些常用的工具）

Java通识基础22：核心类（那些常用的工具）

Java的入口方法

public static void main(String[] args)

public是访问权限、修饰符——该方法由JVM负责调用，需要将该方法暴露出来

static——该方法由类直接调用

String[] args——用于接收用户输入的参数

Java 类名参数1 参数2 参数3...如果某个参数含有空格，该参数需要双引号

`Scanner`类

获取很多地方的输入，键盘输入仅仅是其中一个

用于获取的语句：

对象.nextLine()获取下一行

对象.nextInt()获取下一个整数

对象.nextFloat()获取下一个浮点数

import java.util.Scanner;
public class ArgsTest {
    public static void main(String[] args) throws Exception{
        System.out.println(args.length);
        for (String s:args){
            System.out.println(s);
        }
        Scanner a=new Scanner(System.in);
        //读取文件输入
        while (a.hasNextLine()){
            String line=a.nextLine();
            System.out.println(line);
        }//在此可以一直无限行的输入下去
    }
}

`System`类的详细介绍

Java的程序会在JVM的环境中运行

System类代表操作系统——获取操作系统相关信息
Radom类代表JVM的虚拟机——获取JVM相关信息

`System`类变量

in代表键盘

out代表屏幕
System的方法都是类方法，可以直接调用
学会查找、阅读文档！！！！
举例：
获取时间方法System.currentTimeMillis()

public class Demo1 {
  public static void main(String[] args) {
      //从1970年0时0分0秒到现在过了多少毫秒
      System.out.println(System.currentTimeMillis());
  }
}

退出系统方法System.exit(返回值);

public class Demo2 {
    public static void main(String[] args) {
        //从1970年0时0分0秒到现在过了多少毫秒
        System.exit(1);
        System.out.println("321312");
    }
}
/*
进程已结束,退出代码1
*/

`Runtime`类

Runtime只需要一个实例，应该采用单例模式

举例：

public class Demo1 {
    public static void main(String[] args) {
        Runtime rt=Runtime.getRuntime();//返回与当前Java应用程序关联的运行时的对象
        //单例模式不能创建对象，直接通过类调用方法
        System.out.println("JVM的最大堆内存"+rt.maxMemory());
        System.out.println("JVM的空闲堆内存"+rt.freeMemory());
        System.out.println("JVM总共使用的堆内存"+rt.totalMemory());
    }
}

public class Demo1 {
    public static void main(String[] args) {
       rt.exec("C:\\Program Files\\Mozilla Firefox\\firefox.exe");
       //运行指定路径的程序
    }
}

`Object`类——一切的父类

通常有3个需要被重写的方法——

toString()返回该对象描述的字符串
equals(Object.obj)根据业务条例，提供判断两个对象相等的标准
hashCode()

`Objects`工具

Arrays：操作数组的工具类

Objects：操作对象的工具类，该类的工具方法可以避免NullPointerException

import java.util.Objects;
public class Demo1 {
    public static void main(String[] args){
        Dad a=null;
        //System.out.println(a.hashCode());
        //会出现空指针异常
        System.out.println(Objects.hashCode(a));
        //解决方式
        //System.out.println(a.equals(new Dad()));
        //会出现空指针异常
        System.out.println(Objects.equals(a,new Dad()));
    }
}
class Dad{
}

字符串类

Java的字符串类型

String
StringBuffer
StringBuilder
StringJoiner

String代表了字符内容不能更改的字符串

说明例子：

public class Demo1 {
    public static void main(String[] args) {
        String a="wydsb";//首先创建对象a，"wydsb"进入缓存池
        a=a+"dsb";//首先有一个字符串的直接量"wydsb"，"dsb"进入缓存池
        //还有一个String代表了拼接运算的结果，a指向新的变量
        //此处有两个对象，一个是固有字符串，另一个是拼接结果
        System.out.println(a);
    }
}

StringBuffer StringBuilder代表了字符内容可变的字符串，可以进行对字符的添加、修改和删除

StringBuffer是线程安全的、性能较差

StringBuilder是线程不安全的、性能较好

(对于初学者其实差别不大)

`StringBuilder`举例：

例1

public class Demo1 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("wyd");
        //此处创建了两个对象——一个是直接量"wyd"，另一个是创建的对象sb
        sb.append(" is a sb");//存在直接量" is a sb"，但没有新增多余的对象
        System.out.println(sb);//此处输出的sb对象本身的内容发生了改变
    }
}
/*
    wyd is a sb
*/

此时该字符串本质上被修改了，而不是通过创建新对象表面上的“修改”

例2：

public class Main {
    public static void main(String[] args) {
        String s="";
        for (int i=0;i<10;i++){
            s+=i+",";
        }//传统的for循环实现字符添加
        System.out.println(s);
        StringBuilder a=new StringBuilder();
        for (int i=0;i<10;i++){
            a.append(i);
            a.append(",");
        }//StringBuilder方法可以预分配缓冲区减小负担，无需创建那么多新的对象
        System.out.println(a);
    }
}
/*
    0,1,2,3,4,5,6,7,8,9,
    0,1,2,3,4,5,6,7,8,9,
*/

例3（`StringBuilder`实现链式法则）

public class Main1 {
    public static void main(String[] args) {
        var sb = new StringBuilder(1024);
        sb.append("Mr ")
                .append("Bob")
                .append("!")
                .insert(0,"Hello,");
        System.out.println(sb.toString());
    }
}
/*
    Hello,Mr Bob!
*/

额外补充`StringJoiner`

import java.util.StringJoiner;
public class Main {
    public static void main(String[] args) {
        String[] names={"A","B","C","D"};
        var sj=new StringJoiner(",,");
        for(String name:names){
            sj.add(name);
        }
        String[] cities={"NJ","BJ","CZ","DLSD"};
        var s=String.join("和",cities);
        System.out.println(s);
        System.out.println(sj);
    }
}
/*
NJ和BJ和CZ和DLSD
A,,B,,C,,D
*/

`join`info

public class StringJoin {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var s = String.join(", ", names);
        System.out.println(s);
    }
}
/*
    Bob, Alice, Grace
*/

字符串类中一些其他方法的举例：

public class Main {
    public static void main(String[] args) {
        String a = "Hello";
        String b = "Hello";
        b = b.toLowerCase();//全部字符转化为小写
        System.out.println(b);
        b=b.toUpperCase();
        System.out.println(b);
        a=a.toUpperCase();//全部字符转化为大写
        System.out.println(a==b);
        System.out.println(a.equals(b));
        //由上两行可以看出不能用==来比较字符串
        System.out.println(a.indexOf("H"));//搜索字符在固定字符串的位置
        System.out.println(a.lastIndexOf("L"));//搜索字符在字符串最后出现的位置
        System.out.println(a.startsWith("H"));
        System.out.println(a.endsWith("O"));//判断开头结尾的字符是否为此字符
        System.out.println("a\n".isBlank());
        System.out.println("\n".isBlank());//判断空白字符
        System.out.println(" ".isEmpty());
        System.out.println("".isEmpty());//判断字符串长度是否为0
        b=b.replace("L","m");
        System.out.println(b);//将该字符串的所有L字符替换为m
        String s = "Hi %s, your score is %d!";
        System.out.println(s.formatted("Alice", 80));
        System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5));
        //替换占位符
        String.valueOf(123); // "123"
        String.valueOf(45.67); // "45.67"
        String.valueOf(true); // "true"
        //将别的值转化为字符串
        int m1=Integer.parseInt("fd",16);//将该字符串转化为一个十六进制数
        char[] cs="dwadaw".toCharArray();
        System.out.println(cs[3]);//字符串转化为字符数组
    }
}
/*
hello
HELLO
false
true
0
3
true
true
false
true
false
true
HEmmO
Hi Alice, your score is 80!
Hi Bob, your score is 59.50!
d
*/

（在此就不全部列举了，你已经是一个半成熟的开发者了，应该学会查文档！）

`Math`类

本质上是用于数学计算的类

该类下的方法全部都是有static，可有类本身直接调用

`Random`和`ThreadLocalRandom`类

Random是随机数生成器

ThreadLocalRandom是当前线程的随机数生成器

SecureRadom类的随机性最强，牵扯到量子领域（总之就是很牛逼，如果牵扯到加密建议用它）

例1（调用`Random`类）

import java.util.Random;
import java.util.stream.DoubleStream;
import java.util.concurrent.ThreadLocalRandom;
public class RandomDemo1 {
    public static void main(String[] args) {
        Random a=new Random();
        System.out.println( a.nextDouble());
        ThreadLocalRandom b=ThreadLocalRandom.current();
        //没有构造器，获取实例
        int c=b.nextInt(2,100);
        System.out.println(c);
    }
}
/*
0.8464796112618053(生成一个随机小数)
82(生成一个2-100的随机整数)
*/

例2（直接使用`random`方法）

public class RadomInfo {
    public static void main(String[] args) {
        System.out.println(Math.random());
        double x=Math.random();
        double min=10;
        double max=20;
        Double y = x * (max - min) + min; // y的范围是[10,20)
        long n=y.longValue();
        System.out.println(y);
        System.out.println(n);
    }
}
/*
0.9571031550660398(0-1的随机小数)
17.844978432064373(10到20的随机小数)
17(10到20的随机整数)
*/

例3（`SecurityRadom`的调用）

import java.security.SecureRandom;
import java.util.Random;
public class Demo2 {
    public static void main(String[] args) {
        Random m=new Random();
        System.out.println(m.nextDouble(10));//生成10以内的随机double值
        System.out.println(m.nextInt(5000));//生成5000以内的随机int值
        SecureRandom n=new SecureRandom();
        System.out.println(n.nextDouble(10));
        System.out.println(n.nextInt(5000));
        //功能同上，后者的随机性更强
    }
}
/*
5.359272833227183
3420
0.8603400442734033
617
(生成的随机数)
*/

`BigDecimal`类

对于float、double两个类型而言，它们保存的小时可能不精确——所有语言都这样

——因此如果要比较浮点数是否相等，通常计算他们的差值，如果他们的差足够小，判定相等！

如果需要精确保存小时的值，那么需要使用BigDecimal

基本运算举例

import java.math.BigDecimal;
public class Demo1 {
    public static void main(String[] args) {
        BigDecimal bd=new BigDecimal("0.4222");
        BigDecimal bd1=new BigDecimal("0.2111");
        BigDecimal add=bd.add(bd1);//加法
        System.out.println(add);
        BigDecimal mui=bd.multiply(bd1);//乘法
        System.out.println(mui);
        BigDecimal dev=bd.divide(bd1);//除法
        System.out.println(dev);
    }
}
/*
    0.6333
    0.08912642
    2
*/

`BigDecimal`应对任意精度和大小的浮点数

import java.math.BigDecimal;
import java.math.RoundingMode;
public class Main1 {
    public static void main(String[] args) {
        BigDecimal a=new BigDecimal("2.321313213");
        System.out.println(a.doubleValue());
        System.out.println(a.scale());//显示小数位数
        a=a.setScale(4, RoundingMode.HALF_UP);//保留4位并且四舍五入
        System.out.println(a.doubleValue());
        a=a.setScale(3,RoundingMode.DOWN);
        System.out.println(a.doubleValue());//保留3位后面直接截断
        BigDecimal b=new BigDecimal("2.321");
        System.out.println(a.compareTo(b));//返回正数代表小于，负数代表大于，、0代表等于
    }
}
/*
    2.321313213
    9
    2.3213
    2.321
    0
*/

`Date`类

代表当前日期时间

Dtae()：获取当前时间

Date(long date)：负责将System.currentTimeMillis()返回的long时间装换成Date对象

GetTime()：返回long

举例：

import java.util.Date;
public class Demo1 {
    public static void main(String[] args) {
        long time =System.currentTimeMillis();
        Date a=new Date(time);
        System.out.println(a);
        long time1=a.getTime();
        System.out.println(time1);
    }
}

`Canlendar`类

目的是取代Date类

采用了模板设计，所以Canlendar类是一个抽象类，实际使用的通常是子类

设计初衷希望世界上不同的日历都能通过它来派生子类

import java.util.Calendar;
public class demo1 {
    public static void main(String[] args) {
        Calendar a1=Calendar.getInstance();
        System.out.println(a1);
    }
}
//java.util.GregorianCalendar[time=1648525709222,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=2,WEEK_OF_YEAR=14,WEEK_OF_MONTH=5,DAY_OF_MONTH=29,DAY_OF_YEAR=88,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=5,AM_PM=0,HOUR=11,HOUR_OF_DAY=11,MINUTE=48,SECOND=29,MILLISECOND=222,ZONE_OFFSET=28800000,DST_OFFSET=0]

返回的本质上还是长整型的时间，目前用的不多，具体查文档

`JavaBean`

getter\setter定义属性的工具

public class Person {
    private String name;
    private int age;
    public void setName(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

`Record`

public class Main {
    public static void main(String[] args) {
        Point p=new Point(233,666);
        System.out.println(p.x());
        System.out.println(p.y());
    }
}
record Point(int x,int y){
//定义更简化的final类
}
//该record类等同于
public final class Point {
    private final int x;
    private final int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int x() {
        return this.x;
    }
    public int y() {
        return this.y;
    }
}
/*
233
666
*/

`Biglnteger`应对巨大的整数

import java.math.BigInteger;
public class Main {
    public static void main(String[] args) {
        BigInteger a=new BigInteger("236075690543243213112312312321312321321231212321213213123124234");
        System.out.println(a.longValueExact());//会直接报错ArithmeticException
        System.out.println(a.longValue());//会出现不准确的异常值
    }
}

Java 基础学习

Java通识基础22（Java的核心类）

Java通识基础22：核心类（那些常用的工具）

Java的入口方法

`Scanner`类

`System`类的详细介绍

`System`类变量

`Runtime`类

`Object`类——一切的父类

`Objects`工具

字符串类

说明例子：

`StringBuilder`举例：

例1

例2：

例3（`StringBuilder`实现链式法则）

额外补充`StringJoiner`

`join`info

字符串类中一些其他方法的举例：

`Math`类

`Random`和`ThreadLocalRandom`类

例1（调用`Random`类）

例2（直接使用`random`方法）

例3（`SecurityRadom`的调用）

`BigDecimal`类

基本运算举例

`BigDecimal`应对任意精度和大小的浮点数

`Date`类

举例：

`Canlendar`类

`JavaBean`

`Record`

`Biglnteger`应对巨大的整数

Java通识基础22（Java的核心类）

Java通识基础22：核心类（那些常用的工具）

Java的入口方法

Scanner类

System类的详细介绍

System类变量

Runtime类

Object类——一切的父类

Objects工具

字符串类

说明例子：

StringBuilder举例：

例1

例2：

例3（StringBuilder实现链式法则）

额外补充StringJoiner

joininfo

字符串类中一些其他方法的举例：

Math类

Random和ThreadLocalRandom类

例1（调用Random类）

例2（直接使用random方法）

例3（SecurityRadom的调用）

BigDecimal类

基本运算举例

BigDecimal应对任意精度和大小的浮点数

Date类

举例：

Canlendar类

JavaBean

Record

Biglnteger应对巨大的整数

`Scanner`类

`System`类的详细介绍

`System`类变量

`Runtime`类

`Object`类——一切的父类

`Objects`工具

`StringBuilder`举例：

例3（`StringBuilder`实现链式法则）

额外补充`StringJoiner`

`join`info

`Math`类

`Random`和`ThreadLocalRandom`类

例1（调用`Random`类）

例2（直接使用`random`方法）

例3（`SecurityRadom`的调用）

`BigDecimal`类

`BigDecimal`应对任意精度和大小的浮点数

`Date`类

`Canlendar`类

`JavaBean`

`Record`

`Biglnteger`应对巨大的整数