Java常用类学习

标签：max   nts   包装类   try   ddr   imei   main   存储   etc   

1.内部类

1. 内部类的分类

   

2. 什么是内部类

概念:在一个类的内部再定义一个完整的类。将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

特点:

• 编译之后可生成独立的字节码文件。

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

• 可为外部类提供必要的内部功能组件。

public class Outer {
    private String name;

    //内部类
    class Inner{
        public void show(){
            System.out.println(name);
        }
    }
}

1.成员内部类

概念：在类的内部定义，与实例变量、实例方法同级别的类。
创建内部类对象时，必须依赖外部类对象。有两种方法：

//方法一
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();

//方法二
Outer.Inner inner1=new Outer().new Inner();

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

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

//外部类
public class Outer {
    private String name="张三";
    private int age=20;

    //内部类
    class Inner{
        private String name="李四";
        private String address="北京";
        private String phone="110";
        //内部成员类不能包含静态属性，但是可以包含静态常量
        private static final String COUNTRY="中国";
        //内部方法
        public void show(){
            //打印外部类属性
            //访问外部类同名属性前面要加Outer.this
            System.out.println(Outer.this.name);//访问外部类name
            System.out.println(this.name);//访问内部类name
            System.out.println(age);
            //打印内部类属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}
/*测试类
public class Test {
    public static void main(String[] args) {
//        //1.创建一个外部类对象
//        Outer outer=new Outer();
//        //2.创建内部类对象
//        Outer.Inner inner=outer.new Inner();
        Outer.Inner inner1=new Outer().new Inner();
        inner1.show();
    }
}
*/

2.静态内部类

1. 静态内部类不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。静态内部类等价于外部类。
2. 只能直接访问外部类的静态成员(实例成员需实例化外部类对象)
3. 创建静态内部类对象

//可以直接创建静态内部类对象
        Outer.Inner inner=new Outer.Inner();

//外部类
public class Outer {
    private String name="张三";
    private int age=20;
    //静态内部类，和外部类级别相同
    static class Inner{
        private String address="上海";
        private String phone="111";
        //静态属性
        private static int count=1000;
        public void show(){
            //调用外部类属性
            //1.先创建外部类对象
            //2.再访问外部类属性
            Outer outer=new Outer();
            System.out.println(outer.age);
            System.out.println(outer.name);
            //调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);

        }
    }
}
/*public class Test {
    public static void main(String[] args) {
        //可以直接创建静态内部类对象
        Outer.Inner inner=new Outer.Inner();
        inner.show();
    }
}
*/

3.局部内部类

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

public class Outer {
    private String name="张三";
    private int age=20;

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

        //局部内部类，前面不能加任何访问修饰符
     	class Inner{
            //局部内部类属性
            private String phone="15649853546";
            private String email="123@qq.com";
            //局部内部类不能包含静态属性，但是可以包含静态常量

            public void show2(){
                //访问外部类属性
                System.out.println(name);
                System.out.println(Outer.this.age);
                //访问内部类属性
                System.out.println(phone);
                System.out.println(this.email);
                //访问局部变量
                //jdk1.7要求访问的局部变量必须是常量final，jdk1.8自动加final
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner=new Inner();
        inner.show2();
}
/*测试类
public class Test {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.show();

    }
}
*/

4.匿名内部类

1. 匿名内部类：没有类名的局部内部类(一切特征都与局部内部类相同)。
2. 匿名内部类必须继承一个父类或者实现一个接口。
3. 匿名内部类其实是把定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
4. 优点:减少代码量。

//创建Usb接口
public interface Usb {
    void servce();
}

//创建匿名内部类
public class Test {
    public static void main(String[] args) {
//        Usb usb=new Mouse();
//        usb.servce();
        //局部内部类
//        class Fan implements Usb{
//            @Override
//            public void servce() {
//                System.out.println("连接成功，风扇开始工作...");
//            }
//        }
//        //使用局部内部类创建对象
//        Fan fan=new Fan();
//        fan.servce();

        //如果局部内部类只使用一次，代码显得多余浪费，可以使用匿名内部类优化
        //使用匿名内部类相当于创建了一个局部内部类
        //创建匿名内部类，可以new 父类，抽象类，接口
        Usb usb=new Usb() {
            @Override
            public void servce() {
                System.out.println("连接成功，风扇开始工作...");
            }
        };
        usb.servce();
    }
}

2.Object类

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

1.getClass（）方法

• 返回引用中存储的实际对象类型
• 应用:通常用于判断两个引用中实际存储对象类型是否一致。

//Student类
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 Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",22);
        //判断s1和s2是不是同一个类型
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if(class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}

2.hashCode()方法

public int hashCode() {}

• 返回该对象的哈希码值。
• 哈希值是根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
• 一般情况下相同对象返回相同哈希码。

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",22);
        //hashCode（）
        Student s3=s1;
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());
    }
}
/*
21685669
2133927002
21685669
*/

3.toString（）方法

public String toString(){}

• 返回该对象的字符串表示(表现形式)。
• 可以根据程序需求覆盖该方法，如:展示对象各个属性值。

//调用父类继承下来的toString()方法
System.out.println(s1.toString());
System.out.println(s2.toString());
/*结果：
com.object.objectclass.Student@14ae5a5
com.object.objectclass.Student@7f31245a
*/

//在子类重写toString()方法
@Override
    public String toString() {
        return "Student{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }

//调用子类重写的toString()方法
System.out.println(s1.toString());
System.out.println(s2.toString());
/*结果
Student{name=‘aaa‘, age=20}
Student{name=‘bbb‘, age=22}
*/

4.equals（）方法

public boolean equals(Object obj) {
        return (this == obj);
    }

• 默认实现为(this == obj)， 比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。
• equals()方法覆盖步骤:
  • 比较两个引用是否指向同一个对象。
  • 判断obj是否为null
  • 判断两个引用指向的实际对象类型是否一致。
  • 强制类型转换。
  • 依次比较各个属性值是否相同。

//默认父类equals（）方法
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",22);
Student s3=s1;
System.out.println(s1.equals(s2));//false
System.out.println(s1.equals(s3));//true
Student s4=new Student("小明",17);
Student s5=new Student("小明",17);
System.out.println(s4.equals(s5));//false

//子类重写equals（）方法，比较对象中的属性是否相同
@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                name.equals(student.name);
    }
//测试类结果
Student s4=new Student("小明",17);
Student s5=new Student("小明",17);
System.out.println(s4.equals(s5));//true

5.finalize（）方法

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

//在子类重写finalize()方法
@Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收");
    }

//测试类
public class Test2 {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        new Student("ccc",20);
        new Student("ddd",20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}
/*
回收垃圾
ddd对象被回收
ccc对象被回收
*/

3.包装类

• 基本数据类型所对应的引用数据类型
• Object可统一所有数据，包装类的默认值是null。

装箱：把基本数据类型转换为引用类型。

拆箱：把引用类型转换为基本数据类型。

//装箱拆箱
public class Demo01 {
    public static void main(String[] args) {

        //装箱操作：基本数据类型转换为引用类型
        int num1=18;
        //使用Interger创建一个引用类型
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("=========装箱==========");
        System.out.println(integer1);
        System.out.println(integer2);
        //拆箱：引用类型转换为基本数据类型
        System.out.println("=========拆箱==========");
        Integer integer3 = new Integer(100);
        System.out.println(integer3);
        int num2=integer3.intValue();
        System.out.println(num2);
        //JDK1.5之后提供自动装箱和开箱
        int age=30;
        //自动装箱
        System.out.println("=========自动装箱==========");
        Integer integer4=age;//本质还是调用Integer.valueOf（）
        System.out.println(integer4);
        //自动拆箱
        System.out.println("=========自动拆箱==========");
        int age2=integer4;
        System.out.println(age2);
    }
}

//基本数据类型与字符串之间转换
public class Demo02 {
    public static void main(String[] args) {
        //基本数据类型与字符串之间转换
        //1.基本类型转换为字符串
        int n1=100;
        //1.1使用+号
        String s1=n1+"";
        //1.2使用Interger中的toString方法
        String s2=Integer.toString(n1);
        String s3=Integer.toString(n1,16);//将n1转换为16进制再转换为字符串
        String s4=Integer.toBinaryString(n1);//将n1转换为2进制再转换为字符串
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println(s2.getClass());
        System.out.println(s3.getClass());
        //2.把字符串转换为基本类型
        String str="150";
        //使用Integer.parseXxx（）方法
        int n2=Integer.parseInt(str);
        System.out.println(n2);

        //字符串转成boolean基本类型："true"->true,"True"->true;非"true"一律转换为false
        String str2="True";
        boolean bool=Boolean.parseBoolean(str2);
        System.out.println(bool);
    }
}
/*
100
64
1100100
class java.lang.String
class java.lang.String
150
true
*/

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

• Number父类中提供的6个共性方法。
• parseXXX()静态方法。
• value0f()静态方法。
• 注意:需保证类型兼容，否则抛出NumberForma tException异常。即：字符串转换为基本类型（数字）时，不能含有非数字字符

整数缓冲区：

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

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

        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

    }
}
//第9行代码和第13行代码为什么有区别：原因和valueOf这个方法有关，因为valueOf（）内部创建了-128-127的对象数组，如果装箱的时候-128<=i<=127,则把数组的地址返回给integer，否则新开辟一个空间返回给integer

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

