标签：常用 Java String System println new public out

Java常用类

内部类

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

特点:1.编译后可以生成独立的字节码文件

​ 2.内部类可以直接访问外部类的私有成员,而不破坏封装

​ 3.可为外部类提供必要的功能组件

//身体
public class Body {
    private String name;
    //头部
    class Header{
        public void show(){
            //内部类可以直接访问外部类的私有成员,而不破坏封装
            System.out.println(name);
        }
    }
}

成员内部类

在类的内部定义,与实例变量.实例方法同级别的类

//外部类
public class Outer {
    //实例变量
    private String name = "gy";
    private int age = 22;

    //内部类
    class Inner{
        private String address = "北京";
        private String phone = "110";

        //实例方法
        public void show(){
            //打印外部类的属性
            System.out.println(name);
            System.out.println(age);
            //打印内部类的属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

public class TestOuter {
    public static void main(String[] args) {
        //创建外部类对象
        Outer outer = new Outer();
        //创建内部类对象
        Outer.Inner inner = outer.new Inner();

        //一步到位
        //Outer.Inner inner = new Outer().new Inner();

        inner.show();
    }
}

外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

当外部类.内部类存在重名属性时,会优先访问内部类属性(Outer.this)

System.out.println(Outer.this.name);

成员内部类不能定义静态成员

静态内部类

不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员

//外部类
public class Outer {
    private String name = "gy";
    private int age = 22;

    //静态内部类:和外部类相同
    static class Inner{
        private String address = "上海";
        private String phone = "119";
        //静态成员
        private static int count = 1000;

        public void show(){
            //调用外部类的属性
            //1.先创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //调用静态内部类对象的属性
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}

public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        //调用方法
        inner.show();
    }
}

局部内部类

定义在外部类方法中,作用范围和创建对象范围仅限于当前方法

//外部类
public class Outer {
    private String name = "yg";
    private int age = 23;

    public void show(){
        //定义局部变量
        final String address = "青岛";
        //局部内部类:不能加任何访问修饰符
        class Inner{
            private String phone = "120";
            private String email = "[email protected]";
            public void show2(){
                //访问外部类的属性
                System.out.println(Outer.this.name);
                System.out.println(Outer.this.age);
                //访问内部类的属性
                System.out.println(this.phone);
                System.out.println(this.email);
                //访问局部变量
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final

final String address = "青岛";

限制类的使用范围

匿名内部类

没有类名的局部内部类(一切特征都与局部内部类相同)

必须继承一个父类或者实现一个接口

定义类.实现类.创建对象的语法合并,只能创建一个该类的对象

//接口
public interface Usb {
    //服务
    void service();
}

public class Mouse implements Usb{
    
    @Override
    public void service() {
        System.out.println("连接电脑成功,鼠标开始工作!");
    }
}

public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量
        //Usb usb = new Mouse();
        //usb.service();
        
//--------------------------------------------------------------
        
        //局部内部类
//        class Keyboard implements Usb{
//
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功,键盘开始工作!");
//            }
//        }

        //使用局部内部类创建对象
        //Usb usb = new Keyboard();
        //usb.service();
        
//---------------------------------------------------------------
        
        //使用匿名内部类优化(相当于创建了一个局部内部类)
        Usb usb = new Usb(){

            @Override
            public void service() {
                System.out.println("连接电脑成功,键盘开始工作!");
            }
        };
        usb.service();
    }
}

Object类

超类.基类.所有类的直接或间接父类,位于继承树的最顶层

任何类.如没有书写extends显示继承某个类,都默认都默认直接继承Object类,否则为间接继承

Object类中所定义的方法,是所有对象都具备的方法

Object类型可以存储任何对象

​ (1)作为参数,可接受任何对象

​ (2)作为返回值,可返回任何对象

Object类常用方法

getClass()方法

返回引用中存储的实际对象类型

应用:通常用于判断两个引用中实际存储对象是否一致

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        System.out.println("-----------------getClass方法-------------------");
        Student s1 = new Student("gy",22);
        Student s2 = new Student("yg",23);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}

hashCode()方法

public int hashCode(){}

返回该对象的哈希码值

哈希码值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("gy",22);
        Student s2 = new Student("yg",23);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
        
        //hashCode方法
        System.out.println("-----------------hashCode方法-------------------");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }
}

toString()方法

public String toString(){}

返回该对象的字符串表示(表现形式)

可以根据程序需求覆盖该方法,如:展示对象各个属性值

Student类:

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

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        System.out.println("-----------------getClass方法-------------------");
        Student s1 = new Student("gy",22);
        Student s2 = new Student("yg",23);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }

