java常用类

标签：常用 java String int System println public out

Api概述

API(Application Programming Interface)
应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为Xxx Robot API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类
Api文档

Object类/Scanner类

Object类概述

类层次结构的根类
-所有类都直接或者间接的继承自该类

Object的成员方法

public int hashCode()


public int hashCode() 可以看作是一个对象的地址值的另外一种体现，不同的对象可能是一样

public final Class getClass()

public final Class getClass() 获取当前对象对应类的Class对象

public String toString()

public String toString()  将一个对象以指定的字符串格式输出, 默认情况下也可以看作是一个地址值的表现形式
    java中直接输出对象名，默认调用的就是toString()方法
    我们正常情况下，直接输出对象名，是想观察对象中的成员变量值的情况，重写toString()方法

class Student1{
    String name;
    int age;

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

public class ObjectDemo1 {
    public static void main(String[] args) {
        Student1 s1 = new Student1();
        s1.name = "张三";
        s1.age = 18;
        System.out.println("姓名：" + s1.name + ", 年龄：" + s1.age);

        System.out.println("-----------------------------------");
        Student1 s2 = new Student1();
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s1==s2);
        System.out.println("-----------------------------------");
        System.out.println(s1.getClass().getName());
        System.out.println("-----------------------------------");
        System.out.println(s1.toString()); // shujia.day07.ketang.Student1@4554617c
        System.out.println(s1); // shujia.day07.ketang.Student1@4554617c

    }
}

public boolean equals(Object obj)

public boolean equals(Object obj) Object类中的equals方法底层是使用==比较的，比较的是地址值
    如果要比较内容值的话，需要在对象的类中重写该方法

protected void finalize()

protected void finalize()  做垃圾回收的

protected Object clone()

浅拷贝

Cloneable接口中什么方法都没有，像这样的接口称之为标记接口

Scanner类

import java.util.Scanner;

/*
    Scanner:
 */
public class ScannerDemo1 {
    public static void main(String[] args) {
        //Scanner(InputStream source)
        Scanner sc = new Scanner(System.in);

//        System.out.println("请输入一个数字：");
////         hasNextXxx() 判断输入的内容是否是对应的类型
//        if(sc.hasNextInt()){
//            int i = sc.nextInt();
//            System.out.println("out: "+i);
//        }else {
//            System.out.println("您输入的不是数字！");
//        }

        System.out.println("请输入一个数字：");
        int i = sc.nextInt();
        System.out.println("out: " + i);
        System.out.println("请输入一个字符串：");
//        String s1 = sc.next(); // 不会接收换行符，空白字符
        String s1 = sc.nextLine(); // 也可以接收换行符，空白字符
        System.out.println("out: " + s1);


    }
}

String类/StringBUffer类/StringBUilder类

String类

字符串：由若干个字符构成的字符序列，每一个字符位置是固定的
在java中，提供了一个类来表示字符串：String
Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例【对象】。
因为String对象是不可变的，它们可以被共享。
思考：
1、同一个内容的字符串，为什么地址值也是一样的？因为都指向常量池中的同一个字符串地址值。
2、String对象是不可变的，我们却可以修改字符串变量的值？字符串不可变指的是常量池中的字符串本身不能改变。
3、为什么直接打印字符串对象名，获取的是字符串内容值，而不是地址值？String类中重写了toString()方法

String类的构造方法

String类中的构造方法：
    public String()
    public String(byte[] bytes)
    public String(byte[] bytes,int offset,int length)
    public String(char[] value)
    public String(char[] value,int offset,int count)
    public String(String original)

public class StringDemo2 {
    public static void main(String[] args) {
        //public String()
        String s1 = new String();
        System.out.println("s1: "+s1);
        System.out.println("-----------------------");
        //public String(byte[] bytes)  将字节数组转成一个字符串
        byte[] bytes = {97,65,48,98,99};
        String s2 = new String(bytes);
        System.out.println("s2: "+s2);
        System.out.println("-----------------------");
        //public String(byte[] bytes,int index,int length)  截取字节数组一部分转成字符串
        String s3 = new String(bytes, 1, 3);
        System.out.println("s3: "+s3);
        System.out.println("-----------------------");
        //public String(char[] value) 将字符数组转成一个字符串
        char[] chars = {'我','爱','刘','亦','菲'};
        String s4 = new String(chars);
        System.out.println("s4: "+s4);
        System.out.println("-----------------------");
        //public String(char[] value,int offset,int count) 截取字符数组一部分转成字符串
        String s5 = new String(chars,2,3);
        System.out.println("s5: "+s5);
        System.out.println("-----------------------");
        //public String(String original)
        String s6 = new String("hello");
        System.out.println("s6: "+s6);
        System.out.println("-----------------------");
        String s = new String("hello");
        String s7 = "hello";
        System.out.println(s==s7);

    }
}

