常用类

内部类

什么是内部类:在一个类的内部在定义一个完整的类
特点:

编译之后可生成独立的字节码文件
内部类可以直接访问外部类的私有成员,而不破坏封装.
可谓外部类提供必要的内部功能组件.

package Class;
//身体
public class Body {
	//头部
	class Header{	
	}
}

1.成员内部类

在类的内部定义,与实例变量、实例方法同级别的类。
外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象.
- Outer outer = new Outer();
- Inner inner = new.outer Inner();
当外部类、内部类出现重名属性时，会优先访问内部类属性。
成员内部类不能定义静态成员.但是可以包含静态常量.

package Class;

public class Outer {
    //实例变量
    private String name = "张三";
    private int age = 30;
    //内部类
    class Inner{
        private String adderss = "北京";
        private String phone = "110";
        //方法
        public void show(){
            //打印外部类
            System.out.println(name);
            System.out.println(age);
            //打印内部类
            System.out.println(adderss);
            System.out.println(phone);
        }
    }
}

package Class;

import Class.Outer.Inner;

public class TestOuter {
    public static void main(String[] args){
        //创建外部类
        Outer outer = new Outer();
        //创建内部类
        Inner inner = outer.new Inner();
        //一步到位: Inner inner =  new Outer().new Inner();
        inner.show();
    }

}

注意:当外部类和内部类出现重名现象时,优先显示内部类.

如何打印外部类的属性呢:加上类.this.name

2.静态内部类

不依赖外部类对象,可直接创建或通过类名访问,可声明静态内部成员
只能直接访问外部类的静态成员(实例成员需要实例化外部类对象)
- Outer.Inner inner = new Outer.Inner();
- Outer.Inner.shou();

package Class01;

public class Outer {
    private  String name = "xxx";
    private int age = 18;
    //静态内部类:和外部类相同
    static class Inner{
         private String adderss = "上海";
         private String phone = "111";
         //静态成员
        private static int count = 100;
        public void show(){
            //如何调用外部类属性
            //1.创建外部了对象
            Outer outer = new Outer();
            //2.在调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //调用静态内部类的属性和方法
            System.out.println(adderss);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println();
        }
    }
}

package Class01;

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

3.局部内部类

定义在外部类方法中,作用范围和创建对象范围仅限于当前方法.
局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final.
限制类的使用范围.

package Class02;

public class Outer {
    private String name = "小红";
    private int age = 35;

    public void show(){
        //定义局部变量
        String address = "深圳";

        //局部内部:注意不能家任何访问的修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "128739827198";
            private  String email = "sdoaj@163.com";
            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);
                //访问局部变量,jdk1.7要求:变量必须是常量.jdk1.8后会自动添加final
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

package Class02;

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

4.匿名内部类

没有类名的局部内部类(一切特征都与局部内部类相同).
必须继承一个父类或者实现一个接口.
定义类、实现类、创建对象的语法合并、只能创建一个该类的对象。
优点:减速代理.
缺点:可读性较差.
创建一个接口

package Class03;

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

创建一个Mouse

package Class03;

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

}

创建一个测试

package Class03;

public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量
/*        Usb usb = new Mouse();
        usb.service();*/
        //局部内部类
//        class Fan implements Usb{
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功,风扇开始工作...");
//            }
//        }
//        //使用局部内部类创建对象
//        Usb usb = new Fan();
//        usb.service();
        //使用匿名内部类优化(相当于创建了一个局部内部类)
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("连接电脑成功,风扇开始工作...");
            }
        };
        usb.service();
    }
}

Object类

超类、基类，所有类的直接或间接父类，位于继承书的最顶层。
任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承.
Object类中所定义的方法,是所有对象都具备的方法.
Object类型可以存储任何对象
- 作为参数,可接受任何对象.
- 作为返回值,可以返回任何对象.

1.getClass()方法

public final Class<?> getClass(){};
返回引用中存储的实际对象类型.
应用:通常用于判断两个引用中实际存储对象是否一致.

2.hashCode()方法

public int hashCode(){};
返回该对象的哈希码值.
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值.
一般情况下相同对象返回相同哈希码.

3.toString()方法

public String toString(){};
返回该对象的字符串表示(表现形式).
可以根据程序需求覆盖该方法,如:展示对象各个属性值.

toString() 方法用于返回以一个字符串表示的 Number 对象值。
如果方法使用了原生的数据类型作为参数，返回原生数据类型的 String 对象值。
如果方法有两个参数，返回用第二个参数指定基数表示的第一个参数的字符串表示形式。

toString需要进行重写