        //hashCode方法
        System.out.println("-----------------hashCode方法-------------------");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        //toString方法
        System.out.println("-----------------toString方法-------------------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}

equals()方法

public boolean equals(Object obj){}

默认实现为(this == obj),比较两个对象地址是否相同

可进行覆盖,比较两个对象的内容是否相同

覆盖步骤:

1. 比较两个引用是否指向同一个对象

2. 判断obj是否为null

3. 判断两个引用指向的实际对象类型是否一致

4. 强制类型转换

5. 依次比较各个属性值是否相同

	@Override
    public boolean equals(Object obj) {
        //1.比较两个引用是否指向同一个对象
        if (this==obj){
            return true;
        }
        //2.判断obj是否为null
        if (obj==null){
            return false;
        }
        //3.判断两个引用指向的实际对象类型是否一致
//        if (this.getClass()==obj.getClass()){
//        }
        //instanceof判断对象是否是某种类型
        if (obj instanceof Student){
            //4.强制类型转换
            Student s = (Student)obj;
            //5.依次比较各个属性值是否相同
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        System.out.println("-----------------getClass方法-------------------");
        Student s1 = new Student("gy",22);
        Student s2 = new Student("yg",23);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }

        //hashCode方法
        System.out.println("-----------------hashCode方法-------------------");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        //toString方法
        System.out.println("-----------------toString方法-------------------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());

        //equals方法:判断两个对象是否相等
        System.out.println("------------------equals方法--------------------");
        System.out.println(s1.equals(s2));
        Student s3 = new Student("gygy",23);
        Student s4 = new Student("gygy",23);
        System.out.println(s3.equals(s4));
    }
}

finalize()方法

当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收行列

垃圾对象:没有有效引用指向此对象时,为垃圾对象

垃圾回收:由GC销毁垃圾对象,释放数据存储空间

自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象

手动回收机制:使用System.gc();通知JVM执行垃圾回收

    @Override
    protected void finalize() throws Throwable {
        System.out.println(name+"对象已被回收!");
    }

public class TestStudent2 {
    public static void main(String[] args) {
//        Student s1 = new Student("aaa",21);
//        Student s2 = new Student("bbb",22);
//        Student s3 = new Student("ccc",23);
//        Student s4 = new Student("ddd",24);
//        Student s5 = new Student("eee",25);

        new Student("aaa",21);
        new Student("bbb",22);
        new Student("ccc",23);
        new Student("ddd",24);
        new Student("eee",25);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾...");
    }
}

包装类

基本数据类型所对应的引用数据类型

Object类可统一所有数据,包装类的默认值是null

8种包装类提供不同类型间的转换方式:

1. Number(数字类)父类中提供的6个共性方法(引用类型转换为基本类型):

• byte byteValue()
• abstract double doubleValue()
• abstract float floatValue()
• abstract int intValue()
• abstract long longValue
• shortValue()

2. parseXXX()静态方法
3. valueof()静态方法

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

装箱和拆箱

6个包装类型:Byte.Double.Float.Integer.Long.Short

案例:

public class Demo01 {
    public static void main(String[] args) {
        int num = 10;
        //JDK1.5之前
        //类型转换
        //1.装箱:基本类型转成引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2= Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);
        //2.拆箱:引用类型转成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //JDK1.5之后,提供自动装箱和拆箱
        int age = 22;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

基本类型和字符串转换

public class Demo02 {
    public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1.基本类型转为字符串
        int num1 = 100;
        //1.1使用+号
        String s1 = num1+"";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(num1,16);//radix:进制
        System.out.println(s1);
        System.out.println(s2);

        //2.字符串转为基本类型
        String str = "100";
        //使用Integer.parseXXX();
        int num2 = Integer.parseInt(str);
        System.out.println(num2);

        //boolean字符串转为基本类型 "true"--->true 非"true"--->false
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);
    }
}

Integer缓冲区

Java预先创建了256个常用的整数包装类型对象

在实际应用中,对已创建的对象进行复用

public static Integer valueOf(int i){
	if(i >= IntegerCache.low && i <= IntegerCache.high)//IntegerCache.low=-128 IntegerCache.high=127
		return IntegerCache.cache[i + (-IntegerCache.low)];
	return new Integer(i);
}

public class Demo03 {
    public static void main(String[] args) {
        //面试题
        //在使用"new Integer()"进行对象实例化时，每次都会创建一个新的对象实例
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//false

        //在使用"Integer.valueOf()"时，实际上会返回一个Integer类型的缓存实例
        //当调用"Integer.valueOf()"时，如果传入的参数在-128~127的范围内，则返回的是一个缓存实例，而不是新创建一个对象实例
        Integer integer3 = Integer.valueOf(100);//自动装箱
        Integer integer4 = Integer.valueOf(100);
        System.out.println(integer3 == integer4);//true

        Integer integer5 = Integer.valueOf(200);//自动装箱
        Integer integer6 = Integer.valueOf(200);
        System.out.println(integer5 == integer6);//false
    }
}

String类

字符串是常量,创建之后不可改变

字符串字面值存储在字符串池中,可以共享

public class Demo01 {
    public static void main(String[] args) {
        String name = "gy"; //"gy"常量存储在字符串池中
        name = "yg"; //"yg"赋值给name变量,给字符串赋值时,并没有修改数据,而是重新开辟了一个空间
        String name2 = "yg"; //从字符串池中找,如果有,则重用,如果没有,则重新开辟空间

        //字符串的另一种创建方式:new String();
        //产生两个对象,堆和池各存储一个
        String str = new String("gygy");
        String str2 = new String("gygy");
        System.out.println(str == str2); //false
    }
}

常用方法

• public int length():返回字符串的长度
• public char charAt(int index):根据下标获取字符
• public boolean contains(String str):判断当前字符串中是否包含str

public class Demo02 {
    public static void main(String[] args) {
        //字符串方法的使用
        //1.length();返回字符串的长度
        String content = "java是世界上最好的编程语言";
        System.out.println(content.length());
        //2.charAt(int index);返回某个位置的字符
        System.out.println(content.charAt(content.length()-1));
        //3.contains(String str);判断是否包含某个子字符串
        System.out.println(content.contains("java"));//true
        System.out.println("php");//false
    }
}

• public char[] toCharArray():将字符串转换成数组
• public int indexOf(String str):查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1
• public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下表索引

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        //字符串方法的使用
        //4.toCharArray();返回字符串对应的数组
        String content = "java是世界上最好的编程语言";
        System.out.println(Arrays.toString(content.toCharArray()));
        //5.indexOf();返回子字符串首次出现的位置
        System.out.println(content.indexOf("java"));//0
        //从第X个fromIndex(下标)后查找str(字符)所在的位置
        System.out.println(content.indexOf("好",0));//9
        //6.lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(content.lastIndexOf("java"));

    }
}