字符串String类中的判断功能

boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean startsWith(String str)
boolean endsWith(String str)
boolean isEmpty()

public class StringDemo3 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";

        //boolean equals(Object obj) 比较两个字符串内容是否相同,区分大小写
        System.out.println(s1.equals(s2));

        //boolean equalsIgnoreCase(String str) 忽略大小写比较两个字符串内容是否相同
        String s3 = "HelLo";
        System.out.println(s1.equalsIgnoreCase(s3));

        //boolean contains(String str) 判断一个字符串中是否包含另一个字符串
        String s4 = "今天的天气有点凉，不太适hello合出去郊游";
        System.out.println(s4.contains(s1));


        //boolean startsWith(String str) 判断某一个字符串是否以某个字符串开头
        System.out.println(s4.startsWith("今天我"));

        // boolean endsWith(String str) 判断某一个字符串是否以某个字符串结尾
        System.out.println(s4.endsWith("不去郊游"));

        // boolean isEmpty() 判断一个字符串是否是空字符串
        String s5 = "hello";
        System.out.println(s5.isEmpty());
    }
}

字符串String类的获取功能

字符串String类中的获取功能：
    int length()
    char charAt(int index)
    int indexOf(int ch)
    int indexOf(String str)
    int indexOf(int ch,int fromIndex)
    int indexOf(String str,int fromIndex)
    String substring(int start)
    String substring(int start,int end)

public class StringDemo4 {
    public static void main(String[] args) {
        String s1 = "hello";

        //int length() 获取字符串中的字符个数
        System.out.println(s1.length());

        //char charAt(int index) 根据索引获取对应位置上的字符
        System.out.println(s1.charAt(1));
//        System.out.println(s1.charAt(9));

        //int indexOf(int ch) 根据字符对应ASCII码数值获取对应字符的位置索引
        System.out.println(s1.indexOf(101));

        //int indexOf(String str) 获取大字符串中小字符串的第一个字符的位置,r若不包含返回-1
        String bigStr = "dwqsredhelloqjion";
        String smallStr = "world";
        System.out.println(bigStr.indexOf(smallStr));

        //int indexOf(int ch,int fromIndex) 从指定索引开始查找对应的字符
        String s2= "dwqrewqrffqewrfdwqqrfwqfwq";
        System.out.println(s2.indexOf(101,5));

        //int indexOf(String str,int fromIndex) 从指定索引开始查找对应的字符串
        //TODO:自己实验

        //String substring(int start) 从指定索引开始截取字符串到某尾
        String s3 = "数加科技欢迎大家的到来";
        String s4 = s3.substring(4);
        System.out.println("s3: "+s3);
        System.out.println("s4: "+s4);

        //String substring(int start,int end) 指定开始索引和结束索引截取字符串的一部分
        String s5 = s3.substring(4, 8);
        System.out.println("s5: "+s5);


    }
}

String类中的转换功能

String类中的转换功能：
    byte[] getBytes()
    char[] toCharArray()
    static String valueOf(char[] chs)
    static String valueOf(int i)
    String toLowerCase()
    String toUpperCase()
    String concat(String str)

 */
public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = "数加";

        // byte[] getBytes() 将字符串转成字节数组的形式【受编码的影响】
//        byte[] bytes = s1.getBytes();
        byte[] bytes = s1.getBytes();
        printIntArray(bytes);


        // char[] toCharArray()
        char[] chars = s1.toCharArray(); // 将字符串转成字符数组的形式
        printIntArray(chars);

        //static String valueOf(char[] chs) // 将字符数组转字符串
        String s2 = String.valueOf(chars);
        System.out.println(s2);

        //static String valueOf(int i) // 将数值转成字符串
        String s3 = String.valueOf(10);
        System.out.println(s3); // "10"

        //String toLowerCase() 将字符串转小写
        String s4 = "HellO";
        String s5 = s4.toLowerCase();
        System.out.println(s5);

        //String toUpperCase() 将字符串转大写
        String s6 = s5.toUpperCase();
        System.out.println(s6);

        // String concat(String str) 字符串拼接
        String s7 = "shujia";
        String s8 = "keji";
        System.out.println(s7+s8);
        System.out.println(s7.concat(s8));


    }
    public static void printIntArray(char[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print("[" + array[i] + ",");
            } else if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
    }


    public static void printIntArray(byte[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print("[" + array[i] + ",");
            } else if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
    }
}

String的替换功能