重写:需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表列表必须相同
3.修饰符:范围可以扩大: public>protected>default>private
4.抛出异常:范围,可以被缩小,但不能扩大;classnotfoundexception - - >exception(大)
重写,子类和父类的方法必要一致:方法体不同!
为什么要重写:
1.父类的功能,子类不一定需要,或者比一定满足
alt+insert:override

4.equals()方法

public boolean equals(Object obj){}
默认实现为(this==obj),比较两个对象地址是否相同.
可进行覆盖,比较两个对象的内容是否相同.

equals()方法覆盖步骤

比较两个引用是否指向同一个对象
判断obj是否为null
判断两个引用指向的实际对象类型是否一致
强制转换类型
依次比较各个属性值是否相同
Object方法的代码总和

package Class04;

import java.util.Objects;

public class Student extends Object{
    private String name;
    private int age;
    public Student(){
    };
    public Student(String name, int age) {
        super();
        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;
    }

    @Override
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
    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;
        }

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

package Class04;

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

        //4.equals方法,判断两个对象是否相等
        System.out.println("-------------------4equals--------");
        System.out.println(s1.equals(s2));

        Student s4 = new Student("小明", 17);
        Student s5 = new Student("小明", 17);
        System.out.println(s4.equals(s5));

    }
}

package Class04;

public class TestStudent2 {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 20);
        Student s3 = new Student("ccc", 20);
        Student s4 = new Student("ddd", 20);
        Student s5 = new Student("eee", 20);
//        new Student("aaa", 20);
//        new Student("bbb", 20);
//        new Student("ccc", 20);
//        new Student("ddd", 20);
//        new Student("eee", 20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");

    }
}

5.finalize()方法

当对象被判定垃圾对象.
垃圾回收:由GC销毁垃圾对象,释放数据存为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
垃圾对象:没有有效引用指向此对象时,为储空间.
自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象.
手动回收机制:使用System.gc();>通知JVM执行垃圾回收.(只是告诉垃圾回收机进行回收,是否回收还是看JVM.)

package Class04;

public class TestStudent2 {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 20);
        Student s3 = new Student("ccc", 20);
        Student s4 = new Student("ddd", 20);
        Student s5 = new Student("eee", 20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");

    }
}

package Class04;

public class TestStudent2 {
    public static void main(String[] args) {
        new Student("aaa", 20);
        new Student("bbb", 20);
        new Student("ccc", 20);
        new Student("ddd", 20);
        new Student("eee", 20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");

    }
}

包装类

什么是包装类:基本类型数据类型所对应的引用数据类型.
Object可统一所有数据,包装类的默认值是null.

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

1.类型转换与装箱、拆箱

8种包装类提供不同类型间的转换方式:
- Number父类中提供的6个共性方法.
- paresexxx()静态方法.
- valueof()静态方法.
注意:需保证类型的兼容,否则抛出NumberFormatException

package Class05;

public class Demo01 {
    public static void main(String[] args) {
        int num = 10;
        //类型转换:装箱,基本类型转成引用类型的过程
        //基本类型
        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);
        //类转换:拆箱,引用类型转成基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);
        //jdk1.5以前使用这种装箱和拆箱.jdk1.5之后,提供自动装箱和拆箱
        int age  = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
        System.out.println("----基本类型和字符串之间的转换----");
        //基本类型和字符串之间的转换
        //1基本类型转成字符串
        int n1 = 100;
        //1.1使用+号
        String s1 = n1+"";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1,16);//把n1转成16进制
        System.out.println(s1);
        System.out.println(s2);

        //2字符串转成基本类型
        String str = "150";
        //使用Integer.persexxx()
        int n2 = Integer.parseInt(str);
        System.out.println(n2);


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

整数缓冲区

Java预先创建了256个常用的整数包装类型对象
在实际应用当中,对已创建的对象进行复用.

Integer缓冲区

package Class05;

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);

        Integer integer3 = Integer.valueOf(100);//自动装箱  Integer.valueOf()
        Integer integer4 = Integer.valueOf(100);
        System.out.println(integer3==integer4);//true

        Integer integer5 = 200;//自动装箱  Integer.valueOf()
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//false
        /*为什么s3=s4,但是s5!=s6呢,因为
        *     public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    * 创建了一个数组,从-128~127，当数值大于了127就会重新创建一个新的空间，所以他们的栈空间不一样*/
    }
}

String类

字符串是常量,创建之后不可改变.
字符串字面值存储在字符串池中,可以共享.
String s = "Hello";产生两个对象.堆、池各存储一个

Strin的常用方法

