java基础-常用类

以下为本人的学习笔记

 

1、内部类

• 分类：

  1.内部类：成员内部类，静态内部类， 局部内部类（定义在方法内部），匿名内部类

• 概念：在一个类的内部再定义一个完整的类（类中类）

• 特点：

1. 编译之后可生成独立的字节码文件；

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

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

public class Body{
    private String name;
    //内部类
    class Header{
        public void show(){
            //访问外部类私有成员
        System.out.println(name)
        }
    }
}

 

1.1成员内部类

  1.在类的内部定义，与实例变量、示例方法同级别的类；

  2.外部类的一个实例部分，创建内部类对象时，必须先创建外部类对象：

• Outer out = new Outer();
• out.Inner in = out.new Inner();

  3.当外部类、内部类存在重名属性时，会优先访问内部类属性；

  4.成员内部类不能定义静态成员，但是能定义静态常量。

示例：

public class Outer{
    private String name="张三";
    private int age = 20;
    
    //内部类 
    class Inner{
        private String address = "北京";
        private String phone="110";
        private String name = "李四";
        
        //方法
        public void show(){
            //打印外部类的属性，内部类属性和外部类的属性名字相同(重名时)：Outer.this
            System.out.println(Outer.this.name);
            System.out.println(age);
            
            //打印内部类中的属性
            System.out.println(this.address);
            System.out.println(phone);
        }
    
    }
}
​
public class TestOuter{
    public static void main(String [] agrs){
        //1创建外部类对象
  //      Outer outer = new Outer();
        //2创建内部类对象，要加外部类对象前缀
  //      outer.Inner inner = outer.new Inner()
            
          //1,2合并为一句
        Inner inner = new Outer().new Inner();
        inner.show();
    }
}

 

1.2静态内部类

(静态内部类，在内部类基础上加static,级别相当于外部类，给外部类使用)

  1.不依赖（先创建）外部类对象，可直接创建或通过类名访问

  2.可声明静态成员

  3.只能直接访问外部类的静态成员（实例成员需实例化外部类对象）

• Outer.Inner inner = new Outer.Inner();
• Outer.Inner.show();

示例：

public class Outer {
​
    private String name ="小米";
    private int age = 19;
​
    //静态内部类
    static class Inner{
        private String name = "计缘";
        private int age =11;
        static private String address = "广东";
        public void show(){
            //1.调用外部类的属性，先创建外部类对象，因为静态内部类与外部类属于同一级别
            Outer outer = new Outer();
            //2.调用外部类的属性
            System.out.println(outer.name);
            //3.调用静态内部类的属性
            System.out.println(name);
            //4.调用静态内部类的静态属性，类名.属性名
            System.out.println(Inner.address);
        }
​
​
    }
}
//测试
public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}
​

 

1.3局部内部类

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

   • 局部内部类前缀不能加任何访问修饰符（如，public，protect...),作用范围在方法里

   • 局部内部类和局部变量属于同一级别

   • 静态方法不能访问非静态的成员，因为静态属性是类的属性，不是单个成员的属性

   • 局部内部类不能定义静态变量，但可以定义静态常量

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

3. 限制类的使用范围。

局部内部类访问局部变量：

• 访问局部变量,JDK1.7要求变量是常量final，JDK1.8会自动为局部变量添加final；

• 因为局部变量在方法完成后会消失，但是局部内部类不会消失，可是局部内部类会使用到一个将要消失的局部变量？所以要让局部变量为常量。

public class Outer {
​
    private String name = "计缘";
    private int age = 42;
​
    public void show(){
        String address = "广东";
        class Inner{
            private String name = "尹兆先";
            private int age = 43;
​
            public void show2(){
                //访问外部类的属性，Outer.this可省略
                System.out.println(Outer.this.name);
                System.out.println(age);
​
                //访问内部类的属性
                System.out.println(name);
                //访问局部变量,JDK1.7要求变量是常量final，JDK1.8会自动为局部变量添加final
                System.out.println(address);
            }
        }
        //不能在main方法里创建局部内部类对象，
        // 在main方法里调用外部类的show方法是不能调用局部内部类的，因为
        // 上面只做了声明，没有调用。
        // 要调用局部内部类的方法要在上一级方法（跟局部内部类同一级上）创建局部内部类对象并调用方法
        Inner inner = new Inner();
        inner.show2();
    }
}
​
​
//测试
public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}
​

 