• public String trim():去掉字符串前后的空格
• public String toUpperCase():将小写转换为大写
• public boolean endWith(String str):判断字符串是否以str结尾

public class Demo04 {
    public static void main(String[] args) {
        //字符串方法的使用
        //7.trim();去掉字符串前后的空格
        String content = "Hello World!";
        System.out.println(content.trim());
        //8.toUpperCase();把小写转换为大写 toLowerCase();将大写转换为小写
        System.out.println(content.toUpperCase());
        System.out.println(content.toLowerCase());
        //9.endsWith(str);判断是否以str结尾 startsWith(str);判断是否以str开头
        String filename = "Hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("Hello"));
    }
}

• public String replace(char oldChar,char newChar):将旧字符串替换成新字符串
• public String[] split(String str):根据str做拆分

public class Demo05 {
    public static void main(String[] args) {
        //字符串方法的使用
        //10.replace(char old,char new);用新的字符串替换替换旧的字符串
        String content = "java是世界上最好的编程语言";
        System.out.println(content.replace("java","php"));
        //11.split();对字符串进行拆分
        String saying = "java is the best programing language in the world!";
        String[] arr = saying.split("[ ,]+");
        System.out.println(arr.length);
        for (String string : arr){
            System.out.println(string);
        }

        //补充两个方法:equals(); compare();比较大小
        String s1 = "hello";
        String s2 = "hello";
        //equalsIgnoreCase忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "aaa";
        String s4 = "bbb";
        System.out.println(s3.compareTo(s4));
    }
}