4.String类

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

• 字符串字面值存储在字符串池中，可以共享。

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

String s = new String(“Hello" ); //产生两个对象，堆、字符串池各存储一个。

public class Demo01 {
    public static void main(String[] args) {
        String name="hello";//“hello”存储在字符串池中
        name="张三";//“张三”赋值给name时，并没有修改“hello”，
                    // 而是在字符串池中又开辟了一块空间存放“张三”，把张三的地址给了name
        String name1="张三";//name1也指向张三
        
        //字符串的另一种创建方式
        //使用new关键字创建字符串时，创建2个对象，一个存放在堆中，另一个存放在字符串池中
        String str1=new String("Java");
        String str2=new String("Java");
        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true

    }
}

1.String类常用方法：

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 String toLowerCase ():将大写转成小写。

public boolean endWith (String str) :判断字符串是否以str结尾。

public boolean startWith (String str) :判断字符串是否以str开头。

public String replace (char oldChar, char newChar); 将旧字符串替换成新字符串

public String[] split (String str) :根据str做拆分。

public boolean equals(Object anObject):比较字符串是否相等

public int compareTo(String anotherString):比较在字码表中的顺序，只比较首字符，首字符相同再比较一下个字符

public class Demo02 {
    public static void main(String[] args) {
/*
public int length() :返回字符串的长度。
public char charAt(int index) :根据下标获取字符。
public boolean contains (String str) :判断当前字符串中是否包含str。
 */
        System.out.println("============================");
        String str1="java是世界上最好的java编程语言，java真香";
        System.out.println(str1.length());
        System.out.println(str1.charAt(str1.length()-1));
        System.out.println(str1.contains("java"));//true
        System.out.println(str1.contains("php"));//false

/*
public char[] toCharArray() :将字符串转换成数组。
public int indexOf(String str) :查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1.
public int lastIndexOf (String str) :查找字符串在当前字符串中最后一次出现的下标索引。
 */
        System.out.println("============================");
        char[] chars=str1.toCharArray();
        System.out.println(Arrays.toString(chars));
        System.out.println(str1.indexOf("java"));
        System.out.println(str1.indexOf("java",4));
        System.out.println(str1.lastIndexOf("java"));

/*
public String trim() ：去掉字符串前后的空格。
public String toUpperCase ():将小写转成大写。
public String toLowerCase ():将大写转成小写。
public boolean endWith (String str) :判断字符串是否以str结尾。
public boolean startWith (String str) :判断字符串是否以str开头。
 */
        System.out.println("============================");
        String str2="    hello world       ";
        System.out.println(str2.trim());
        System.out.println(str2.toUpperCase());
        System.out.println(str2.endsWith(" "));
        System.out.println(str2.startsWith("h",4));

/*
public String replace (char oldChar, char newChar); 将旧字符串替换成新字符串
public String[] split (String str) :根据str做拆分。
 */
        System.out.println("============================");
        System.out.println(str1.replace("java", "php"));
        String say="java is the best    programming language,,java xiang";
        System.out.println(Arrays.toString(say.split(" ")));
        System.out.println(Arrays.toString(say.split("[ ,]")));//加个中括号[]，表示选择，遇到空格或者逗号就拆分
        System.out.println(Arrays.toString(say.split("[ ,]+")));//后面再写个+，表示可以连续拆分多个空格或者逗号

/*
public boolean equals(Object anObject):比较字符串是否相等
public int compareTo(String anotherString):比较在字码表中的顺序，只比较首字符，首字符相同再比较一下个字符
 */
        String str3="hello";
        String str4="HELLO";
        str3.equals(str4);//false
        System.out.println(str3.equalsIgnoreCase(str4));
        String str5="asad";
        String str6="adafdd";
        System.out.println(str5.compareTo(str6));
        //比较再字码表中的顺序，只比较首字符，首字符相同再比较一下个字符
        String str7="abcd";
        String str8="abcdefg";
        System.out.println(str7.compareTo(str8));
        //像这种情况则比较字符串长度
    }
}
/*
============================
26
香
true
false
============================
[j, a, v, a, 是, 世, 界, 上, 最, 好, 的, j, a, v, a, 编, 程, 语, 言, ，, j, a, v, a, 真, 香]
0
11
20
============================
hello world
    HELLO WORLD       
true
true
============================
php是世界上最好的php编程语言，php真香
[java, is, the, best, , , , programming, language,,java, xiang]
[java, is, the, best, , , , programming, language, , java, xiang]
[java, is, the, best, programming, language, java, xiang]
true
15
-3
*/

练习:

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

public class Demo03 {
    public static void main(String[] args) {
        String str="this is a text";
        //1.将str的单词单独获取出来
        String[] arr=str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }
        //2.将str中的text替换为practice
        String str1=str.replace("text","practice");
        System.out.println(str1);
        //3.在text前面插入一个easy
        String str2=str.replace("text","easy test");
        System.out.println(str2);
        //4.将每个单词的首字母改为大写
        for (int i = 0; i < arr.length; i++) {
            char c1=arr[i].charAt(0);
            char c2=Character.toUpperCase(c1);
            String str3=c2+arr[i].substring(1);
            System.out.print(str3+" ");
        }

    }
}