1.4匿名内部类

1. 没有类名的局部内部类（一切特征都与局部内部类相同）；

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

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

• 优点：减少代码量；

• 缺点：可读性较差。

示例：

public interface Usb {
    public void service();
}
​
​
public class Mouse implements Usb{
​
    public void service(){
        System.out.println("鼠标正在工作中...");
    }
}
​
​
public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量,多态
//        Usb usb = new Mouse();
//        usb.service();
​
        //局部内部类，main方法也是方法里
//        class Fan implements Usb{
//
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功，风扇开始工作...");
//            }
//        }
//
//        //使用局部内部类创建对象
//         Usb usb = new Fan();
//          usb.service();
//
​
        //使用匿名内部类优化(相当于创建了一个局部内部类)
        Usb usb = new Usb(){//第二个Usb位置可以是接口，抽象类，父类，在方法体里可以重写方法
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作...");
            }
        };
        usb.service();
    }
}
​

 

2、Object类

1. 超类、基类，所有类的直接或间接父类，位于继承树的最顶层；
2. 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承；
3. Object类中所调用的方法，是所有对象都基本的方法；
4. Object类型可以存储任何对象

• 作为参数，可接收任何对象。
• 作为返回值，可返回任何对象。

3、Object类常用方法

3.1getClass()方法

public final Class<?> 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) {
        Student s1 = new Student("居元子",999);
        Student s2 = new Student("魏元生",6);
​
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
​
    }
}
​ 

3.2hashCode()方法

public int hashCode(){}
返回该对象的哈希码值；
哈希值根据对象的地址或字符串或数字使用hash算法（系统底层提供）计算出来的int类型的数值；
一般情况下相同对象返回相同哈希码。
示例：

  Student s1 = new Student("居元子",999);
        Student s2 = new Student("魏元生",6);
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());//s1.hashCode()!=s2.hashCode()
        Student s3 = s1;
        System.out.println(s3.hashCode());//s1.hashCode()=s3.hashCode()

 

3.3 toString()方法

public String toStrin(){};
返回该对象的字符串表示；
可以根据程序需求覆盖该方法，如：展示对象各个属性的值。

     System.out.println(s1.toString());
     System.out.println(s2.toString());//输出：默认名字+返回哈希值的十六进制

重写toString：

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

 

3.4equals()方法

public boolean equals （Object obj）{}
默认(源码)实现为（this == obj）[比较两个对象是否相同]，比较两个对象地址是否相同；
可进行覆盖（重写后），比较两个对象的内容是否相同
equals是Object类的方法，默认为比较地址，跟'=='一样，String类中重写equals方法，比较的是值。

  //判断两个对象是否相等
        System.out.println(s1.equals(s2));//false
        Student s6 = new Student("小米", 12);
        Student s7 = new Student("小米", 12);
        System.out.println(s6.equals(s7));//false

 
String类里，覆盖（重写）equals()方法的步骤：

1. 比较两个引用是否指向同一个对象；
2. 判断obj是否为null；
3. 判断两个引用指向的实际对象类型是否一致；
4. 强制类型转换；
5. 依次比较各个属性值是否相同。

//Student类里  
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;
    }

tips： instanceof比较的是前面的实际类型是不是后面对象实际类型的子类或同类，是的话返回true，否则返回false，所以true的情况下要强制转换为同类

 

3.5finalize（）方法

finalize：译：最终确定，把(计划、旅行、项目等)最后定下来;定案