String类中的替换功能
    String replace(char old,char new)
    String replace(String old,String new)
去除字符串两空格
    String trim()
按字典顺序比较两个字符串【重要！！】
    int compareTo(String str) 按照字符串中的字符从左向右依次比较=，如果长度和内容都一样，返回0
    int compareToIgnoreCase(String str)

public class StringDemo6 {
    public static void main(String[] args) {
        String s1 = "今天是20205年1月4日，hello今年是蛇年hellodsaqwwdq";
        //String replace(char old,char new) 使用新字符替换所有的旧字符
        String s2 = s1.replace('h', '_');
        System.out.println("s1: "+s1);
        System.out.println("s2: "+s2);

        System.out.println("--------------------");
        //String replace(String old,String new) 使用新的字符串替换旧字符串
        String s3 = s1.replace("hello", "flinkspark");
        System.out.println("s1: "+s1);
        System.out.println("s3: "+s3);

        System.out.println("--------------------");
        String s4 = "    hello world    ";
        System.out.println(s4.trim());
        System.out.println("--------------------");

        String s5 = "hello";
        String s6 = "world";
        String s7 = "hel";
        System.out.println(s5.compareTo(s6)); // -15
        System.out.println(s5.compareTo(s7)); // 2

        // "hello","apple","world","flink","hadoop"


    }
}

/*
    String类中的compareTo源码解释：
            //s5.compareTo(s6)
            public int compareTo(String anotherString) {
                int len1 = value.length; // 5
                int len2 = anotherString.value.length; // 3
                int lim = Math.min(len1, len2); // 3
                char[] v1 = value; // ['h','e','l','l','o']
                char[] v2 = anotherString.value; // ['h','e','l']
                int k = 0;

                while (k < lim) {
                    char c1 = v1[k]; // 'h'  'e'  'l'
                    char c2 = v2[k]; // 'h'  'e'  'l'
                    if (c1 != c2) {
                        return c1 - c2; // 104 - 119 = -15
                    }
                    k++;
                }
                return len1 - len2; // 2
            }
 */

StringBuffer类

StringBuffer类概述
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题
线程安全的可变字符序列

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

    构造方法：
        public StringBuffer()
        public StringBuffer(int capacity)
        public StringBuffer(String str)

public class StringBufferDemo1 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        System.out.println("sb1: " + sb1);

        // 获取StringBuffer容量大小
        System.out.println(sb1.capacity());
        // 获取实际的字符个数
        System.out.println(sb1.length());

        System.out.println("----------------");
        //public StringBuffer(int capacity) 指定容量大小
        StringBuffer sb2 = new StringBuffer(100);
        // 获取StringBuffer容量大小
        System.out.println(sb2.capacity());
        // 获取实际的字符个数
        System.out.println(sb2.length());
        System.out.println("----------------");
        //public StringBuffer(String str)  创建StringBuffer对象的时候，放入一个初始字符串
        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println(sb3.capacity()); // 21
        // 获取实际的字符个数
        System.out.println(sb3.length());
        System.out.println("----------------");

    }
}

StringBuffer方法二

添加功能
    public StringBuffer append(String str)
    public StringBuffer insert(int offset,String str)
删除功能
    public StringBuffer deleteCharAt(int index)
    public StringBuffer delete(int start,int end)
替换功能
    public StringBuffer replace(int start,int end,String str)
反转功能
    public StringBuffer reverse()
截取功能
    public String substring(int start)
    public String substring(int start,int end)

public class StringBufferDemo2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();

        //public StringBuffer append(String str) 末尾处追加
        sb.append(10);
        sb.append(12.34);
        sb.append(true);
        sb.append("hello");
        sb.append('w');
        System.out.println("sb: "+sb);

        //1012.34truehellow
        //public StringBuffer insert(int offset,String str) 指定索引插入元素
        sb.insert(5,"java");
        System.out.println("sb: "+sb);

        //1012.java34truehellow
        //public StringBuffer deleteCharAt(int index) 根据索引删除元素
        sb.deleteCharAt(7);
        System.out.println("sb: "+sb);

        //1012.jaa34truehellow
        //public StringBuffer delete(int start,int end) 指定开始和结束索引删除一部分字符
        sb.delete(7,11);
        System.out.println("sb: "+sb);

        //1012.jaruehellow
        //public StringBuffer replace(int start,int end,String str)  替换StringBuffer一部分字符序列
        sb.replace(7,10,"flink");
        System.out.println("sb: "+sb);

        //public StringBuffer reverse() 将StringBuffer中的字符序列反转
        StringBuffer sb2 = new StringBuffer("hello");
        sb2.reverse();
        System.out.println("sb2: "+sb2);


        //public String substring(int start)
        StringBuffer sb3 = new StringBuffer("世界很大，我想去看看！");
        String s1 = sb3.substring(5);
        System.out.println("sb3: "+sb3);
        System.out.println("s1: "+s1);

        String s2 = sb3.substring(5,8);
        System.out.println("sb3: "+sb3);
        System.out.println("s1: "+s2);

    }
}