2.StringBuffer和StringBuilder

• 和String的区别：1.效率比String高；2.比String节省内存

//StringBuffer和StringBuilder常用方法
//推荐使用StringBuffer
public class Demo04 {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        //1.追加append（）
        sb.append("java世界第一");
        System.out.println(sb.getClass());
        System.out.println(sb);
        System.out.println(sb.toString().getClass());
        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,"hello");//含头不含尾
        System.out.println(sb.toString());
        //4.delete（）：删除
        sb.delete(0,5);
        System.out.println(sb.toString());
        //清空
        sb.delete(0,sb.length());
    }
}

/**
 * 验证StringBuilder比StringBuffer效率高
 * @author NG
 */
public class Demo05 {
    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));
        //开始时间
        long start1=System.currentTimeMillis();
        StringBuffer sb=new StringBuffer();
        for (int i = 0; i <9999; i++) {
            sb.append(i);
        }
        System.out.println(sb);
        long end1=System.currentTimeMillis();
        System.out.println("用时:"+(end1-start1));
    }
}

5.BigDecimal类

很多实际应用中需要精确运算，而double，float是近似值存储，不再符合要求，需要借助BigDecimal。

public class TestBigDecimal {
    public static void main(String[] args) {
        double d1=1.0;
        double d2=0.9;
        //double，float在内存存放的是近似值
        System.out.println(d1-d2);
        double result=(1.4-0.5)/0.9;
        System.out.println(result);
    }
}
/*
0.09999999999999998
0.9999999999999999
*/