public int length():返回字符串的长度.
public char charAt(int index):根据下标获取字符.
public boolean contains(String str):判断当前字符串中是否包含str.
public char[] toCharArray();将字符串转换成数组.
public int indexOf(String str):查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1
public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引.
public String trim():去掉字符串前后的空格.
public String toUpperCase();将小写转成大写.
public boolean endWith(String str);判断字符是否是以str结尾.
public String replace (char oldChar,char newChar);将旧字符串替换成新字符串
public String[] split(String str):根据str做拆分.

package Class05;

import java.util.Arrays;
import java.util.Locale;

public class Demo03 {
    public static void main(String[] args) {
        String name = "hello";//"hello" 常量存储在字符串池中,
        name = "zhangshan";//"zhangsan"赋值给name变量,给字符串赋值时,并没有修改数据,而是重新开辟一个空间
        String name2 = "zhangshan";

        //演示字符串的另一种创建方式
        String str = new String("java");
        String str2 = new String("java");
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//true  比较两个值用equals
        System.out.println("----字符串方法的使用1----");
        //字符串方法的使用
        //1.length();返回字符串的长度
        //2.charAt(int index);返回某个位置的字符
        //3.contains(String str);判断是否包含某个子字符串
        String content = "java是世界上最好的编程语言java,java真香";
        System.out.println(content.length());
        System.out.println(content.charAt(content.length()-1));
        System.out.println(content.contains("java"));
        System.out.println(content.contains("php"));
        System.out.println("----字符串方法的使用2----");
        //字符串方法的使用
        //4.toCharArray();返回字符串对应的数量
        //5.indexOf();返回子字符串首次出现的位置
        //6.lastIndexOf();返回字符串中最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java",4));
        System.out.println(content.lastIndexOf("java"));
        System.out.println("----字符串方法的使用3----");
        //7.trim();去掉字符串前后的空格
        //8.toUpperCase();把小写转成大写.toLowerCase();把大写转成小写
        //9.endWith(str);判断是否已str结尾,startWith(str);潘杜建是否已str结尾
        String content2 = "    hello worle   ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.toLowerCase());
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));
        System.out.println("----字符串方法的使用4----");
        //10.replace(char old,char new);用新的字符或字符串替换旧的字符或字符串
        //11.split();对字符串进行拆分

        System.out.println(content.replace("java","pho"));
        String say = "java is the best programing language";
        String[] arr = say.split("");//[ ,]可以使用空格和逗号分割
        System.out.println(arr.length);
        for (String string:arr){
            System.out.println(string);
        }
        //补充两个方法equals、compare（）；比较大小
        System.out.println("----补充---");
        String s1 = "hello";
        String s2 = "Hello";
        System.out.println(s1.equalsIgnoreCase(s2));//不区分大小写比较

        String s3 = "abc";
        String s4 = "xyz";
        System.out.println(s3.compareTo(s4));//从第一个字开始比较

        String s5 = "abc";
        String s6 = "abcxyz";
        System.out.println(s5.compareTo(s6));//不在事比较位置,而是比较长度
    }
}

String方法的案例演示

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

package Class05;

public class Demo04 {
    /*. 需求:
已知String str = "this is a text";
  1.将str中的单词单独获取出来
  2.将str中的text替换为practice
  3.在text前面插入一个easy
  4将每个单词的首字母改为大写
*/
    public static void main(String[] args) {
        String str = "this is a text";
        //1.将str中的单词单独获取出来
        String[] arr = str.split(" ");
        System.out.println("----1.将str中的单词单独获取出来----");
        for (String s:arr){
            System.out.println(s);
        }
        //2.将str中的text替换为practice
        System.out.println("--2.将str中的text替换为practice--");
        String str2 = str.replace("text","practice");
        System.out.println(str2);
        //3.在text前面插入一个easy
        System.out.println("--3.在text前面插入一个easy--");
        String str3 = str.replace("text","easy text");
        System.out.println(str3);
        //4.将每个单词的首字母改为大写
        System.out.println("--4.将每个单词的首字母改为大写--");
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            //把第一个字符转成大写
            char uppfirst = Character.toUpperCase(first);
            String news = uppfirst+arr[i].substring(1);
            System.out.println(news);
        }

    }
}

可变字符串

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

package Class05;
/*StringBuffer和StringBuilder的使用
* 和String区别(1)效率比String高(2)比String节省内存
*/
public class Demo05 {
    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());
        sb.append("java不错");
        System.out.println(sb.toString());
        //2.insert();添加
        sb.insert(0,"我在最前面");
        //3replace();
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());
        //4delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());
        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.toString());
    }
}

