JavaSE_第十一章:常用类

最新推荐文章于 2024-11-18 08:41:09 发布

开心点!

最新推荐文章于 2024-11-18 08:41:09 发布

阅读量286

点赞数

分类专栏： # JavaSE学习历程文章标签： java 字符串

本文链接：https://blog.csdn.net/YX_SYXS/article/details/115289936

版权

JavaSE学习历程专栏收录该内容

14 篇文章 1 订阅

订阅专栏

JavaSE学习历程

第一章:Java初识
 第二章:Java语言基础
 第三章:选择结构与分支结构
 第四章:循环结构
 第五章:方法/函数
 第六章:数组
 第七章:面向对象
 第八章:三大特性
 第九章:三个修饰符
 第十章:接口

第十一章:常用类

1 内部类

1.1 内部类的分类

成员内部类
静态内部类
局部内部类
匿名内部类

1.2 什么是内部类

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

特点:

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

1.3 为什么使用内部类

1.内部类方法可以访问该类所在作用域定义的数据,包括被private修饰的私有数据
2.内部类对同一包下的其他类是隐藏的,不可被其他类所调用.
3.内部类可以解决Java单继承的缺陷.
4.当我们想要定义一个回调函数却不想写大量代码的时候我们可以选择使用匿名内部类来实现.
5.每个内部类都可以继承一个类,外部类可以使用,另类实现多继承.

1.4 成员内部类

1.4.1成员内部类

在类的内部定义,与实例变量、实例方法同级别的类
外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象.
当外部类、内部类存在重名属性时，会优先访问内部类属性。
成员内部类不能定义静态成员。

案例:

/**
 * @Classname MemberInnerClass
 * @Description TODO:成员内部类:创建对象及调用方法
 * @Created by xx
 */
public class MemberInnerClass {
    public static void main(String[] args) {
        //调用非静态内部类
        //方法一:
        O out = new O();
        O.I inner = out.new I();
        inner.i();
        //方法二:一步完成
        O.I inner1 = new O().new I();
        inner1.i();
    }
}

/**
 * 外部类
 */
class O {
    public void o() {
        System.out.println("外部类方法");
    }

    /**
     * 内部类
     */
    class I {
        int age = 10;

        //静态成员初始化在类加载时进行,内部类的加载则依赖于内部类对象的创建,晚于静态成员的加载时机
        //故:成员内部类不能定义静态成员
        //        static String sex = "男";
        public void i() {
            System.out.println(age);
            System.out.println("内部类方法");
        }
    }
}

/*
运行结果:
0
内部类方法
10
内部类方法
*/

1.4.2 静态内部类

不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员
只能直接访问外部类的静态成员(实例成员需实例化外部类对象)

案例:

**
 * @Classname StaticInner
 * @Description TODO:静态内部类:创建对象与调用方法
 * @Created by xx
 */
public class StaticInner {
    public static void main(String[] args) {
//      调用静态内部类
        StaticOut.StaticInner inner1 = new StaticOut.StaticInner();
        inner1.print();

    }
}

class StaticOut{
    static class StaticInner{
        private static String name = "张三";

        public static void print(){
            System.out.println(name);
        }
    }
}

/*
运行结果:
张三
*/

1.4.3 局部内部类

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

生命周期:

局部变量:从声明的位置开始到代码块结束的位置.存放在栈中,使用完立即回收

对象:保存在堆中,声明使用后不立即回收,回收由java回收机制进行回收.

```
final常量:回收机制更为严格,
```

/**
 * @Classname TestInner
 * @Description TODO:局部内部类
 * @Created by xx
 */
public class TestInner {
    public static void main(String[] args) {
        //创建非静态内部类对象
        Outer outer = new Outer();
        outer.m1();

    }
}

class Outer {
    int a = 10;
    static int count = 0;

    public Outer() {
        count++;
    }

    public void m1() {
//        final String local = "Hello";
        //jdk8以后,发现局部变量被局部内部类调用,隐式使用final修饰
        String local = "World";

        class Inner2 {
            int a = 20;

            public void m2() {
                int a = 30;
                System.out.println("Inner2 - m2()" + a);
                System.out.println("Inner2 - m2()" + this.a);
                System.out.println("Inner2 - m2()" + Outer.this.a);
                System.out.println("Inner2 - m2()" + local);
//                不可被更改,说明隐式使用了final修饰
//                local = null;
            }
        }
        //初始化对象
        Inner2 inner2 = new Inner2();
        inner2.m2();
    }
}

