JavaSE第五章.常用类

已于 2022-06-08 00:39:11 修改
阅读量442 收藏 1
点赞数 1
分类专栏： java 文章标签： java
于 2021-07-24 03:06:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52163230/article/details/119050698
版权

文章目录

API

API(Application Programming Interface)应用程序编程接口是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明

基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类

  • 八种基本数据类型的包装类
    byte ——Byte
    short ——Short
    int ——Integer
    long-----Long
    float-----Float
    double----Double
    char----Character
    boolean—Boolean
  • 1字节(byte、boolean)、 2字节(short、char)、4字节(int、float)、8字节(long、double)

类型转换

基本数据类型---->字符串

  1. 基本数据类型对象包装类中的方法 toString(基本类型);
  2. String类中的方法： valueOf(基本类型)
  3. 基本类型数据 +“ ”；
Integer.toString(10);	 //将整数转为 String
Integer.valueOf(10);
String s =10+"11";

字符串---->基本数据类型

基本类型包装类 . parseInt（“字符串”）

int i = Integer.parseInt("4564987");	//将String类型转为int
System.out.println(Integer.parseInt("23") + 1);

基本类型的对象---->基本数据类型数值

integer对象中的 intValue()方法

Integer w =new Integer(15);
int ww = w.intValue();	//取出对象中包含的int值

基本类型---->引用类型

自动装箱：valueOf ()

自动拆箱：intValue ()

int x = 10;
/*
  基本类型转引用类型
  Integer  n  =  new Integer(x);
  Integer  n1  =  Integer.valueOf(x);
*/

Integer n = x;  //自动装箱  默认调用valueOf()方法 创建一个Integer对象

//n.intValue()
int y = n;//自动拆箱  将引用类型转为基本类型  默认调用intValue()方法 取出包含的int值

进制转换

使用Integer类的静态方法

//将十进制转换成
Integer.toBinaryString(16);  //二进制
Integer.toOctalString(16);   //八进制
Integer.toHexString(16);     //十六进制

Integer.toString(15,3);//将15转换成3进制

常用方法

1、包含了int类型的信息：@Native public static final int 修饰的常量

System.out.println(Integer.MAX_VALUE);//最大的int型数：2的31次方-1  2147483647
System.out.println(Integer.MIN_VALUE);//最小的int型数：2的31次方
System.out.println(Integer.SIZE);//32  位数
System.out.println(Integer.BYTES);//4  字节数

2、静态方法

int max = Integer.max(10, 5);
//选出两个中大的
System.out.println(max);//10

3、成员方法

  1. compateTo()
  2. equals()
Integer n =  new Integer("10");
Integer m =  new Integer("12");
System.out.println(m+10);
System.out.println(m.compareTo(n));//比较大小	返回-1/0/1
System.out.println(n.equals(m));//比较是否相等

== & equals

==比较基本类型的时候比较的是他们的值，比较引用的时候表的是他们在内存中的地址

基本数据类型与基本数据类型封装类使用==比较：会将基本数据类型封装类自动拆箱成基本数据类型后比较

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);//true

equals()比较的是对象的值

  • 基本类型自动装箱( valueOf() )时，如果数值在-128到127之间，会从缓存中取出一个对象返回，如果多个值相同返回的是同一个对象，不在这个范围之间会创建新的对象返回

    Long n = -128L;
Long m = -128L;
System.out.println(n==m);//nm都用同一对象,地址相同,返回true
	
Integer a = 128;
Integer b = 128;
System.out.println(a==b);//创建新的对象,地址不同,返回false

  • 如果比较new出的对象，无论数值，地址都不相同

    Integer m = new Integer(127);
Integer n = new Integer(127);
System.out.println(m==n);//false
System.out.println(m.equals(n));//true
System.out.println(128==128);//true

Object类

java.lang包下的核心类，是所有类的父类，何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类；所有对象（包括数组）都实现这个类的方法。

hasCode()

本地方法，返回的对象地址值

String等封装类中对此方法进行了重写。方法调用得到一个计算公式得到的 int值

equals()

对象内容比较

  • 因为此时直接调用equals()方法默认进行比较的是两个对象的地址
  • 在源码中，传递来的Object对象和当前对象比较地址值，返回布尔值
public class Person extends Object{

     private String name;
     private int age;

     Person(String name,int age){
         this.name = name;
         this.age = age;
     }