案例

需求:

1. 已知String str = "this is a text";
2. 将str中的单词单独获取出来
3. 将str中的text替换为practice
4. 在text前面插入一个easy
5. 将每个单词的首字母改为大写

public class Demo06 {
    public static void main(String[] args) {
        String str = "this is a text";
        String[] arr = str.split(" ");
        for (String string : arr){
            System.out.println(string);
        }

        System.out.println(str.replace("text","practice"));

        System.out.println(str.replace("text","easy text"));

        for (int i = 0;i<arr.length;i++){
            char first = arr[i].charAt(0);
            char upperfist = Character.toUpperCase(first);
            String news = upperfist+arr[i].substring(1);
            System.out.println(news);
        }
    }
}

可变字符串

StringBuffer:可变长字符串,JDK1.0提供,运行效率慢,线程安全

StringBuilder:可变长字符串,JDK5.0提供,运行效率快,线程不安全

/**
 * StringBuffer和StringBuilder的使用
 * 和String的区别
 * 1.效率比String高
 * 2.比String节省内存
 */
public class Demo07 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1.append();追加
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java不是世界第一");
        System.out.println(sb.toString());
        //2.insert();添加
        sb.insert(0,"哇塞");
        System.out.println(sb.toString());
        //3.replace();替换
        sb.replace(0,2,"wow");
        System.out.println(sb.toString());
        //4.delete();删除
        sb.delete(0,3);
        System.out.println(sb.toString());
        //5.清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

//验证StringBuilder效率高于String
public class Demo08 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
//        String string = "";
//        for (int i = 0;i < 99999;i++){
//            string += i;
//        }
//        System.out.println(string);

        StringBuilder sb = new StringBuilder();
        for (int i = 0;i < 99999;i++){
            sb.append(i);
        }
        System.out.println(sb.toString());
        long end = System.currentTimeMillis();
        System.out.println("用时:"+(end-start));
    }
}

BigDecimal类

位置:java.math包中

作用:精确计算浮点数

创建方式:BigDecimal bd = new BidDecimal("1.0");

import java.math.BigDecimal;

//BigDecimal 大的浮点数精确计算
public class Demo01 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//0.099999999

        double result = (1.4-0.5)/0.9;
        System.out.println(result);//0.99999999

        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);
        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);
        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);
        //除法:divide(BigDecimal bd,int scal,RoundingMode mode)
        //参数scal:指定精确到几位小数点后几位
        //参数mode:
        //指定小数部分的取舍模式,通常采用四舍五入的模式
        //取值为BigDecimal.ROUND_HALF_UP
        BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(r4);
        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);
    }
}

Date类

Date表示特定的瞬间,精确到毫秒.Date类中的大部分方法都已经被Calender类中的方法所取代

时间单位:

• 1秒=1000毫秒
• 1毫秒=1000微秒
• 1微妙=1000纳秒

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //1.创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toString());

        //2.after和before方法
        boolean b1 = date1.after(date2);
        System.out.println(b1);
        boolean b2 = date1.before(date2);
        System.out.println(b2);

        //3.compareTo();比较
        int d = date1.compareTo(date2);
        System.out.println(d);

        boolean b3 = date1.equals(date2);
        System.out.println(b3);
    }
}

Calendar类

Calendar提供了获取或设置各种日历字段的方法

构造方法:protected Calendar():由于修饰符是protected,所以无法直接创建该对象

其他方法:

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year,int month,int date,int hourofday,int minute,int second)	设置日历的年.月.日.时.分.秒
int get(int field)	返回给定日历字段的值.字段比如年.月.日等
void setTime(Date date)	用给定的Date设置此日历的时间.Date-Calender
Date getTime()	返回一个Date表示此日历的时间.Calender-Date
void add(int field,int amount)	按照日历的规则,给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

import java.util.Calendar;

public class Demo01 {
    public static void main(String[] args) {
        //1.创建Calender对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2.获取时间信息
        //获取年
        int year = calendar.get(calendar.YEAR);
        //获取月
        int month = calendar.get(calendar.MONTH);
        //获取日
        int day = calendar.get(calendar.DAY_OF_MONTH);
        //获取小时
        int hour = calendar.get(calendar.HOUR);
        //获取分钟
        int minute = calendar.get(calendar.MINUTE);
        //获取秒
        int second = calendar.get(calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,12);
        System.out.println(calendar2.getTime().toLocaleString());
        //4.add方法修改时间
        calendar2.add(Calendar.MONTH,+1);
        System.out.println(calendar2.getTime().toLocaleString());
        //5.补充方法
        //获取当前月的最后一天
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        //获取当前月的第一天
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类

进行格式化(日期->文本),解析(文本->日期)

常用的时间模式字母:

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中小时数(0~23)	22
m	分钟	16
s	秒	59
S	毫秒	367

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

public class Demo01 {
    public static void main(String[] args) {
        //1.创建SimpleDateFormat对象
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd/HH:mm:ss");
        //2.创建Date
        Date date = new Date();
        //格式化date(把日期转换为字符串)
        String str = simpleDateFormat.format(date);
        System.out.println(str);
        //解析(把字符串转换为日期)
        Date date2 = null;
        try {
            date2 = simpleDateFormat.parse("2001/02/22/22:22:22");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date2);
    }
}

System类

System系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的

方法名	说明
static void arraycopy(...);	复制数组
static long currentTimeMillies();	获取当前系统时间,返回的是毫秒值
static void gc();	建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status);	退出JVM,如果参数是0表示正常退出JVM,非0表示异常退出JVM

public class Demo01 {
    public static void main(String[] args) {
        //1.arrayCopy:数组的复制;
        //src:源数组
        //srcPos:从哪个位置开始复制
        //dest:目标数组
        //destPos:目标数组的位置
        //length:复制的长度
        int arr[] = {1,2,3,4,5,6,7,8,9};
        int[] dest = new int[9];
        System.arraycopy(arr,5,dest,3,3);
        for (int i = 0;i<dest.length;i++){
            System.out.println(dest[i]);
        }

        //2.currentTimeMillies:获取毫秒数
        System.out.println(System.currentTimeMillis());

        long start = System.currentTimeMillis();
        int result = 0;
        for (int i = 0; i < 999; i++) {
            result +=i;
        }
        System.out.println(result);
        long end = System.currentTimeMillis();
        System.out.println("用时:"+(end-start));

        //3.System.gc():告诉垃圾回收器回收垃圾
        new Student("aaa",21);
        new Student("bbb",22);
        new Student("ccc",23);
        System.gc();

        //4.exit:退出JVM
        System.exit(0);
        System.out.println("程序结束啦...");
    }
}

标签：常用,Java,String,System,println,new,public,out
From： https://www.cnblogs.com/gy486926/p/17563940.html