/*
运行结果:
Inner2 - m2()30
Inner2 - m2()20
Inner2 - m2()10
Inner2 - m2()World
*/

1.4.4 匿名内部类

没有类名的局部内部类(一切特征都与局部内部类相同)
必须继承一个父类实现一个接口,不是实例化父类或接口
定义类、实现类、创建对象的语法合并(符合程序员的书写习惯),只能创建一个该类对象.

匿名内部类写法技巧:编辑软件按照创建对象的写法写,编辑器默认要写匿名内部类,—>接口与抽象类不能实例化.

优点:减少代码量
缺点:可读性较差

/**
 * @Classname AnonymousInner
 * @Description TODO:匿名内部类实现取彩盒与黑白盒
 * @Created by xx
 */
public class AnonymousInner {
    public static void main(String[] args) {
        //定义匿名内部类--->实现接口
        Inbox inbox = new Inbox() {
            @Override
            public String getColor() {
                return "彩盒";
            }
        };
        //第二个匿名内部类--->继承父类
        PInbox pInbox = new PInbox() {
            @Override
            public String getColor() {
                return "黑白盒";
            }
        };

        System.out.println("使用"+inbox.getColor()+"打印");
        System.out.println("使用"+pInbox.getColor()+"打印");
    }
}

abstract class Printer{
	public abstract String getColor();
}

interface Inbox{
    public abstract String getColor();
}
/*
运行结果:
使用彩盒打印
使用黑白盒打印
*/

2 Object类

2.1 概述

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

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

2.2 常用方法

2.2.1 getClass()方法

 public final native Class<?> getClass();

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

public class TestGetClass {
    public static void main(String[] args) {
        Animal animal = new Dog();
        Animal animal1 = new Cat();
        
        //判断引用的真实类型是否一致
        if(animal.getClass() == animal1.getClass()){
            System.out.println("类型一致");
        }else {
            System.out.println("类型不一致");
        }
    }
}

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃");
    }
}

class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃老鼠");
    }
}

/*
运行结果:
类型不一致
*/

2.2.2 hashCode()方法

public native int hashCode();

返回该对象的十进制的哈希码值.
哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值.
哈希码并不唯一,可保证相同对象返回相同的哈希码,尽量保证不同对象返回不同哈希码.

/**
 * @Classname hashCode
 * @Description TODO:hashCode方法
 * @Created by xx
 */
public class hashCodeClass {
    public static void main(String[] args) {
        //哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值.
        //故:int类型的哈希值为本身,char类型为ASCII码
        int a = 10;
        //使用包装类
        Integer a1 = new Integer(a);
        double d = 1.0;
        Double d1 = new Double(d);
        char c = 'A';
        Character c1 = new Character(c);
        String s = "啦啦啦";
        int[] arr = new int[]{1,3,2,4,5};
        //基本类型中需要使用包装类才能调用hashCode方法
        System.out.println(a1.hashCode());
        System.out.println(d1.hashCode());
        System.out.println(c1.hashCode());
        System.out.println(s.hashCode());
        System.out.println(arr.hashCode());
        System.out.println("========================");

        //计算出来的int值超过int的取值范围,返回值为高位截断后的结果
        String sa = "ABCDEa123abc";
        String sb = "ABCDFB123abc";
        System.out.println(sa.hashCode());
        System.out.println(sb.hashCode());
        System.out.println(sa.hashCode() == sb.hashCode()); //输出true


    }
}

/*
运行结果:
10
1072693248
65
21708966
460141958
========================
165374702
165374702
true

*/

2.2.3 toString()方法

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

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

public class TestStudent {
	public static void main(String[] args) {
		//1getClass方法
		System.out.println("------------1getClass---------");
		Student s1=new Student("aaa", 20);
		Student s2=new Student("bbb",22);
		System.out.println(s1.toString());
		System.out.println(s2.toString());
		}
	}

class Student  {
	private String name;
	private int age;
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	
	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 + "]";
	}
}

/*
运行结果:
Student1 [name=aaa, age=20]
Student1 [name=bbb, age=22]
*/

2.2.4 equals()方法

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

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

package com.yx.lesson15.lianxi;

/**
 * @Classname OverriderEquals
 * @Description TODO:重写`equals方法:学号与姓名相同为同一人.
 * @Created by xx
 */