import java.math.BigDecimal;

/**
 * BigDecimal类，大的浮点数精确计算
 * @author NG
 */
public class TestBigDecimal2 {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //1.减法，substract（）
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);
        //2.加法，add()
        BigDecimal r2 =bd1.add(bd2);
        System.out.println(r2);
        //3.乘法，multiply（）
        BigDecimal r3 =bd1.multiply(bd2);
        System.out.println(r3);
        //4.除法，divide（）
        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"),5,BigDecimal.ROUND_HALF_UP);//保留五位小数，四舍五入
        System.out.println(r5);
    }
}
/*
0.1
1.9
0.90
1
3.33333
*/

BigDecimal类除法: divide (BigDecimal bd, int scal, RoundingMode mode)

• 参数scal :指定精确到小数点后几位。
• 参数mode:
  • 指定小数部分的取舍模式，通常采用四舍五入的模式，
  • 取值为BigDecimal. ROUND_HALF _UP。

6.Date类

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

/**
 * Date类
 * @author NG
 */
public class TestDate {
    public static void main(String[] args) {
        //1.创建Date对象
        //今天
        Date date1=new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天
        //getTime()：计算到1970年1月1日00:00:00的毫秒数
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        //2.方法：after，before
        System.out.println(date1.after(date2));//true
        System.out.println(date1.before(date2));//false
        //3.compareTo():比较毫秒数大小，
        // a.compareTo(b),a>b，返回1；a=b，返回0；a<b,返回-1
        int d1=date1.compareTo(date2);
        int d2=date2.compareTo(date1);
        System.out.println(date1.getTime());
        System.out.println(date2.getTime());
        System.out.println(d1);
        System.out.println(d2);
        //4.equals（）：比较时间是否相等
        System.out.println(date1.equals(date2));
        System.out.println(date1.equals(date1));
    }
}