String作为参数传递

public class StringBufferDemo3 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println("s1: " + s1 + ", s2: " + s2); // s1: hello,s2: world
        change(s1, s2);
        System.out.println("s1: " + s1 + ", s2: " + s2);// s1: hello,s2: world



    }

    public static void change(String s1, String s2) {
        System.out.println("s1: " + s1 + ", s2: " + s2);// s1: hello,s2: world
        s1 = s2;
        s2 = s1 + s2;
        System.out.println("s1: " + s1 + ", s2: " + s2);// s1: world,s2: worldworld
    }
}

StringBuffer作为参数传递

public class StringBufferDemo4 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: hello,sb2: world
        change(sb1,sb2);
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: hello,sb2: worldworld
    }

    public static void change(StringBuffer sb1,StringBuffer sb2){
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: hello,sb2: world
        sb1 = sb2;
        sb2.append(sb1);
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: worldworld,sb2: worldworld
    }
}

Arrays工具类

import java.util.Arrays;

/*
    Arrays: jdk针对数组做操作的一个工具类

    成员方法：
        public static String toString(int[] a) 以指定格式查看任意类型元素的数组
        public static void sort(int[] a) 快速排序一个数组，从小到大
        public static int binarySearch(int[] a,int key)  二分查找，返回所查找元素的索引，前提该序列要有序


 */
public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] arr = {123,5432,67,2,64,8443};
//        String s1 = Arrays.toString(arr);
//        System.out.println(s1);
        System.out.println("排序前："+Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后："+Arrays.toString(arr));

        //[2, 64, 67, 123, 5432, 8443]
        System.out.println(Arrays.binarySearch(arr,99)); // -4



    }
}

/*
    Arrays类中的binarySearch方法源码解释：
            public static int binarySearch(int[] a, int key) {
                // a - [2, 64, 67, 123, 5432, 8443]
                // key - 99
                return binarySearch0(a, 0, a.length, key);
            }

                // Like public version, but without range checks.
            private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
                // a - [2, 64, 67, 123, 5432, 8443]
                // fromIndex - 0
                // toIndex - 6
                // key - 99

                int low = fromIndex; // 0
                int high = toIndex - 1; // 5

                while (low <= high) {
                    int mid = (low + high) >>> 1; // 2  4  3
                    int midVal = a[mid]; // 67  5432 123

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

基本包装类/Random类

    Character是char基本数据类型的包装类

    八大基本数据类型对应的包装类都具备了自动装箱和自动拆箱的功能

    Character类中常用方法：
        public static boolean isUpperCase(char ch)
        public static boolean isLowerCase(char ch)
        public static boolean isDigit(char ch)
        public static char toUpperCase(char ch)
        public static char toLowerCase(char ch)

public class CharacterDemo1 {
    public static void main(String[] args) {
//        Character c1 = 'a'; // 自动装箱
//        Character c2 = new Character('a');


        char c1 = '5';

        // public static boolean isUpperCase(char ch) 判断一个字符是否是大写
        System.out.println(Character.isUpperCase(c1));
        System.out.println(Character.isLowerCase(c1));

        //public static boolean isDigit(char ch) 判断一个字符内容是否是一个数字
        System.out.println(Character.isDigit(c1));

        // public static char toUpperCase(char ch) 字符串转大写
        System.out.println(Character.toUpperCase('q'));
        System.out.println(Character.toLowerCase('Y'));


    }
}

Integer基本类型包装类:

byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character

Integer类的构造方法：
public Integer(int value)
public Integer(String s)

public class IntegerDemo1 {
    public static void main(String[] args) {
//        int i = 10;
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        //public Integer(int value) 将一个基本数据类型的值包装在一个包装类中
//        Integer i = new Integer(100);
        Integer i = 100; // 实际上是创建了一个Integer对象包装了100值，自动装箱

        System.out.println(i+100); // Integer对象其中的整数值自动拿出来做运算，自动拆箱



        // public Integer(String s) 将字符串转整数，实际上是封装在Integer对象中
        Integer i1 = new Integer("100"); // 字符串的内容是数字格式的才可以
        System.out.println(i1);


    }
}

Integer类中的方法：
public int intValue()
public static int parseInt(String s)
public static String toString(int i)
public static Integer valueOf(int i)
public static Integer valueOf(String s)

public static String toBinaryString(int i) // 10进制->2进制
public static String toOctalString(int i) // 10进制->8进制
public static String toHexString(int i) //10进制->16进制

public class IntegerDemo2 {
    public static void main(String[] args) {
        Integer i = new Integer(100);

        //public int intValue() 将包装的int值取出来
        // Integer -> int
        int i1 = i.intValue();
        System.out.println(i1);

        //public static int parseInt(String s) 将字符串转int类型
        // String -> int
        int i2 = Integer.parseInt("11");
        System.out.println(i2);

        // String -> Integer
        Integer i3 = new Integer("100");

        // public static String toString(int i)
        // int -> String
        String s1 = Integer.toString(12);
        System.out.println(s1);

        // public static Integer valueOf(int i)
        // int -> Integer
        Integer i4 = Integer.valueOf(15);
        System.out.println(i4);

        // public static Integer valueOf(String s)
        // String -> Integer
        Integer i5 = Integer.valueOf("19");
        System.out.println(i5);


        String s2 = Integer.toBinaryString(68); // 1000100
        System.out.println(s2);

    }
}

random类

import java.util.Random;

/*
    Random:
        public Random()

 */