1. 当对象被判定为垃圾对象时，有JVM自动调用此方法，用以标记垃圾对象，进入回收队列；
2. 垃圾对象：没有 有效引用（没有被赋予变量等） 指向此对象时，为垃圾对象；
3. 垃圾回收：由GC销毁垃圾对象，释放数据存储空间；
4. 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象；
5. 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。（说是手动，其实还是JVM自动回收，只不过是被人为的告诉JVM一声）。

//Student类里
 protected void finalize() throws Throwable{
        System.out.println(this.name+"对象被回收了...");
    }
    
//TestStudent类里
     new Student("aaa",32);
        new Student("bbb",32);
        new Student("ccc",32);
        new Student("ddd",32);
        new Student("eee",32);
        System.gc();
        System.out.println("回收垃圾");

4.包装类

1. 基本数据类型所对应的引用数据类型；
2. Object可统一所有数据，包装类的默认值是null；
3. 包装类对应：

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

如：Byte类将基本类型byte的值包装在一个对象中。一个Byte类型的对象只包含一个类型为byte的字段。即把原来放栈里的byte数据放到堆里。

• 基本类型数据存储在栈空间，且栈里面存对象的引用地址
• 引用类型数据存储在堆空间，堆里面存对象

效果图：

 

4.1、类型转换与装箱、拆箱

装箱：把基本数据类型转换成引用数据类型的过程，即把栈里面的值放到堆里面。
拆箱：把引用数据类型转换成基本数据类型的过程，即把堆里面的对象放到栈里面。

//JDK1.5之前的办法：
//基本类型
int num1 = 18;
//装箱
//法一：使用Integer类创建对象
Integer integer1 = new Integer(num1);
//法二：使用valueof（）方法创建对象
Integer integer2 = Integer.valueOf(num1);
​
//拆箱
Integer integer3 = new Integer(100);
//使用Number里的intValue（）方法。
int num2 = integer3.intValue();
​
//JDK1.5之后，提供自动装箱和拆箱
int age = 30;
//自动装箱    直接给Integer引用类型变量赋予int类型值，背后编译器自动将age转换为Integer.valueOf(age);
Integer integer4 = age;
//自动拆箱  背后编译器自动将integer4转换为Integer4.intValue();
int age2 = integer4

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

• Number父类中提供的6个共性方法
• 包装类名.parseXXX()静态方法
• valueOf()静态方法

注意：需保证类型兼容，否则抛出NumberFormatException异常

//基本类型和字符串之间转换
​
//1基本类型转换成字符串
int n1 = 100；
//1.1使用+号
String s1 = n1+"";//s1=100 ,100后有空格字符
//1.2使用Integer的toString（）方法
String s2 = Integer.toString(n1)//s2 = 100
//toString重载方法
//String s2 = Integer.2toString(n1,16);//第二个参数数字表示多少进制
​
//2字符串转成基本类型
String str = "150";
//使用Integer.parseXX();
int n2 = Integer.parseInt(str);//str不能包含除数字的其他字符
​
//boolean字符串形式转成基本类型
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);//输出结果："true"---->true 非"true"---->false

 

4.2整数缓冲区

• Java预先创建了256个常用的整数包装类型对象；
• 在实际应用中，对创建的对象进行复用

Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(s1 == s2 );//false
​
Integer integer3 = 100;//自动装箱使用Integer.valueOf(100),而Integer.valueOf里规定了一个缓存区，-128到127的缓存数组（256个对象），要赋值时先在这个数组里找已存在的对象
Integer integer4 = 100;//integer4指向的对象是缓存区已有的100对象,即integer3指向的那个对象。
System.out.println(s3 == s4 );//true   
​
Integer integer5 = 200;//自动装箱使用Integer.valueOf(100),200>127,所以不能使用缓存数组。直接在堆new Integer（200）
Integer integer6 = 200;
System.out.println(s5 == s6 );//false