public class OverrideEquals {
    public static void main(String[] args) {
        Student stu = new Student("123","张三");
        Student stu1 = new Student("123","张三");
        System.out.println(stu.equals(stu1));
    }
}

class Student{
    private String StuNo;
    private String StuName;

    public Student() {
    }

    public Student(String stuNo, String stuName) {
        StuNo = stuNo;
        StuName = stuName;
    }

    public String getStuNo() {
        return StuNo;
    }

    public void setStuNo(String stuNo) {
        StuNo = stuNo;
    }

    public String getStuName() {
        return StuName;
    }

    public void setStuName(String stuName) {
        StuName = stuName;
    }

    //重写equals方法使其判断符合实际情况:学号与姓名相同为同一人.
    @Override
    public boolean equals(Object obj) {
        //1.判断地址是否一致
        if (this == obj){
            return true;
        }
        //2.判断obj是否为null
        if (obj == null){
            return false;
        }
        //3.判断是否为同一类型
        if (obj instanceof Student){
            //4.强制转换为Student类型
            Student student = (Student)obj;
            //5.比较属性--->下面语句中的equals为字符串重写的equals方法
            if (this.StuNo.equals(student.getStuNo()) && this.StuName.equals(student.StuName)){
                return true;
            }
        }
        //执行到此步,说明不相等
        return false;
    }

}

/*
运行结果:
true
*/

字符串重写的equals方法—>Java源码

//字符串重写的equals方法--->Java源码
 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

2.2.5 finalize()方法

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

案例代码:

public class TestFinalize {
	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("回收垃圾");
		
	}
}

3 包装类

3.1 概述

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

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

3.2 装箱、拆箱

八种包装类提供不同类型间的转换方式。

Number父类中提供的6个共性方法。
parseXXX()静态方法（除了Character）。
valueOf()静态方法。
注意：需保证类型兼容，否则抛出NumberFormatException异常。
JDK 5.0之后，自动装箱、拆箱。基本数据类型和包装类自动转换。

案例演示：包装类使用。

public class TestInteger {
	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之后,提供自动装箱和拆箱
        System.out.println("-------------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=255;
		//1.1使用+号
		String s1=n1+"";
		//1.2使用Integer中的toString()方法
		String s2=Integer.toString(n1, 16);//f
		System.out.println(s1);
		System.out.println(s2);
		
		
		//2字符串转成基本类型
		String str="150";
		//使用Integer.parseXXX();
		int n2=Integer.parseInt(str);
		System.out.println(n2);
		
		//boolean字符串形式转成基本类型，"true"--->true  非"true"---->false
		String str2="false";
		boolean b1=Boolean.parseBoolean(str2);
		System.out.println(b1);
		
	}
}

3.3 整数缓冲区

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

面试题：分析以下输出结果的原因。

public class TestInteger2 {
	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=Integer.valueOf(200);//自动装箱
		Integer integer6=Integer.valueOf(200);
		System.out.println(integer5==integer6);//false
		
	}
}

4 String

4.1 概述

Java程序中的所有字符串文本（例如“abc”）都是此类的实例。

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

常用创建方式：
```
String str1 = “Hello”;
```
```
String str2 = new String(“World”);
```

4.2 常用方法

方法名	描述
public char charAt(int index)	根据下标获取字符
public boolean contains(String str)	判断当前字符串中是否包含str
public char[] toCharArray()	将字符串转换成数组.
public int indexOf(String str)	查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int length()	返回字符串的长度
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做拆分
public String subString(int beginIndex,int endIndex)	在字符串中截取出一个子字符串

案例:String的使用

public class TestString1 {
	public static void main(String[] args) {
		String name="hello";//"hello" 常量存储在字符串池中,
		name="zhangsan";//“张三”赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
		String name2="zhangsan";
		
		//演示字符串的另一种创建方式，new String();
		String str=new String("java");
		String str2=new String("java");
		System.out.println(str==str2);
		System.out.println(str.equals(str2));
		
		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 World   ";
		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", "php"));
		
		String say="java is the best   programing language,java xiang";
		String[] arr=say.split("[ ,]+");
		System.out.println(arr.length);
		for (String string : arr) {
			System.out.println(string);
		}
		
		//补充两个方法equals 、compareTo();比较大小
		System.out.println("---------补充---------");
		String s1="hello";
		String s2="HELLO";
		System.out.println(s1.equalsIgnoreCase(s2));
		
		String s3="abc";//97
		String s4="ayzawe";//120
		System.out.println(s3.compareTo(s4));
		
		String s5="abc";
		String s6="abc";
		System.out.println(s5.compareTo(s6));
	}
}