验证StringBuilder效率高于String

package Class05;
public class Test05 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
        String string = "";
        for (int i = 0; i < 9999; i++) {
            string+=i;
        }
        System.out.println(string);
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("用时"+(end-start));
    }
}

package Class05;
public class Test05 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 999999; i++) {
            sb.append(i);
        }
        System.out.println(sb);
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("用时"+(end-start));
    }
}

BigDecimal

位置:java.math包中.
作用:精确计算浮点数.
创建方式:BigDecimal bd = new BigDecimal("1.0");
方法:
- BigDecimal add(BigDecimal bd) 加
- BigDecimal substract(BigDecimal bd) 减
- BigDecimal multiply(BigDecimal bd) 乘
- BigDecimal divide(BigDecimal bd) 除

除法:divide(BigDecimal bd,int scal,RoundingMode mode)
参数scal:指定精确到小数点后几位
参数mode:指定小数部分的取舍模式,通常采用四舍五入的模式,取值为BigDecimal.ROUND_HALF_UP

package Class05;

import java.math.BigDecimal;

public class Demo06 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);
        //BigDecimal,大的浮点数精确计算
        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);
        //除法
        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);//ROUND_HALF_UP四舍五入
        System.out.println(r5);
    }
}

Date

Date表示特定的瞬间,精确到毫秒.Date类中的大部分方法都已经被Calendar类中的方法所取代.
时间单位:
- 1秒=1000毫秒
- 1毫秒=1000微秒
- 1微秒=1000纳秒

package Class05;

import java.util.Date;

public class Date1 {
    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);
        System.out.println(date2.toString());
        //方法after before
        boolean d1 = date1.after(date2);
        System.out.println(d1);
        boolean d2 = date2.before(date1);
        System.out.println(d2);

        //比较compareTo();
        int d3 = date1.compareTo(date2);
        System.out.println(d3);
        //比较是否相等equals();
        boolean d4 = date1.equals(date2);
        System.out.println(d4);
    }
}

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 filed)	返回给定日历字段的值。字段比如年、月、日等
void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
Date getTime	返回一个Date表示此日历的时间。Calendar-Date
void add(int filed,int amount)	按照日历的规则,给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

package Class05;

import java.util.Calendar;

public class Calendar01 {
    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_OF_DAY);//HOUR12小时;HOUR_OF_DAY24小时
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+month+"月"+day+"日"+hour+":"+minute+":"+second);
        //修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar2.getTime().toLocaleString());

        //4add方法修改时间
        calendar2.add(Calendar.HOUR,2);
        System.out.println(calendar2.getTime().toLocaleString());

        //5补充方法
        calendar2.add(Calendar.MONTH,1);
        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

package Class05;

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

public class SimpleDateFormat01 {
    public static void main(String[] args) throws ParseException {
        //1.创建SimpleDateFormat对象y:年 M:月
//      SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        //2.创建一个Date
        Date date = new Date();
        //格式化date(把日期转成字符串)
        String str = sdf.format(date);//format格式化
        System.out.println(str);
        //解析(把字符串转成日期)
        Date date1 = sdf.parse("1990年05月01日");//和上面的格式必须保持一致
        System.out.println(date1);

    }
}

System类

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

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

package Class05;

public class System01 {
    public static void main(String[] args) {
        //arraycopy进行数组的复制
        //src,源数组
        //srcPos:从哪个位置开始复制
        //dest:目标数组
        //destPos:目标数组的位置
        //length:复制的长度
        int[] arr = {20,18,15,8,35,26,45,90};
        int[] dest = new int[8];
        //1复制数组
        System.arraycopy(arr,4,dest,4,4);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
        System.out.println(System.currentTimeMillis());
        long start = System.currentTimeMillis();
        for (int i = -999999999; i < 99999999; i++) {
            for (int j = -999999999; j < 99999999; j++) {
                int result = i+j;
            }
        }
        //3获取毫秒数
        long end = System.currentTimeMillis();
        System.out.println("用时"+(end-start));

        //System.gc();告诉垃圾回收站进行回收
        Student s1 = new Student("aaa", 19);
        Student s2 = new Student("bbb", 19);
        Student s3 = new Student("ccc", 19);
        //3回收垃圾
        System.gc();
        
        //4退出jvm
        System.exit(0);
        System.out.println("程序结束了...");
    }
}

posted @ 2021-11-18 22:50 freedomAndWind 阅读(16) 评论(0) 编辑收藏举报

刷新页面返回顶部

林江plus

常用类

内部类