注意：

 Integer a = new Integer(10);
 Integer b = new Integer(10);
 Integer c = new Integer(11);
 Integer d = 11;
 Integer e = 11;
 int f =10;
 System.out.println(a==b);//false，因为==比较的是内存地址，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）
 System.out.println(c==d);//false，非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，
                           // 而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）
 System.out.println(d==e);//true对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false
 System.out.println(b==f);//true因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较

5.String类

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

字符串字面值存储在字符串池（或叫常量池）中，可以共享（重用）

String s = "Hello";产生一个对象，字符串池中存储；

String s = new String ();产生两个对象，堆，池各存储一个。

注：方法区在JDK1.8之后叫元空间，JDK1.8之前叫永久代

//面试题
String name = "hello"; //"hello" 常量存储在字符串池中
name = "zhangsan";//”zhangsan"赋值给name变量，给字符串赋值时，没有修改数据，而是重新开辟一个空间，这就是不可变性
String name2 = "zhangsan";
​
//字符串的另一种创建方式
String str = new String("java");//在堆创建一个对象"java"，在字符串池也会有一个“java”，浪费空间
String str2 = new String("java");
System.out.println(str==str2);//false
System.out.println(str.equals(str2));//true

 

 

5.1常用方法

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

//字符串方法的使用
//length();返回字符串的长度
//2.charAt(int index);返回某个位置的字符
//3.contains(String str);判断是否包含某个子字符串
​
String content = "java是世界上最好的,java真香";
system.out.println(content.length());//输出：11
system.out.println(content.charAt(content.length()-1));//输出‘的’
system.out.println(content.contains("java"));//true
system.out.println(content.contains("php"));//false
​
//字符串方法的使用
//4.toCharArray():返回字符串对应的数组
//5.indexOf();返回字符串首次出现的位置
//6.lastIndexOf();返回字符串最后一次出现的位置
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java"));//输出：0
System.out.println(content.indexOf("java",4));//从下标4往后找
System.out.println(content.lastIndexOf("java"));//输出：18
​
​
//字符串方法的使用
//7.trim()；去掉字符串前后的空格
//8.toUpperCase();把小写转成大写，toLowerCase();把大写转成小写
//9.endsWith(String str)；判断是否以str结尾，starsWith(String str)；判断是否以str开头
String content2 = "  Hello world  ";
System.out.println(content2.trim());//输出：Hello world
System.out.println(content2.toUpperCase());//输出：HELLO WORLD
System.out.println(content2.toLowerCase());//输出：hello world
​
String fileName = "hello.java";
System.out.println(fileName.endsWith(".java"));
System.out.println(fileName.startsWith("hello"));
​
//字符串方法的使用
//10.replace(char old,char new);用新的字符或字符串替换旧的字符或字符串
//11.split();对字符串进行拆分
System.out.println(content.replace("java","php"));
​
String say = "java is the best programing language";
String[] arr = say.split(" ");
//正则表达式，[],[ ,]→以空格或逗号划分
//String[] arr = say.split("[ ,]+");
System.out.println(arr.length);//6
for(String string : arr ){
    System.out.println(string);
}
​
//补充两个方法equals,compare();比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equalsIgnoreCase(s2));//equalsIgnoreCase()忽略大小写比较
​
String s3 = "abc";//a编号97
String s4 = "xyz";//x编号120
System.out.println(s3.compareTo(s4));//s3编号位置减s4编号位置，输出：-23；当s3,s4长度不等时，compareTo比较的是长度，s3的长度减s4的长度
​
//截取字符串
//字符串.substring(int beginIndex)
//字符串.substring(int beginIndex, int endIndex)

 

5.2可变字符串

StringBuffer→（提前开辟缓存区）:可变长字符串，JDK1.0提供，运行效率慢、线程安全。
StringBuilder→（单线程可用）:可变长字符串，JDK5.0提供，运行效率快、线程不安全。
两者与String区别：

• 效率比String高，比String节省内存

StringBuilder功能同StringBuffer一样：