7.Calendar类

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

• 构造方法：

  protected Calerdar() : 由于修饰符是protected,所以无法直接创建该对象。

• 其他方法：

  方法名	说明
  static Calendar getlnstance()	使用默认时区和区域获取日历
  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 getTimelnMilies()	毫秒为单位返回该日历的时间值

  import java.util.Calendar;
  
  /**
   * Calendar使用
   * @author NG
   */
  
  public class TestCalendarClass {
      public static void main(String[] args) {
          //1.创建一个Calendar对象
          Calendar calendar=Calendar.getInstance();
          System.out.println(calendar.getTime().toLocaleString());
          System.out.println(calendar.getTimeInMillis());//返回毫秒值
          System.out.println("===========================");
          //2.获取时间信息get()
          //获取年
          int year=calendar.get(Calendar.YEAR);
          //月，0-11月，显示时加1
          int month=calendar.get(Calendar.MONTH);
          //日
          int day=calendar.get(Calendar.DAY_OF_MONTH);
          //小时
          int hour=calendar.get(Calendar.HOUR_OF_DAY);//HOUR:12小时；HOUR_OF_DAY：24小时
          //分钟
          int minute=calendar.get(Calendar.MINUTE);
          //秒
          int second=calendar.get(Calendar.SECOND);
          System.out.println(year+"年"
                  +(month+1)+"月"+day+"日"+hour+"时"
                  +minute+"分"+second+"秒");
          System.out.println("===========================");
          //3.修改时间信息set()
          Calendar calendar1=Calendar.getInstance();
          calendar1.set(Calendar.DAY_OF_MONTH,16);
          System.out.println(calendar1.getTime().toLocaleString());
          //4.add方法修改时间
          calendar1.add(Calendar.HOUR_OF_DAY,-2);
          System.out.println(calendar1.getTime().toLocaleString());
          //5.getActualMaximum
          int max=calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
          int min=calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
          System.out.println(max);//打印当前月份天数最大值
          System.out.println(min);//打印当前月份天数最小值
  
      }
  }
  

8.SimpleDateFormat

• SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
• 进行格式化(日期->文本)、解析(文本->日期)。
• 常用的时间模式字母：

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

public class Test {
  public static void main(String[] args) throws ParseException {
      //1.创建一个SimpleDateFormat对象
      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);
      //解析：把字符串转为日期
      Date date1=sdf.parse("1995年06月12日12：20：30");
      System.out.println(date1);
  }
}

9.System类

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

import java.util.Arrays;

/**
 * System类
 * @author NG
 */
public class TestSystem {
    public static void main(String[] args) {
        //1.arraycopy（）：复制数组
        //src:源数组
        //srcPots：从哪个位置开始复制
        //dest:目标数组
        //destPots：目标数组的位置
        //length：复制的长度
        int[] arr={20,18,15,8,35,26,45};
        int[] dest=new int[7];
        System.arraycopy(arr, 4, dest, 4, 3);
        for (int i : dest) {
            System.out.print(i+" ");
        }
        System.out.println("");
        System.out.println("============");
        int[] arr1=Arrays.copyOf(arr, 10);
        for (int i : arr1) {
            System.out.print(i+" ");
        }
        //2.currentTimeMillis()获取当前系统时间，返回的是毫秒值
        System.out.println("");
        System.out.println("============");
        long start=System.currentTimeMillis();
        for (int i = 0; i < 999999999; i++) {
            for (int j = 0; j < 999999999; j++) {
                int result=i+j;
            }
        }
        long end=System.currentTimeMillis();
        System.out.println("用时"+(end-start));
        //3.static void gc()：建议JVM赶快启动垃圾回收器回收垃圾

    }
}

Java常用类学习

标签：max   nts   包装类   try   ddr   imei   main   存储   etc   

原文地址：https://www.cnblogs.com/Ng3061851/p/14409522.html