	/*
     Object类中equals
         public boolean equals(Object obj) {
            return (this == obj);
         }
    */
     public static void main(String[] args) {
         Person p1 = new Person("张三",18);
         Person p2 = new Person("张三",18);
         System.out.println(p1.equals(p2)); //false 比较地址

         String s = new String("abc");
         String s1 = new String("abc");
         System.out.println(s==s1);//false
         System.out.println(s.equals(s1));//true	String类重写了equals()  比较的是对象中包含的内容是否相等

         Integer x = 128; //new Integer(128);
         Integer y = 128; //new Integer(128);
         System.out.println(x==y);//false
         System.out.println(x.equals(y));//true
         //几乎API中所有类都重写Object类中equals(),比较的是对象中包含的内容是否相等
     }
}

重写比较规则equals()，判断对象的值是否相等

@Override
public boolean equals(Object obj) {
    if (obj instanceof Person) {
        Person person = (Person) obj;
        return this.age == person.age && this.name == person.name;
    } else {
        System.out.println("类型错误");
        return false;
    }
}
System.out.println(p1.equals(p2)); //false 比较值

为什么重写equals方法必须重写hashcode方法
判断先比较hashcode()再比较equals()，要是只重写equals()就可能导致equals()比较为True但hashcode()值不同

toString()

取得对象信息，返回该对象的字符串表示

  • 使用System.out.println§;输出对象,此时会默认调用对象中的toString()
    当类中没有toString()时,默认调用父类toString()
  • Object类中toString()输出的是对象地址
  • 一般情况下可以重写Object类中toString()
//没有重写toString()
Person p = new Person("张三",18);
System.out.println(p);
-----------------------------------------------
com.ffyc.javaapi.day2.objectdemo.Person@1b6d3586

//在Person类中重写toSting()
@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
----------------------------------------
Person{name='张三', age=18}

getClass()

获取一个对象其类的Class类

Object.class：静态方法，获取Object类的Class类

finalize()

对象回收的时候默认调用的方法。见 JVM

@Override
protected void finalize() throws Throwable {
    System.out.println("对象已被回收");
}
public static void main(String[] args){
    new Person("张三",18);
    System.gc();
}

wait() & notify()

wait()；wait(long)；wait(long,int)；notify()；notifyAll()

这几个函数体现的是Java的多线程机制

  • 在使用的时候要求在synchronize语句中使用
  • wait()用于让当前线程失去操作权限，当前线程进入等待序列
  • notify()用于随机通知一个持有对象的锁的线程获取操作权限
  • notifyAll()用于通知所有持有对象的锁的线程获取操作权限
  • wait(long) 和wait(long,int)用于设定下一次获取锁的距离当前释放锁的时间间隔

Arrays类

位于java.util包内，用于操作数组工具类，里面定义了常见操作数组的静态方法

toString()

重写又重载了Object类中的toString方法

public class ArrayToString {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,5};
        System.out.println(a);
        System.out.println(Arrays.toString(a));
    }
}