4.3 可变长字符串

概念:可在内存中创建可变的缓冲空间,存储频繁改变的字符串.

Java中提供了两个可变字符串类：

StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。
StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
这两个类中方法和属性完全一致。

常用方法:

方法名	属性
public StringBuilder append(String str)	追加内容。
public StringBuilder insert(int dstOffset, CharSequence s)	将指定字符串插入此序列中。
public StringBuilder delete(int start, int end)	移除此序列的子字符串中的字符。
public StringBuilder replace(int start, int end, String str)	使用给定字符串替换此序列的子字符串中的字符。start开始位置、end结束位置。
public int length()	返回长度（字符数）。

案例:

public class TestStringBuffer {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer("A");
        
        //追加内容
        stringBuffer.append("a");
        System.out.println(stringBuffer);

        StringBuilder s2 = new StringBuilder("abcd");
        s2.append("aaa");
        //左闭右开--->删除cd
        System.out.println(s2.delete(2,4));
        
        //1.可变长
        //2.StringBuffer线程安全;StringBuilder线程不安全
        //3.频繁修改字符串使用StringBuffer或StringBuilder
    }
}

案例:验证StringBuild;StringBuffer;String的效率

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

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

        StringBuffer sf=new StringBuffer();
        long startf=System.currentTimeMillis();
        for(int i=0;i<99999;i++) {
            sf.append(i);
        }
//        System.out.println(sf.toString());
        long endf=System.currentTimeMillis();
        System.out.println("StringBuffer用时:"+(endf-startf));
        System.out.println("=====================================");
    }
}

/*
运行结果:
String用时:24650
=====================================
StringBuilder用时:3
=====================================
StringBuffer用时:5
=====================================
*/

5 BigDecimal类

5.1 为什么使用BigDecimal?

很多实际应用中需要精确计算,而double是近似值存储,不再符合精确计算的要求,此时为达到精确计算的要求,需要借助BigDecimal

5.2 BigDecimal基本用法

位置:java.math包中
作用:精确计算浮点数
创建方式: BigDecimal bd = new BigDecimal(“1.0”).
建议使用字符串形式的浮点数,便于精确计算.

常用方法:

方法名	描述
BigDecimal add(BigDecimal bd)	加
BigDecimal subtract(BigDecimal bd)	减
BigDecimal multiply(BigDecimal bd)	乘
BigDecimal divide(BigDecimal bd)	除

/**
 * @Classname TestCalc
 * @Description TODO:BigDecimal实现计算器
 * @Created by xx
 */
public class TestCalc {
    public static void main(String[] args) {
        TestCalc cal = new TestCalc();
        cal.calMenu();
    }


    /**
     *计算菜单
     * */
    public void calMenu(){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入第一个数值");
//        BigDecimal num1 = new BigDecimal(input.next());
        BigDecimal num1 = input.nextBigDecimal();
        System.out.println("请输入运算符");
        String ysf = input.next();
        System.out.println("请输入第二个数值");
//        BigDecimal num2 = new BigDecimal(input.next());
        BigDecimal num2 = input.nextBigDecimal();
        if (ysf.equals("+")) {
            BigDecimal num3 = num1.add(num2);
            System.out.println(num3);
        }else if (ysf.equals("-")){
            BigDecimal num3 = num1.subtract(num2);
            System.out.println(num3);
        }else if (ysf.equals("*")){
            BigDecimal num3 = num1.multiply(num2);
            System.out.println(num3);
        }else if (ysf.equals("/")){
            BigDecimal num3 = num1.divide(num2,2,BigDecimal.ROUND_HALF_UP);
            System.out.println(num3);
        }

    }
}

除法：divide(BigDecimal bd,int scal,RoundingMode mode)。
参数scale ：指定精确到小数点后几位。

参数mode ：

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

6 时间类型

6.1 Date

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

案例:

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());
		//昨天
		Date date2=new Date(date1.getTime()-(60*60*24*1000));
		System.out.println(date2.toLocaleString());
		//2方法after before
		boolean b1=date1.after(date2);
		System.out.println(b1);
		boolean b2=date1.before(date2);
		System.out.println(b2);
		
		//比较 compareTo();
		int d=date2.compareTo(date1);
		System.out.println(d);
		//比较是否相等 equals()
		boolean b3=date1.equals(date2);
		System.out.println(b3);
		
	}
}

