📂java
🔖java
2021-11-18 22:50阅读: 15评论: 0推荐: 0

常用类

内部类

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

  • 编译之后可生成独立的字节码文件
  • 内部类可以直接访问外部类的私有成员,而不破坏封装.
  • 可谓外部类提供必要的内部功能组件.
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("程序结束了...");
    }
}

本文作者:freedomAndWind

本文链接:https://www.cnblogs.com/linjiangplus/p/15564163.html

版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   freedomAndWind  阅读(15)  评论(0编辑  收藏  举报
编辑推荐:
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列:如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列:如何用 C#调用 C方法造成内存泄露
阅读排行:
· 震惊!C++程序真的从main开始吗?99%的程序员都答错了
· 别再用vector<bool>了!Google高级工程师:这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码?零基础破解AI编程运行原理
· 上周热点回顾(3.3-3.9)
点击右上角即可分享
微信分享提示
评论
收藏
关注
推荐
深色
回顶
收起
  1. 1 Meet Fi9江澈,果妹
Meet - Fi9江澈,果妹
00:00 / 00:00
An audio error has occurred.

作词 : Fi9江澈

作曲 : Fi9江澈

她不是很瘦 她的个子也够不高

她不是很瘦 她的个子也够不高

她有时很逗 有时候 她也够SAO

每次她化完妆盯着问我 我会说她很丑

但每次离开的时候 我们互相 谁都不肯走

她爱吃粉丝的醋 也爱跟我 生气

她做傻事的时候 也都是和我会有争议

她不化妆的时候 我会刻意的说她很漂亮

总爱素颜的时候 去和别的女生去较量

她喜欢我性格的好 和行为上的屌丝

喜欢我的城市还有运河街道边的小吃

她有时很任性 莫名的跟我吵架

每次她耍小性子 也都会被我都一顿的好骂

她叫我玩游戏 我总故意不跟她玩

每次吵架的时候 总骂我是个渣男

她会讨好我爸妈 也会买礼物给悄悄

每次 卖萌 我也心领神会的笑笑

HOOK:街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

她一直都很敏感 总是常常怕我失去

她不知道 在我心里 她是我写下的诗句

她会在心情不好的时候 跟朋友去酗酒

大醉之后会说以后的路 她会陪着我去走

总爱问我分手了 会不会像以前 那样去对她

提些奇怪的问题 手机屏保为什不是她

说我对你这么好 你竟然想要跟我分手

哎 这个贱男人 我就知道 你可真狗

这个不可理喻的女人让我又爱又恨

生病的时候让人心疼 看起来又乖又笨

就算吵架的时候 不爱跟你讲道理

在人群中我依然 一眼就能找到你

我可以为 她遮风为她挡雨

也可以陪她一整天 依偎在我房里

还记得第一次见她 是我 第一次的演出

还记得她也曾在 夜里 为我闭着眼哭

HOOK:街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

混音:Fi9江澈

混音:Fi9江澈

统筹:杨冰

OP:汇音文化