public class RandomDemo1 {
    public static void main(String[] args) {
        Random random = new Random();

        //public int nextInt()
        System.out.println(random.nextInt());

        //public int nextInt(int n)
        System.out.println(random.nextInt(2) ); // [0, 100)
    }
}

Data类和DataFormat类

Data类

java提供了一个和日期相关的类：Date

构造方法：
        Date()  分配一个                                                         Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。
        Date(long date) 分配一个 Date对象，并将其初始化为表示自称为“时代”的标准基准时间以后的指定毫秒数，即1970年1月1日00:00:00 GMT。

    java针对日期格式化，提供了一个类：DateFormat-子类：SimpleDateFormat
    构造方法：
        public SimpleDateFormat(String pattern)

    提供了一个和日期相关的类：Date

    构造方法：
        Date()  分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。
        Date(long date) 分配一个 Date对象，并将其初始化为表示自称为“时代”的标准基准时间以后的指定毫秒数，即1970年1月1日00:00:00 GMT。

    java针对日期格式化，提供了一个类：DateFormat-子类：SimpleDateFormat
    构造方法：
        public SimpleDateFormat(String pattern)



 */
public class DateDemo1 {
    public static void main(String[] args) throws Exception{
//        Date d1 = new Date();
//        System.out.println(d1);
//
//        //1736128640411
//        //Date(long date) 传入指定的时间戳，转成Date类型对象
//        Date d2 = new Date(1736128640411L);  // TimeStamp -> Date
//        System.out.println(d2);
//        // Mon Jan 06 09:57:20 CST 2025  -> 2025-01-06 09:57:20
//        // yyyy-MM-dd HH:mm:ss
//        //根据日期模板创建SimpleDateFormat对象
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 aaa");
//        // 通过sdf对象将Date类型以指定的格式输出
//        String res1 = sdf.format(d2);  // Date -> String
//        System.out.println("日期："+res1);
//
//        String s2 = "今年是2045年，现在是上午的4点47分，今天是7月4号";
//        SimpleDateFormat sdf2 = new SimpleDateFormat("今年是yyyy年，现在是上午的HH点mm分，今天是MM月dd号");
//        Date d3 = sdf2.parse(s2); // String -> Date
//        String res2 = sdf.format(d3);
//        System.out.println(res2);

        String nowTime = DateUtil.getTime(System.currentTimeMillis());
        System.out.println(nowTime);


    }
}

package shujia.day09;

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

public class DateUtil {
    private DateUtil(){}

    public static String getTime(long timeStamp){
        Date d2 = new Date(timeStamp);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(d2);
    }
}

标签：常用,java,String,int,System,println,public,out
From： https://www.cnblogs.com/lanzhi666/p/18677802

java常用类

java常用类

Api概述

Object类/Scanner类

Object类概述

public int hashCode()

public final Class getClass()

public String toString()

public boolean equals(Object obj)

protected void finalize()

Scanner类

String类/StringBUffer类/StringBUilder类

String类

String类的构造方法

字符串String类中的判断功能

字符串String类的获取功能

String类中的转换功能

String的替换功能

StringBuffer类

StringBuffer方法二

String作为参数传递

StringBuffer作为参数传递

Arrays工具类

基本包装类/Random类

Integer基本类型包装类:

random类

Data类和DataFormat类

Data类

相关文章

赞助商

阅读排行