-------------------------------------------------
[I@1b6d3586
[1, 2, 3, 4, 5]

equals()

比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身

int []a = {1,2,3,4};
int []b = {1,2,3,4};
System.out.println(a==b); //false
System.out.println(a.equals(b));//Object中未重写的equals()  false
System.out.println(Arrays.equals(a,b));// Arrays类重写重载过后的equals() true
/*  重写后的equals源码
public static boolean equals(int[] a, int[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }
*/

sort()

对数组排序，可以指定区间：Arrays.sort(array, start, end)

对对象数组排序：指定排序规则：Arrays.sort(T[] array, comparator<? super T> c)

基本类型排序

int[]a = {3,7,6,9,4,1,6,9,41};
//Arrays.sort(a);
Arrays.sort(a,0,5);  //指定区间排序
System.out.println(Arrays.toString(a));
//输出[3, 4, 6, 7, 9, 1, 6, 9, 41]
-------------------------------------------------
//按大小写字母顺序排序，不区分大小写
String[] strArray = new String[] { “z”, “a”, “C” };
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
//输出： [a, C, z]
---------------------------------------------------------
//逆向排序
Arrays.sort(strArray, Collections.reverseOrder());
//输出：[z, a, C]

字符串排序

按照字典中顺序排列

String[]a = {"a","3","樊","景"};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
--------------------------------------------------
[3, a, 景, 樊]

Object类排序

先继承compare接口并定义泛型(要排序的类),在重写compare()---->(定义排序规则)

compareTo()方法会在sort()的底层中调用

public class Student implements Comparable<Student> {
    private int num;
    private String name;

    public Student(int num, String name) {
        this.num = num;
        this.name = name;
    }

	//用来做比较, 提供的一个自定义排序规则的方法
	//compareTo()方法会在sort()的底层中调用
    @Override
    public int compareTo(Student o) {
        return this.num - o.num;  //按num
        //return this.name.compareTo(o.name); //按name
    }

    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}


public class ArraySortObject {
    public static void main(String[] args) {
        Student[] students = new Student[5];  //创建Student[]存放Student类

        Student student1 = new Student(101, "张三1");
        Student student2 = new Student(102, "张三2");
        Student student3 = new Student(103, "张三3");
        Student student4 = new Student(104, "张三4");
        Student student5 = new Student(105, "张三5");

        students[0] = student3;
        students[1] = student1;
        students[2] = student4;
        students[3] = student2;
        students[4] = student5;
        System.out.println(Arrays.toString(students));

        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

-------------------------------------------------------
    [Student{num=103, name='张三3'}, Student{num=101, name='张三1'}, Student{num=104, name='张三4'}, Student{num=102, name='张三2'}, Student{num=105, name='张三5'}]
[Student{num=101, name='张三1'}, Student{num=102, name='张三2'}, Student{num=103, name='张三3'}, Student{num=104, name='张三4'}, Student{num=105, name='张三5'}]

或者使用Lambda表达式

Arrays.sort(students,((o1, o2) -> {
    return o1.getNum() - o2.getNum();
}));

binarySearch()

二分查找法找指定元素的索引

数组一定是排好序的，否则会出错。找到元素，只会返回最后一个位置

//底层排序源码
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

找不到就返回这个数理应出现在整个数组的位置加上负号

	int[] arr = {10,20,30,40,50};

	System.out.println(Arrays.binarySearch(arr, 30));
    //输出：2 （下标索引值从0开始）

	System.out.println(Arrays.binarySearch(arr, 36));
	//输出：-4 （找不到元素，返回如果存在应该所在的位置取负，从-1开始数，如题，返回-4）

	System.out.println(Arrays.binarySearch(arr, 0,3,30));
	//输出：2 （从0到3位（不包括）找30，找到了，在第2位，返回2）

    System.out.println(Arrays.binarySearch(arr, 0,3,40));
    //输出：-4 （从0到3位（不包括）找40，找不到，从-1开始数，返回-4）

copyOf()

截取/扩容

底层调用System.arraycopy 本地方法

int[] arr = {10,20,30,40,50};
int[] arr1 = Arrays.copyOf(arr, 3);
System.out.print(Arrays.toString(arr1));
//输出：[10, 20, 30] （截取arr数组的3个元素赋值给新数组arr1）

//复制数组以扩容		
int[] a = {1,2,3,4,5};
//返回一个指定长度的新数组,并将原数组中的内容复制到新数组中
int [] b = Arrays.copyOf(a, 10);
System.out.println(Arrays.toString(b));
//输出：[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

//copyOfRange()
int[] a = {1,2,3,4,5};
//截取指定位置元素       //第一位从0开始，截取到第三位，不包括第三位
int [] b = Arrays.copyOfRange(a,0,2);
System.out.println(Arrays.toString(b));
//输出:[1, 2]

String类

位于java.lang包下

所有字符串都是String类的实例(对象)字符串值不能改变(一旦给定字符串的值，值就不能改变) 因为底层用到一个final修饰的char 数组

private final char value[]; 底层是单个字符存储 char a=97 b=98 c=99

两种创建形式

  1. String s = " "：首先会在字符串常量池中查找，如果没有，就在常量池中创建；如果常量池已经存在，就不需要创建，直接返回地址即可
  2. String s = new String(" ")：都会在堆中创建一个对象
String s1 = "abc";//首先会在字符串常量池中查找,如果没有,就在常量池中创建
String s2 = "abc";//如果常量池已经存在,就不需要创建,直接返回地址即可
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true

String s3 = new String("abc");
String s4 = new String("abc"); //都会在堆中创建一个对象
System.out.println(s3==s4);//false
System.out.println(s3.equals(s4));//true

为什么设计成不可变的

  1. 实现字符串常量池：字符串常量池要求存入的数据不可改变
  2. 多线程安全：防止多线程并发修改
  3. 安全：网络、数据库连接都是字符串作为参数，如果可以改变容易被攻击
  4. 加快字符串处理速度：由于String是不可变的，保证了hashcode的唯一性，于是在创建对象时其hashcode就可以放心的缓存了，不需要重新计算。这也就是Map喜欢将String作为Key的原因，处理速度要快过其它的键对象。所以HashMap中的键往往都使用String。

"+"连接符

底层会创建一个StringBuilder，使用append()操作实现的，然后用toString方法把对象转成字符串

        int i = 10;
        String s = "abc";
        System.out.println(s + i);
        /*
          byte byte0 = 10;      
          String s = "abc";      
          System.out.println((new StringBuilder()).append(s).append(byte0).toString());
          每次连接一个字符串都会new一个StringBuilder,所以当进行大量字符串连接时,自己先new一个
          StringBuilder sb = new StringBuilder("abc");
          sb.append("");
        */
  • 直接相加：“樊”+“景”+“泽"会在编译期间转成"樊景泽”
  • 使用引用间接相加：s1+s2+s3 编译期间无法确定值，降低效率

字符串常量池

String s = " " 创建方式会先从字符串常量池中找，如果没有再创建并放入字符串常量池

因为字符串对象频繁创建和回收，提升性能+减少开销

JDK6：永久代（方法区），存储的是对象
JDK7：堆，存储的是引用
JDK8：方法区被元空间取代

存在于堆区，底层是StringTable，StringTable继承自HashTable，长度为1009

intern()
直接使用双引号声明出来的String对象会直接存储在字符串常量池中，如果不是用双引号声明的String对象，可以使用String提供的intern方法。intern 方法是一个native方法，intern方法会从字符串常量池中查询当前字符串是否存在，如果存在，就直接返回当前字符串；如果不存在就会将当前字符串放入常量池中，之后再返回

创建了几个对象？
string s = “aaa”：先在常量池找，没有就将’‘aaa’'放入常量池中，然后将地址赋给s。
string s = new String(“aaa”)：在堆内存出开辟一块空间，然后在看常量池中有无

常用方法

判断
  • equals(Object obj)：判断两个字符串的内容是否相等
  • equalsIgnoreCase(String str)：判断内容忽略大小写
  • contains(String str)：是否包含指定字符串
  • isEmpty() boolean：是否为空
  • startsWith(String prefix)：是否以指定字符串开头
  • endsWith(String suffix)：结尾
获取
  • int length()：返回字符串长度
  • char charAt(int index)：返回指定索引的字符
  • int indexOf(String str)：获取指定字符串首次出现的位置 从头开始向后找
  • int indexOf(String str,int fromIndex)：获取指定字符串首次出现的位置，从指定索引开始
  • int lastIndexOf(String str)：最后一次出现的位置
  • String substring(int start)：从指定位置截取到结束
  • String substring(int start,int end)：指定区间，不包括结束的
转换
  • String toLowerCase()：转小写
  • String toUpperCase()：转大写
  • String concat(String str)：两个字符串拼接 并返回新的字符串对象
  • Stirng[] split " ," )：用指定符号 来分割字符串为数组
替换 replace()
  • String replace(char/String old,char new)：替换所有的该字符串为什么等同于replaceAll()
  • replaceAll(String regex, String replacement)：替换所有的
  • replaceFirst(String regex, String replacement)：只替换第一个
  • 去除字符串两端空格 String trim()
String str = "  abCd ECdfg ";
String str1 = str.replace("Cd","ccc");  //替换所有
System.out.println(str1);
System.out.println(str.replaceFirst("Cd","ccc"));  //只替换第一个

String str2 = str.trim();  //去除两端空格
System.out.println(str2);
--------------------------------------------------
abccc Ecccfg 
abccc ECdfg 
abCd ECdfg
分割 split()
String str = " a3b:c66de";
String[] s1 = str.split(":");  //按:拆分成一个String[]
System.out.println(Arrays.toString(s1));
String[] s2 = str.split("\\d"); //按数字拆分
System.out.println(Arrays.toString(s2));
---------------------------------------------------
[ a3b, c66de]
[ a, b:c, , de]
编码解码 getBytes()
System.out.println('樊'+0);
String s = "樊景泽";
byte[] b = s.getBytes();  //编码  把字符串转化为编码数组  utf-8
System.out.println(Arrays.toString(b));

String s1 = new String(b);
System.out.println(s1);  //解码

byte[] b1 =s.getBytes("GBK");  //选择GBK编码,抛UnsupportedEncodingException异常
System.out.println(Arrays.toString(b1));
String s2 = new String(b1,0,3,"GBK");  //区域解码,从0到3,不包含3
System.out.println(s2);
------------------------------------------------
27146
[-26, -88, -118, -26, -103, -81, -26, -77, -67]
樊景泽
[-73, -82, -66, -80, -44, -13]
樊�
转数组toCharArray()

把字符串分割成字符,转换成char数组，可以进行数组操作

  • 字符串—>数组：toCahrArray()
  • 数组—>字符串：1、String的构造方法；2、String的valueOf()
String s = "bdac";
char[] chars = s.toCharArray();     //把字符串分割,转换成一个char[]
Arrays.sort(chars);   //排序char[]
System.out.println(Arrays.toString(chars));

//把char[]转换成字符串
String s1 = new String(chars);  //String的构造方法
System.out.println(s1);
String s2 = String.valueOf(chars); //String的valueOf()
System.out.println(chars);

char[] c = {'a','b','c'};
System.out.println(Arrays.toString(c));
System.out.println(c);   //输出char[]会自动转化成字符串的形式
int[] a={1,2,3};
System.out.println(a);  //int[]则为地址
----------------------------------------------------------------
[a, b, c, d]
abcd
abcd
[a, b, c]
abc
[I@5caf905d

正则表达式

正则表达式是由一些具有特殊含义的字符组成的字符串，多用于查找、替换符合规则的字符串。在表单验证、Url映射等处都会经常用到

Scanner scanner = new Scanner(System.in);
String mail = scanner.next();
boolean res = mail.matches("\\w{6,10}@\\w{2,5}\\.(com|com\\.cn)");
System.out.println(res);

元字符

代码说明
.除换行符以外的任意字符
\w字母或数字或下划线或汉字
\s任意的空白符
\d数字
\b单词的开始或结束
^字符串的开始（在集合字符里[^a]表示非（不匹配）的意思
$字符串的结束

反义字符

代码/语法说明
\W任意不是字母，数字，下划线，汉字的字符
\S任意不是空白符的字符
\D任意非数字的字符
\B不是单词开头或结束的位置
[^x]除了x以外的任意字符
[^aeiou]除了aeiou这几个字母以外的任意字符

限定字符

代码/语法说明
*重复零次或更多次
+重复一次或更多次
?重复零次或一次
{n}重复n次
{n,}重复n次或更多次
{n,m}重复n到m次

懒惰限定符

代码/语法说明
*?重复任意次，但尽可能少重复
+?重复1次或更多次，但尽可能少重复
??重复0次或1次，但尽可能少重复
{n,m}?重复n到m次，但尽可能少重复
{n,}?重复n次以上，但尽可能少重复

转义字符

        /*
            $ ---> \$
            ( ---> \(
            ) ---> \)
            * ---> \*
            + ---> \+
            . ---> \.
            [ ---> \[
            ] ---> \]
            ? ---> \?
            \ ---> \\
            / ---> \/
            ^ ---> \^
            { ---> \{
            } ---> \}
         */

StringBuilder&StringBuffer

StringStringBufferStringBuilder
值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且浪费大量优先的内存空间值可变，线程安全，不会产生新对象。每个StringBuffer对象都有一定的缓冲区容量，可自动扩容值可变，线程不安全，速度更快

对String操作时内存变化：

img

初始String值为“hello”，然后在后面加上“world”，就需要重新开辟空间存word，然后再开辟空间存hello world，在让引用指向hello world，消耗大。使用StringBuilder&StringBuffer

继承关系

img

常用方法
/*
   StringBuffer线程安全的,值可变的字符串(指的是底层char[]的值在变)
   public StringBuffer() {
       super(16);
   }
   AbstractStringBuilder(int capacity) {
       value = new char[capacity];
   }
   StringBuilder线程不安全的,值可变的字符串
*/
StringBuffer stringBuffer = new StringBuffer("abc");//创建了一个字符串对象,底层是一个默认长度为3+16的数组
System.out.println(stringBuffer.capacity());//返回底层char[]的长度
stringBuffer.append("111111");
stringBuffer.append("222222");
stringBuffer.append("3333de");  //底层数组扩容int newCapacity = (value.length << 1) + 2;
System.out.println(stringBuffer);//输出字符串
System.out.println(stringBuffer.indexOf("1",6));//获取指定字符串的索引(第一次出现),从第几个开始
System.out.println(stringBuffer.charAt(20));//获取指定索引的字符
System.out.println(stringBuffer.insert(2,"F"));//在指定索引位置添加字符串
System.out.println(stringBuffer.deleteCharAt(2));//删除指定索引位置的字符
System.out.println(stringBuffer.delete(3,9));//删除索引区间的字符,从3到9不含9
System.out.println(stringBuffer.reverse());//字符串取反
System.out.println(stringBuffer.replace(0,14,"qwer"));//替换
System.out.println(stringBuffer.substring(1,3));//字符串截取:直接返回String类型
-----------------------------------------------
19
abc1111112222223333de
6
e
abFc1111112222223333de
abc1111112222223333de
abc2222223333de
ed3333222222cba
qwera
we

Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和，返回值类型一般为double型

System.out.println(Math.abs(-2.0)); //绝对值       2.0
System.out.println(Math.sqrt(64.0));  //立方根     8.0
System.out.println(Math.max(56,78)); //两者之间较大的      78
System.out.println(Math.min(56,78)); //两者之间较小的      56
System.out.println(Math.random());  //随机,数大于等于 0.0 ，小于 1.0
System.out.println(Math.pow(2,10));  //幂        1024.0
System.out.println(Math.ceil(18.36));  //向上取整       19.0
System.out.println(Math.floor(18.66));  //向下取整      18.0
System.out.println(Math.round(11.5));  //四舍五入 -->long    12
System.out.println(Math.round(-11.5));  //四舍五入      -11

Random类

此类用于产生随机数

  • Random random = new Random(long send)：send为随机数种子，如果send相同，随机数也相同，无参就按照当前时间
  • public int nextInt(int bound) ：bound为随机数范围，从0开始
Random random = new Random();
int a = random.nextInt(100)+1;  //范围在1~100之间

byte[] bytes = new byte[5];
random.nextBytes(bytes);  //直接对byte[]进行操作,随机赋值，只有byte[]
System.out.println(Arrays.toString(bytes));
-----------------------------------------------
[-69, 4, -9, -105, -94]

System类

位于java.lang包，代表系统，系统级的很多属性和控制方法都放置在该类的内部

构造方法是私有的，所以无法创建该类的对象，也就是无法实例化该类。

其内部的成员方法和成员变量都是静态的，直接使用类

成员变量

in、out、err

out是PrintStream的final static来修饰变量，由此可见，out是可以调用printStream中的方法的。例如，system.out.println中的println就是printStream中的一种输出方法

public final static InputStream in;		//标准输入流
public final static PrintStream out;	//标准输出流
public final static PrintStream err;	//标准错误流

成员方法

  • currentTimeMillis()：获取时间
  • arraycopy()：复制数组
  • exit()：停机
  • gc()：垃圾回收
System.out.println(System.currentTimeMillis());  //获取操作系统的时间-毫秒 自1970-1-1 0:0:0
System.out.println(System.getProperty("os.version"));//操作系统版本

System.out.println(System.getenv());//获取环境变量
System.out.println(System.getenv("Path"));  //接收指定环境变量


//返回一个指定长度的新数组,把原数组的值填充进去
int[] a = {1, 2, 3, 4, 5};
int[] ints = Arrays.copyOf(a, 10);
System.out.println(Arrays.toString(ints));
/*
   src 原数组
   srcpos 原数组的起点
   dest 目标数组
   destpos 目标数组起点
   length 要复制的数量
*/
int[] c = new int[10];
System.arraycopy(a, 0, c, 4, a.length);
System.out.println(Arrays.toString(c));
}

System.exit(0); //退出,停止虚拟机
System.gc();//手动垃圾回收
-------------------------------------------------------
1643547929217
10.0
{USERDOMAIN_ROAMINGPROFILE=DEEVAN...
D:\Program Files\VMware\VMware workstation\bin\...
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 2, 3, 4, 5, 0]

Date类

Date类是经常会使用到的一个用来处理日期、时间的一个类

Date date = new Date();  // 创建一个日期对象,里面包含程序运行时那一刻的时间
System.out.println(date);//格式输出时间
System.out.println(date.getTime());//获取long类型的时间
System.out.println(date.toLocaleString()); 根据本地区习惯输出一个字符串格式的时间

Date date1 = new Date(1627062196656L);
System.out.println(date1);

System.out.println(date.after(date1));   //true
System.out.println(date.before(date1));   //false
System.out.println(date.compareTo(date1));  //1   返回-1/0/1

/*
       System.out.println(date.getYear()+1900);//获得年   过期方法  可以使用  只是官方不推荐
       System.out.println(date.getMonth()+1); // 0开始
       System.out.println(date.getDate());  //月中的第几天
       System.out.println(date.getDay()); //周中的第0天      从0开始 0-星期天
       System.out.println(date.getHours());
       System.out.println(date.getMinutes());
       System.out.println(date.getSeconds());
*/
-----------------------------------------------------------
Sat Jul 24 01:47:35 GMT+08:00 2021
1627062455800
2021-7-24 1:47:35
Sat Jul 24 01:43:16 GMT+08:00 2021

Calendar类

Calendar是java util包下的一个工具类，提供了很方便的不同日期格式的处理

//Calendar是抽象类 不能创建对象 ,两种方法创建
Calendar calendar =Calendar.getInstance();     //获取子类对象
Calendar calendar1 = new GregorianCalendar();    //直接new子类对象

//calender.set(year, month, date, hourOfDay, minute, second)
calendar.set(2021,7,24);
calendar.add(Calendar.SECOND,1);//时间加1秒
System.out.println(calendar.getTime());		//Tue Aug 24 02:18:57 GMT+08:00 2021
System.out.println(calendar.getTimeInMillis());	//1629742737877
System.out.println(calendar.get(Calendar.MONTH)+1);//获取月数+1		8
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//一年中的第几天	236

SimpleDateFormat类

根据给定的日期格式字符串

通过SimpleDateFormat在String和Date之间相互转换

Date date = new Date();
System.out.println(date); //默认格式  Sat Jul 24 02:39:19 GMT+08:00 2021
System.out.println(date.toLocaleString());//当地默认格式  2021-7-24 2:39:19

//日期转字符串
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日\thh:mm:ss SSS E");//日期格式化
String str = simpleDateFormat.format(date); //把java中的对象型(new Date()  Calendar ) 转为指定格式的字符
System.out.println(str);    //2021年07月24日	02:39:19 627 星期六

//字符串转日期
String birthday ="2001-11-15";	
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
try {
    Date date1 =simpleDateFormat1.parse(birthday);//字符串日期格式与 指定格式必须一致
    System.out.println(date1);     //Thu Nov 15 00:00:00 GMT+08:00 2001
} catch (ParseException e) {	//表示解析时意外出现错误异常
    e.printStackTrace();
}

BigInteger类

大整数 可以表示任意的整数

add()，subtract()，multiply()，divide() 加减乘除

BigInteger a  = new BigInteger("1111111111111111111111111111111111111111111111111");
BigInteger c = a.add(b);//加

BigDecimal类

  • 在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去 一定的精确度。
  • 根本原因是：十进制值通常没有完全相同的二进制表示形式；十进制数的二进制表示形式可能不精确。只能无限接近于那个值
System.out.println((10.5-10.4)==0.1);   //false

金融项目，因为涉及金额的计算都必须十分精确

add()，subtract()，multiply()，divide() 加减乘除

BigDecimal a = new BigDecimal("10.5");
BigDecimal b = new BigDecimal("10.4");
System.out.println(a.subtract(b));	//0.1
EnndmeRedis
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
第五章 Java中的常用类（Math类和Random类）
weixin_57263458的博客
01-03 121
Math类 math类是一个工具类，用于进行数学运算。他的构造方法被定义成private，我们无法创建实例对象，Math类中的所有方法都是静态方法，可以直接通过类名去调用。 public class Example{ public static void main(String[]args){ System.out.println("计算绝对值的结果"+Math.abs(-1)); System.out.println("计算正弦的结果"+Math.sin(2.
JavaSE第五章 java常用API
qq_37079157的博客
11-14 740
文章目录5 第五章JavaAPI5.1 基本数据类型包装类5.2 Object转成字符串toString()比较equals()返回哈希值hashCode()5.3 Arrays5.3.1 转成字符串toString()5.3.2 比较equals()5.3.3 排序 sort()（快速排序）对普通类型的排序对象数组的排序自定义排序用name对Student数组进行排序用id对Student数组进行排序5.3.4 查找 binarySearch()（二分）手撕二分查找5.4 String5.4.1 字符串的
Java(重点)知识总结——第五章:Java中的常用类
qq_45952480的博客
06-27 128
第五章 字符串类 判断功能： String s= "HelloWorld"; booleanresult=s.equals("HelloWorld"); System.out.println(result); result=s.equalsIgnoreCase("helloworld"); System.out.println(result); result=s.startsWith("H"); System.out.println(result); result=s.endsWit..
第五章.常用类.java.API概述——StringBuffer类，StringBuilder类，Math类，System类，Random类
qq_51913153的博客
11-21 240
1.StringBuffer类，StringBuilder类 StringBuffer类与StringBuilder类相似，方法相似，这里以StringBuffer类为例。 1.1 2.Math类 包含了一些数学中常用的计算方法 2.1abs()
JavaSE第八章.IO
qq_52163230的博客
07-28 143
目录IO流分类![在这里插入图片描述](https://img-blog.csdnimg.cn/ec20a41cce134db0b74707a293327072.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUyMTYzMjMw,size_16,color_FFFFFF,t_70#pic_center)特性非流式File类流式字节流缓冲数组
JavaSE第二章.基础语法
qq_52163230的博客
05-20 313
1.IDE的使用 IDE(Integrated Development Environment )集成开发环境,是用于 提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器 和图形用户界面等工具。 ● 常用的java开发工具有 IntelliJ IDEA 免费下载 使用收费 Eclipse 完全免费 安装设置参考文档 2.注释 使用的特定的符号标记的内容,对代码功能的解释 // 单行注释 /* 多行注释 */ /** 文档注释 用于为类,成员变量,方法的功能进行说明,在调用时可以提示
JavaSE 第十二章 常用类
技术小白
02-20 102
1、基本数据类和引用数据类型 八种基本数据类型有对应的包装类型，认识基本数据类型与包装类型之间的转化。同时知道数组转化为 字符串，以及将字符串转化为数值类型。 装箱：将基本数据类型转化为包装类型称之为装箱 int i = 500; Integer t = new Integer(i); Float f = new Float(“4.56”); 拆箱：将包装类型转化为基本数据类型称之为拆箱 boolean b = bObj.booleanValue(); 字符串转换成基本数据类型 通过包装类的
JavaSE之第九章常用类
weixin_45603326的博客
08-07 110
JavaSE之第九章常用类
JavaSE 第 9 章 常用类
Serinaldo的博客
05-31 140
1.String声明为final的，不可被继承2.String实现了Serializable接口（可序列化接口）：表示字符串是支持序列化的。String实现了Comparable接口：String可以比较大小3.String在内部定义了final char[] value用于存储字符串数据4.String：代表不可变的字符序列。简称：不可变性。体现：1、当字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的内存区域赋值2、当对现有的字符串进行连接操作时，也需要指定内存区域赋值，不能对原有的内存区域赋值
JavaSE上机练习1.zip
04-20
在本上机练习1.zip中，我们重点关注的是JavaSE的基础知识，特别是第五章的内容。 在JavaSE的学习中，第五章通常会涵盖以下几个关键知识点： 1. **面向对象编程**：Java是一种完全面向对象的语言，第五章可能详细...
使用Java理解程序逻辑第15章.zip
04-20
在本章"使用Java理解程序逻辑第15章"中，我们主要探讨的是如何通过Java语言来深化对程序逻辑的理解。Java作为一种强大的面向对象编程语言，不仅被广泛应用于软件开发，也是学习程序设计的重要工具。JavaSE（Java ...
使用Java理解程序逻辑第1章.zip
04-20
在本压缩包“使用Java理解程序逻辑第1章.zip”中，主要涵盖了Java SE（标准版）的基础知识，尤其侧重于程序逻辑的理解。作者田超凡原创的这一章节旨在帮助初学者建立坚实的Java编程基础。Java SE是Java平台的核心...
尚硅谷javaSE所有课后练习答案.zip
08-17
第4章和第5章的练习涵盖了这些基础，帮助学员理解和应用面向对象的设计原则。 2. **数组**：在Java中，数组是一种存储同类型数据的集合，第3章节的练习可能涉及数组的声明、初始化、遍历以及数组操作技巧，如排序和...
Java基础（课件2-9+输出）第一章.zip
10-19
7. **字符串**：Java中的String类是不可变的，理解其特性和常用方法，如concat(), substring(), equals()等。 8. **异常处理**：了解Java中的异常体系，如何使用try-catch-finally结构进行异常捕获和处理。 9. **...
Java反射&序列化
qq_52163230的博客
10-25 1011
概述 什么是反射 ​ JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制 反射就是把java类中各个成分映射成一个个java对象 ​ 例如一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象 优点 ​ 可以只写一套代码，就可以获得任意类的信息，并创建其对象 Class类 一旦class文件被加
JavaSE第十章.线程
qq_52163230的博客
08-04 447
目录程序进程线程线程和进程的关系创建线程1.继承Thread类2.实现Runnable接口Thread类中的常用方法放缓休眠线程优先级线程状态线程的分类用户线程守护线程多线程概念何时需要多线程优点缺点线程同步并发与并行多线程同步synchronized修饰代码块修饰方法LOCK线程死锁产生死锁的原因产生死锁的必要条件线程通信新增创建线程方式 程序进程线程 程序 程序(program),是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码 进程 进程((process),就是正在执行的
JavaSE第十一章.GUI
qq_52163230的博客
08-06 372
目录概述Swing组件容器组件JFrameJPanel布局管理器FlowLayoutBorderLayoutGridLayout功能组件JLabelJTextFieldJTextAreaJPasswordFieldJButtonJMenuBar事件处理监听按钮监听菜单项监听鼠标键盘监听对话框内部类成员内部类静态内部类局本内部类匿名内部类 概述 GUI（Graphical User Interface）即图形用户界面 Swing组件 （1）顶层容器:：常用有JFrame，JDialog （2）中间容器：JPa
JavaSE第七章.集合
qq_52163230的博客
07-27 331
目录泛型集合概述CollectionListArrayListLinkedListVectorSetHashSetTreeSetIteratorMapHashMapput()底层原理TreeMapHashTableCollections类 泛型 即“参数化类型” 就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参）,然后在使用/调用时传入具体的类型（类型实参） ![2019101117003396](S:\非凡csdn\图片暂存javase\201910
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

EnndmeRedis

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值