6.2 Calender

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 getTimeInMillis()	毫秒为单位返回该日历的时间值

案例:

/**
 * @Classname TestDate01
 * @Description TODO:5、输出当前的年月日
 * @Created by xx
 */
public class TestDate01 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        //System.out.println(calendar);
        System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(calendar.MONTH)+1)+"月"+calendar.get(calendar.DAY_OF_MONTH)+"日");
        
        //2获取时间信息
		//获取年
		int year=calendar.get(Calendar.YEAR);
		//月 从0-11
		int month=calendar.get(Calendar.MONTH);
		//日
		int day=calendar.get(Calendar.DAY_OF_MONTH);//Date
		//小时
		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+1)+"月"+day+"日"+hour+":"+minute+":"+second);
		//3修改时间
		Calendar calendar2=Calendar.getInstance();
		calendar2.set(Calendar.DAY_OF_MONTH, 5);
		System.out.println(calendar2.getTime().toLocaleString());
		
		//4add方法修改时间
		calendar2.add(Calendar.HOUR, -1);
		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);
    }
}

/*
运行结果:
2021年3月26日
2021年3月26日11:4:25
2021-3-5 11:04:25
2021-3-5 10:04:25
30
1
*/

6.3 SimpleDataFormat

SimpleDateFormat是以与语言环境有关的方式来格式化和解析日期的类。
进行格式化（日期 -> 文本）、解析（文本 -> 日期）。

常用时间模式字母：

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

案例:

/**
 * @Classname TestDate02
 * @Description TODO:字符串与日期的互转,计算两个字符串之间的天数
 * @Created by xx
 */
public class TestDate02 {
    public static void main(String[] args) throws ParseException {
        DateClass dc = new DateClass();
        String date = "2020-2-23";
        Date d = dc.StringToDate(date,"yyyy-MM-dd");
        System.out.println(d);
        String str = dc.DateToString(d,"yy/MM/dd HH:mm:ss");
        System.out.println(str);

        String date1 = "2021-2-23 12:34:20";
        Date d2 = dc.StringToDate(date1,"yyyy-MM-dd HH:mm:ss");

        dc.CalDate(d,d2);
    }
}

class DateClass{
    private SimpleDateFormat sf = null;

    /**
     * 字符串转日期
     * */
    public Date StringToDate(String string, String patten) throws ParseException {
        sf = new SimpleDateFormat(patten);
        return sf.parse(string);
    }

    /**
     * 日期转字符串
     * */
    public String DateToString(Date date,String patten){
        sf = new SimpleDateFormat(patten);
        return sf.format(date);
    }

    /**
     * 计算两个字符串之间的天数
     * */
    public void CalDate(Date date,Date date2){

        if(date2.after(date)){
            long ms =  date2.getTime()-date.getTime();
            System.out.println("相差:"+ms/1000/60/60/24);
        }else {
            long ms = date.getTime() - date2.getTime();
            System.out.println("相差:" + ms / 1000 / 60 / 60 / 24);
        }
    }
}

/*
运行结果:
Sun Feb 23 00:00:00 CST 2020
20/02/23 00:00:00
相差:366
*/

7 System

System系统类，主要用于获取系统的属性数据和其他操作。

常用方法：

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

案例演示：

public class TestSystem {
	public static void main(String[] args) {
		//1 arraycopy：数组的复制
		//src：源数组
		//srcPos:从那个位置开始复制 0
		//dest：目标数组
		//destPos:目标数组的位置
		//length：复制的长度
		int[] arr= {20,18,15,8,35,26,45,90};
		int[] dest=new int[8];
		System.arraycopy(arr, 4, dest, 4, 4);
		for(int i=0;i<dest.length;i++) {
			System.out.println(dest[i]);
		}
		//Arrays.copyOf(original, newLength)
		System.out.println(System.currentTimeMillis());
		
		long start=System.currentTimeMillis();
		for(int i=-9999999;i<99999999;i++) {
			for(int j=-999999;j<9999999;j++) {
				int result=i+j;
			}
		}
		//2 获取毫秒数
		long end=System.currentTimeMillis();
		System.out.println("用时:"+(end-start));
		
		
		new Student("aaa", 19);
		new Student("bbb", 19);
	new Student("ccc", 19);
		//3回收垃圾
		System.gc();//告诉垃圾回收期回收
		
		//4退出jvm
		System.exit(0);
		
		System.out.println("程序结束了....");
	}
}