StringBuffer sb = new StringBuffer();
//1.append();追加
sb.append("阿珍爱上");
System.out.println(sb.toString());//输出：阿珍爱上
sb.append("阿强！");
System.out.println(sb.toString());//输出：阿珍爱上阿强！
​
//2.insert();添加，可以在指定位置添加
sb.insert(0,"我发现")//第一个参数表示添加位置
System.out.println(sb.toString());//输出：我发现阿珍爱上阿强！
​
​
//3.replace();String的replace()只能新值替换旧值，这里的replace可以指定位置
sb.replace(3,5,"晓晓")//3到5的位置，不含5，即含头不含尾，以0为开始。
System.out.println(sb.toString());//输出：我发现晓晓爱上阿强！
​
​
//4.delete();删除,
sb.delete(0.5)//位置同一含头不含尾
System.out.println(sb.toString())
    
//清空
sb.delete(0,sb.length());
System.out.println(sb.toString())

测试：StringBuilder效率比String高

public class test5 {
    public static void main(String[] args) {
​
       long start = System.currentTimeMillis();
        String sb = " ";
        for (int i = 0; i<99999;i++){
            sb+=i;
        }
        System.out.println(sb);
        long end = System.currentTimeMillis();
        System.out.println("String用时："+(end - start));//用时：21557毫秒
​
        long start2 = System.currentTimeMillis();
        StringBuilder sb2 = new StringBuilder(" ");
        for (int i = 0; i<99999;i++){
            sb2.append(i);
        }
        System.out.println(sb2.toString());
        long end2 = System.currentTimeMillis();
        System.out.println("StringBuilder用时:"+(end2-start2));//用时：125毫秒
    }
}

6.BigDecimal类(精确存储)

思考：一下程序输出结果是多少？

public class TestBigDecimal{
public static void main(String[] args){
double d1 = 1.0;
double d2 = 0.9:
System.out.println(d1-d2);

//面试题
double result=(1.4-0.5)/0.9;
System.out.println(result);//0.9999999999999999
}
}

结果→1？错，结果为0.9999999999999998
（double和float存的是近似值，比如存1，但实际存的是0.9999999999999999）
很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，需要借助BigDecimal。
位置：java.math包中
作用；精确计算浮点数
创建方式：BigDecimal db = new BigDecimal("1.0");//构造方法的参数一定用字符串，如果是用1.0的话，你传进去就会有精度缺失，就不是1.0了，而可能是0.9999.....
方法：
加法: BigDecimal add( BigDecimal bd)
减法: BigDecimal subtract( BigDecimal bd)
乘法: BigDecimal divide( BigDecimal bd)
除法: BigDecimal multiply( BigDecimal bd)
当除不尽时使用重载方法：
除法：divide（BigDecimal bd, int scal,RoundingMode mod)
参数scale：指定精确到小数点后几位
参数mode：

• 指定小数部分的取舍模式，通常采用四舍五入的模式，
• 取值为BigDecimal.ROUND_HALF_UP

//BigDecimal，大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
​
//减法
BigDecimal r1 = bd1.subtract(db2);
System.out.println(r1);
​
//加法
BigDecimal r2 = bd1.add(db2);
Sysetm.out.println(r2);
​
//乘法
BigDecimal r3 = bd1.multiply(bd2);
Sysetm.out.println(r3);
​
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"))
Sysetm.out.println(r4);
​
//当除法，除不尽时，要加保留小数点后几位
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//ROUND_HALF_UP四舍五入
Sysetm.out.println(r5);

7.Date类（特定时间）

• Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经别Calendar类中的方法所取代。
• 时间单位：1秒=1000毫秒1毫秒=1000微秒1微秒=1000纳秒

import java.util.Date;
​
public class TestDate {
    public static void main(String[] args) {
        //1.今天的日期，
        Date d1 = new Date();
        System.out.println(d1.toString());//输出为：Tue Sep 27 16:14:34 CST 2022
        System.out.println(d1.toLocaleString());//此方法过时了，输出为：2022-9-27 16:14:34
​
        //昨天的日期， getTime()获取毫秒数
        Date d2 = new Date(d1.getTime() - (60 * 60 * 24 * 1000));
        System.out.println(d2.toLocaleString());
​
        //2.after:比较日期d1是否在d2之后，是就返回true，否则返回false,
        // before：比较日期d1是否在d2之前，是就返回true，否则返回false,
        boolean b1 = d1.after(d2);
        System.out.println(b1);//true
        boolean b2 = d1.before(d2);
        System.out.println(b2);//false
​
        //3.compareTo:比较毫秒数，前后毫秒数相减，正数返回1，负数返回-1，相等就返回0
        System.out.println(d1.compareTo(d2));
​
        //4.比较equals
        System.out.println(d1.equals(d2));//false
    }
}

8.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-Calendar
Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
void add(int field,int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

import java.util.Calendar;
​
public class TestCalendar {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //获取月,从0-11，所以要加 1
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        //获取小时,HOUR是12小时制，HOUR_OF_DAY是24小时制
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        //获取分钟
        int minutes = calendar.get(Calendar.MINUTE);
        //获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println("现在时间为："+year+"年"+(month+1)+"月"+day+"日"+hour+"小时"+minutes+"分"+second+"秒");
        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.YEAR,1);//将year设置为1月
        System.out.println(calendar2.getTime().toLocaleString());
        //4.add方法修改时间
        calendar2.add(Calendar.MONTH,1);//加一个月，是-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);
    }
}

9.SimpleDateFormate类（格式化时间）

SimpleDateFormate是一个以语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期 —>文本）、解析（文本 —>日期），即特定字符串与日期互相转换
常用的时间模式字母：

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中小时数（0-23），h表示12进制的	22
m	分钟	16
s	秒	59
S	毫秒	367

public class Demo{
    public static void main(String[] args) throws Exception{
        //1.创建SimpleDateFormat对象,y年M月,设置为yyyy年MM月dd日 HH:mm:ss这种格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //2.创建Date
        Date date = new Date();
        //格式化date(把日期转成字符串)
        String str = sdf.format(date);
        System.out.println(str)//输出：2022年9月27日 17:13:21
        //解析(把字符串转成日期)
        Date date2 = sdf.parse("1990年05月01日 11:45:24")//parse()里的格式跟SimpleDateFormat格式不一致的话，会报错
            System.out.println(date2)
}
}

10.System类（系统类）

System系统类，主要用于获取系统的属性数据（都是静态的，用System.调用就行）和其他操作，构造方法私有（不需要创建对象）。

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

//1.复制数组，arraycopy(Object src,int srcPos,Object dest,int destPos，int lengt):数组的复制
//Object src被复制的数组,
//int srcPos从哪个位置开始复制,
//Object dest目标数组,
//int destPos目标数组的位置，
//int length复制的长度
int[] arr = {20.18,15,8,35,26,45,90};
int[] dest = new int[8];
System.arraycopy(arr,0,dest,0,arr.length);
for(int i = 0 ;i<dest.length;i++){
System.out.println(dest[i]);
}
//Arrays.copyOf(original,newLength)效率比System.arraycopy低
​
//2.System.currentTimeMilis()用来计时,获取毫秒数
System.out.println(System.currentTimeMilis());
​
long start System.currentTimeMillis();
for(int i = 0;i<999999;i++){
for()(int j = 0;j<999999;j++){
int result=i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时："+(end-start));
​
//3.System.gc()例子见3.5
​
//4.退出JVm
System.exit(0)
System.out.println("程序退出来...")//没有打印这条语句就说明已经退出了

 

参考资料：

JDK1.8帮助文档

 

■免责申明
⒈ 本站是纯粹个人学习网站，与朋友交流共赏，不存在任何商业目的。
⒉ 本站利用了部分网络资源，版权归原作者及网站所有，如果您对本站所载文章及作品版权的归属存有异议，请立即通知我们，我们将在第一时间予以删除，同时向你表示歉意！