首页 > 编程语言> 文章详细

Java常用类

2022-05-20 22:32:09 阅读：98 来源： 互联网

标签：常用 Java String int System println public out

1. 内部类

内部类分类

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

内部类概念：在一个类的内部再定影一个完整的类
```
class Outer{
	class Inner{
	}
}
```
特点：
- 编译后可生成独立的字节码文件（.class文件）
- 内部类可直接访问外部类的私有成员，而不破坏封装
- 内部类可为外部类提供必要的内部功能组件

1.1 成员内部类

成员内部类：在类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

//创建内部类对象方法1
Outer outer =new Outer();
Outer.Inner inner=outer.new Inner();//创建内部类对象时，必须依赖外部类对象
//创建内部类对象方法2
Outer.Inner inner=new Outer().new Inner();

当外部类、内部类存在重名属性时，会优先访问内部类属性；若要访问外部类属性，使用外部类名.this.属性访问
内部类不能定义静态成员

public class Demo {
    public static void main(String[] args) {
//        //1创建外部类对象
//        Outer outer =new Outer();
//        //2创建内部类
//        Outer.Inner inner=outer.new Inner();//创建内部类对象时，必须依赖外部类对象
        //一步创建内部类
        Outer.Inner inner=new Outer().new Inner();
        inner.show();
    }
}

public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;
    //内部类
    class Inner{
        private String address="上海";
        private String phone="110";
        private String name="李四";
        //private static String country="中国";//内部类不能定义静态成员
        public void show(){
            //当内部类和外部类属性的名字相同时，使用 外部类名.this 指定访问外部类
            //若不指定外部类，会默认调用内部类属性
            System.out.println(Outer.this.name );
            System.out.println(Outer.this.age);
            System.out.println(this.name);
            System.out.println(this.address);
        }
    }
}

1.2 静态内部类

静态内部类不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
静态内部类调用外部类属性和方法，需要在静态内部类里面new一个外部类对象
只有静态内部类可以使用static修饰，普通类不能使用static修饰

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


//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;
    //静态内部类
    static class Inner{
        private String address="上海";
        private String name="李四";
        private static String country="中国";//静态内部类可以定义静态成员
        public void show(){
            //1.静态内部类调用外部类属性
            //（1）先创建外部类对象
            Outer outer=new Outer();
            //（2）调用外部类属性
            System.out.println(outer.name );
            System.out.println(outer.age);
            //2.调用内部类属性
            System.out.println(this.name);
            System.out.println(this.address);
            //3.调用静态内部类的静态属性
            System.out.println(Inner.country);//静态属性可直接通过类名访问
        }
    }
}

1.3 局部内部类

局部内部类：定义在外部类的方法之中，作用范围和创建对象范围仅限于当前方法
在定义局部内部类时不能添加任何访问修饰符，如private、static
局部内部类访问属性
- 访问外部类属性：可直接访问，为了区分一般使用外部类名.this.属性名
- 访问内部类属性：可直接访问，为了区分一般使用 this.属性名
- 访问方法中的局部变量：
  - jdk1.7之前要求局部变量加修饰符final变为常量才能访问，jdk1.8中会自动添加final
  - 原因内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
局部内部类不能包含static修饰的静态属性，可以使用static +final修饰
局部内部类使用范围有限：使用局部内部类只能在外部类当前方法中实例化一个内部类对象

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


//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;
    //方法
    public void show(){
        //定义局部变量
        String address="上海";//访问方法中的局部变量：
        // jdk1.7之前要求局部变量加修饰符final变为常量才能访问，jdk1.8中会自动添加final

        //局部内部类
        //在定义局部内部类时不能添加任何访问修饰符，如private、static
        class Inner{
            //局部内部类属性
            private String phone="11938982";
            private String email="zhangsan.@162.com";
            static final private String ID="110";//局部内部类不能包含static修饰的静态属性，可以使用static +final修饰

            public void show(){

                //局部内部类访问外部类属性
                System.out.println(Outer.this.name);//访问外部类属性：可直接访问，为了区分一般使用Outer.this.
                System.out.println(Outer.this.age);
                //局部内部类访问内部类属性
                System.out.println(this.phone);//访问内部类属性：可直接访问，为了区分一般使用this.
                System.out.println(this.email);
                //局部内部类访问局部变量
                System.out.println(address);
            }
        }
        //在方法内部实例化内部类对象
        Inner inner=new Inner();
        inner.show();
    }
}

1.4 匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相似）
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点：减少代码量
缺点：可读性较差

public class TestUsb {
    public static void main(String[] args) {
        //2.1 使用局部内部类实现接口
//        class Fan implements Usb{
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功，风扇开始工作...");
//            }
//        }
//        Usb usb = new Fan();
//        usb.service();

        //2.2 使用匿名内部类实现接口
        Usb usb=new Usb(){//匿名类实现了Usb接口
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作...");
            }
        };//注意这里有个分号
        usb.service();
    }
}


//使用匿名内部类首先要继承一个父类或者实现一个接口
//1.定义一个接口
public interface Usb {
    //服务
    void service();
}

2. Object类

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

2.1getClass()方法

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

2.2 hashCode()方法

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

2.3 toString() 方法

public String toString() {}
返回该对象的字符串表示（表现形式）。
可以根据程序需求覆盖该方法，如：重写toString ()方法展示对象各个属性值

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

2.4 equals ()方法

public boolean equals (Object obj) {}
默认实现为(this==obj)，比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同
- 覆盖对象步骤
  1. 比较两个引用是否指向同一个对象
  2. 判断obj是否为null
  3. 判断两个引用指向的实际对象是否一致
  4. 强制类型转换
  5. 依次比较各个属性值是否相同

    @Override
//重写equals()方法，改为比较属性值是否相同
    public boolean equals(Object obj) {
        //1. 比较两个引用是否指向同一个对象
        if (this==obj){
            return true;
        }
        //2. 判断obj是否为null
        if (obj==null){
            return false;
        }
        //3. 判断两个引用指向的实际对象是否一致
        //3.1使用this.getClass判断
//        if(this.getClass()==obj.getClass()){
//
//        }
        //3.2使用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;

    }

2.5 finalize ()方法

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

第2节实现代码

public class Demo {
    public static void main(String[] args) {
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",19);
        //1.使用getClass()判断两个引用中实际储存对象类型是否一致
        System.out.println("=======getClass()=======");
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if(class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
        //2.hashCode()方法获得对象的哈希值
        System.out.println("=======hashCode()=======");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());
        //3.toString()方法该对象的字符串表示，一般为了查看属性都会重写该方法
        System.out.println("=======toString()=======");
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        //4.equals()比较对象，默认比较对象地址是否相同，可重写为比较内容是否相同
        System.out.println("=======equals()=======");
        //System.out.println(s1.equals(s2));
        //System.out.println(s1.equals(s3));//不重写之前是比较对象地址是否相同
        Student s4=new Student("张三",18);
        System.out.println(s1.equals(s4));
        //5.finalize()方法回收垃圾
        System.out.println("=======finalize()=======");
        new Student("zhangsan",19);
        new Student("lisi",29);
        //回收垃圾
        System.gc();//手动调用通知系统垃圾回收
        System.out.println("回收垃圾");
    }
}


//定义Student类
public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object obj) {
        //1. 比较两个引用是否指向同一个对象
        if (this==obj){
            return true;
        }
        //2. 判断obj是否为null
        if (obj==null){
            return false;
        }
        //3. 判断两个引用指向的实际对象是否一致
        //3.1使用this.getClass判断
//        if(this.getClass()==obj.getClass()){
//
//        }
        //3.2使用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;
    }

    //重写finalize()，便于判断该方法是否执行过
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}

3. 包装类

3.1包装类概述

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

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

3.2 类型转换：装箱、拆箱

8种包装类提供不同类型间的转换
- Number父类中提供的6个共性方法
- parseXXX ()静态方法
- valueOf() 静态方法
- toString() 静态方法
注意：需保证类型兼容，否则抛出NumberFormatError异常

public class Demo {
    public static void main(String[] args) {
        //1. 数据类型转换：装箱与拆箱
        //（1）装箱，基本类型转成引用类型的过程
        //方法1，使用构造函数转换
        int num1=18;
        Integer integer1=new Integer(num1);
        //方法2，使用Integer.valueof()方法转换
        Integer integer2=Integer.valueOf(num1);
        //（2）拆箱，引用类型转换为基本类型
        int num2=integer1.intValue();

        //（3）JDK1.5后，提供自动装箱和拆箱，编译器自动完成装箱拆箱操作
        int age=30;
        Integer integer4=age;//装箱
        int age2=integer4;//拆箱

        //2. 基本类型和字符串之间的转换
        //(1)基本类型转成字符串
        int num=255;
        //方法1 使用“+”号
        String s1=num+"";
        System.out.println(s1);
        //方法2 使用Integer.toString()方法
        String s2=Integer.toString(num,16);//radix可以指定基数，16即为十六进制数，默认为十进制数
        System.out.println(s2);
        //（2) 字符串转换为基本类型
        String str="150";
        //使用Integer.parseXXX()；
        int num3=Integer.parseInt(str);
        System.out.println(num3);
        //(3) boolean字符串形式转换为基本类型 只有"true"->true，其余字符串都会转为false
        String str1="true";
        boolean b1=Boolean.parseBoolean(str1);
        System.out.println(b1);

        String str2="aaa";
        boolean b2=Boolean.parseBoolean(str2);
        System.out.println(b2);
    }
}

3.3 Integer整数缓冲区

Java预先创建了256个常用的整数包装类型对象（使用Integer.valueOf()或自动装箱时）
在实际应用当中，对已经创建的对象进行复用

public class Demo {
    public static void main(String[] args) {
        //Inter整数缓冲区
        //比较对象是否为同一个对象
        //（1）使用new Integer()对比
        Integer integer = new Integer(100);
        Integer integer1 = new Integer(100);
        System.out.println(integer==integer1);//false,使用对象创建，指向堆中位置不同

        //（2）自动装箱或使用Integer.valueOf()
        //Integer.valueOf()会使用静态方法提前在堆中生成缓冲区Integer数组
        //当数字在-128~127之间时，integer是调用缓冲区数组
        //当数字不在这个范围内时，才会重新new Integer()对象
        //作用是-128~127使用频繁，降低内存消耗。Integer.valueOf()内部调用的也是new Integer()，只不过会提前生成缓冲区
        Integer integer2=100;
        Integer integer3=100;
        System.out.println(integer2==integer3);//true

        //
        Integer integer4=200;
        Integer integer5=200;
        System.out.println(integer4==integer5);//false
    }
}

4. String类

4.1 字符串概述

字符串是常量，创建之后不可改变
字符串字面值存储在方法区的字符串池中，可以共享
创建字符串
- String s="Hello"；产生一个对象，字符串池中存储
- String s=new String("Hello"); 产生两个对象，堆和池中各存储一个，堆中数据仍然是指向字符串池中

4.2 字符串常用方法

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 String equals() 判断字符串是否相等；public String equalsIgnoreCase() 忽略大小写
public String compareTo() 比较字符串大小，按编码表进行比较
代码

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

public class Demo {
    public static void main(String[] args) {
        //1. public int length() 返回字符串的长度
        //2. public char charAt(int index) 根据下标获取字符
        //3. public boolean contains(String str) 判断当前字符串中是否包含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"));
        //public char[] toCharArray() 将字符串转换为数组
        //public int indexOf(String str) 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
        //public int lastIndexOf(String str) 查找字符串在当前字符串中最后一次出现的下标索引
        System.out.println(Arrays.toString(content.toCharArray()));//按字符转换为数组
        System.out.println(content.indexOf("Java",2));//fromIndex指定第几次出现，默认为第一次
        System.out.println(content.lastIndexOf("Java"));
        //public String trim() 却掉字符串前后的空格
        //public String toUpperCase() 将小写转成大写；public String toLowerCase() 将大写转成小写
        //public boolean endWith(String str) 判断字符串是否以str结尾；public boolean startWith(String str) 判断字符串是否以str开始
        String content2="  hello World  ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase(Locale.ROOT));
        System.out.println(content2.toLowerCase(Locale.ROOT));
        String filename="hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));
        //public String replace(char oldChar, char newChar) 将旧字符串替换成新字符串
        //public String[] split(String str) 根据str做拆分
        System.out.println(content.replace("Java","Php"));
        String say="java is  the best programing language,,java xiang";
        //say.split("[ ,]+")参数，[ ,]+表示使用空格和","分割，"+"表示可以空格和","可以出现一次或多次
        String [] arr= say.split("[ ,]+");
        System.out.println(arr.length);
        for (String s : arr) {
            System.out.println(s);
        }
        //public String equals() 判断字符串是否相等
        //public String compareTo() 比较字符串大小，按编码表进行比较
        String s1="Hello";
        String s2="hello";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写
        String s3=new String("hello");
        String s4=new String("hello");
        System.out.println(s3.equals(s4));//String类内部已经重写了equals()

        String s5="abc";//97
        String s6="xyza";//120
        System.out.println(s5.compareTo(s6));//-23 按编码表比较，返回首次出现差别字符的int类型的差值,此处即a-x=-23

        String s7="abcdef";
        System.out.println(s5.compareTo(s7));//-3 当出现"abcdef"完全包含"abc"时，返回的是字符个数的差值
    }
}

案例演示
- 需求：已知String str="this is a text"
  - 将str中的单词单独获取出来
  - 将str中的text替换为practice
  - 在text前面插入一个easy
  - 将每个单词的首字母改为大写

/**
 * 将str中的单词单独获取出来
 * 将str中的text替换为practice
 * 在text前面插入一个easy
 * 将每个单词的首字母改为大写
 */

public class Demo {
    public static void main(String[] args) {
        String str="this is a text";
        //1. 将str中的单词单独或取出来
        String [] arr=str.split(" ");
        System.out.println("-----将str中的单词单独取出来-----");
        for (String s : arr) {
            System.out.println(s);
        }
        //2. 将str中的text替换为practice
        System.out.println("-----将str中的text替换为practice-----");
        String str2=str.replace("text","practice");
        System.out.println(str2);
        //3. 在text前面插入easy
        System.out.println("-----在text前面插入easy------");
        String str3=str.replace("text","easy text");
        System.out.println(str3);
        //4. 将每个单词的首字母改为大写
        for (int i=0;i<arr.length;i++){
            //4.1 将每个单词第一个字母变为大写
            char first=arr[i].charAt(0);
            char upperFirst=Character.toUpperCase(first);//使用了字符的封装类
            //4.2 将第一个单词与后面内容拼装
            String news=upperFirst+arr[i].substring(1);//arr[i].substring(1)为截取字符串的字串，参数有起始位置和终止位置
            System.out.println(news);
        }

    }
}

4.3 可变字符串

StringBuffer: 可变长字符串，JDK1.0提供，运行效率慢、线程安全
StringBuilder: 可变长字符串，JDK5.0提供，运行效率块、线程不安全
效率比String高，比String节省内存
常用方法

//1 append(); 追加
//2 insert(); 添加
//3 replace(); 替换
//4 delete(); 删除
//5 reverse();倒置

public class Demo {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        //1 append(); 追加
        sb.append("Java真好");
        sb.append("Java真香");
        System.out.println(sb.toString());
        //2 insert(); 添加,offset为插入位置
        sb.insert(0,"最前面");
        System.out.println(sb.toString());
        //3 replace(); 替换,start开始位置，end结束位置
        sb.replace(0,3,"hello");
        System.out.println(sb.toString());
        //4 delete(); 删除,位置从0到4的字符
        sb.delete(0,5);
        System.out.println(sb.toString());
        //5 reverse();倒置
//        sb.reverse();
//        System.out.println(sb.toString());
    }
}

验证StringBuilding效率高于String

/**
 * 验证StringBuilding效率高于String
 */

public class Demo {
    public static void main(String[] args) {
//        long startTime1=System.currentTimeMillis();
//        String string="";
//        for (int i=0;i<99999;i++){
//            string+=i;
//        }
//        System.out.println(string);
//        long endTime1=System.currentTimeMillis();
//        System.out.println("String用时："+(endTime1-startTime1));

        long startTime2=System.currentTimeMillis();
        StringBuilder sb=new StringBuilder();
        for (int i=0;i<99999;i++){
            sb.append(i);
        }
        System.out.println(sb.toString());
        long endTime2=System.currentTimeMillis();
        System.out.println("StringBuild用时："+(endTime2-startTime2));
    }
}

5. 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)
  - 除法时涉及除不尽小数时，需要指定精确参数
  - divide(BigDicimal bd, int scal, RoundingMode mode)
  - 参数scal: 指定精确到小数点后几位
  - 参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式，BigDecimal.ROUND_HALF_UP

import java.math.BigDecimal;

public class Demo {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //加法1.0+0.9
        BigDecimal r1= bd1.add(bd2);
        System.out.println(r1);
        //减法1.0-0.9
        BigDecimal r2=bd1.subtract(bd2);
        System.out.println(r2);
        //乘法1.0*0.9
        BigDecimal r3=bd1.multiply(bd2);
        System.out.println(r3);
        //除法(1.4-0.5)/0.9
        BigDecimal r4=new BigDecimal("1.4").subtract(new BigDecimal("0.5"))
                .divide((new BigDecimal(("0.9"))));
        System.out.println(r4);
        //除法除不尽时需要指定舍入模式和保留小数位数20/3=6.67
        //scale:2表示保留2位小数
        //BigDecimal.ROUND_HALF_UP 表示四舍五入
        BigDecimal r5=new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);
    }
}

6. 与时间有关的类

6.1 Data类

Data表示特定的瞬间，精确到毫秒。Data类中的大部分方法已经被Calendar类中的方法取代

import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        //1. 创建Date对象
        //public Date() 返回当前时刻时间
        Date date1=new Date();
        System.out.println(date1.toString());//date1.toString()使用默认时间格式转换时间为字符串
        System.out.println(date1.toLocaleString());//已过时 date1.toLocaleString()使用当地时间格式转换时间为字符串
        //public Date(long date) 可以输入一个long类型数值，按毫秒计算与1970/1/1 0:0:0的差值
        //创建昨天时间date2
        Date date2=new Date(date1.getTime()-60*60*24*1000);//date1.getTime()获取当前时间，以毫秒计  60*60*24*1000一天总共毫秒
        System.out.println(date2.toLocaleString());
        //2. before()和after() 判断两个时间的先后，返回boolean值
        boolean b1=date1.before(date2);
        System.out.println(b1);
        boolean b2=date1.after(date2);
        System.out.println(b2);
        //3. compareTo()比较两个时间大小，以毫秒比较，大返回1，小返回-1，相等为0
        int d=date1.compareTo(date2);
        System.out.println(d);
        //4. equals() 判断两个时间是否相等，返回Boolean值
        boolean b3=date1.equals(date2);
        System.out.println(b3);
    }
}

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

import java.util.Calendar;
import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        //1. 创建calendar对象
        // Calendar.getInstance()依据当前时区创建默认的Calendar对象
        Calendar calendar=Calendar.getInstance();//不能使用new创建对象
        System.out.println(calendar.getTime().toLocaleString());//calendar.getTime()依据Calendar类创建一个Data类
        System.out.println(calendar.getTimeInMillis());//calendar.getTimeInMillis()返回毫秒计的calendar时间
        //2. 获取时间信息
        int year=calendar.get(Calendar.YEAR);//年
        int month=calendar.get(Calendar.MONTH);//月 注意该方法返回的月份为0~11月
        int day=calendar.get(Calendar.DATE);//日 Calendar.DAY_OF_MONTH或alendar.DATE
        int hour=calendar.get(Calendar.HOUR_OF_DAY);//时 Calendar.HOUR_OF_DAY 24小时值; Calendar.HOUR 12小时值
        int minute=calendar.get(Calendar.MINUTE);//分
        int second=calendar.get(Calendar.SECOND);//秒
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
        //3. 修改时间 calendar2.set()
        Calendar calendar2=Calendar.getInstance();
        //修改月份
        calendar2.set(Calendar.MONTH,4);//注意此处月份仍是从0开始
        //修改日期
        calendar2.set(Calendar.DAY_OF_MONTH,10);
        System.out.println(calendar2.getTime().toLocaleString());
        //4. add方法修改时间
        calendar2.add(Calendar.HOUR,-1);//-1表示值减1，正数表示值增加
        System.out.println(calendar2.getTime().toLocaleString());
        //5. 获得时间的最大值和最小值
        int max=calendar.getActualMaximum(Calendar.DAY_OF_MONTH);//月份天数最大值
        int min=calendar.getActualMinimum(Calendar.DAY_OF_MONTH);//月份最小值
        System.out.println("当月最多有"+max+"天，"+"最少有"+min+"天");
    }
}

6.3 SimpleDateFormat类

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

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

public class Demo {
    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();

        //3. 格式化date(将date对象转换为sdf指定格式的字符串)
        String str=sdf.format(date);
        System.out.println(str);

        //4. 解析(把字符串转成data对象的日期)
        Date date1=sdf.parse("1996/03/20 08-45-55");
        System.out.println(date1.toLocaleString());

    }
}

7. System类

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

public class Demo {
    public static void main(String[] args){
        //1. 数组复制System.arraycopy(src,srcPos,dest,destPos,length)
        //Arrays.copyOf()内部调用的也是System.arraycopy()
        //src--源数组,srcPos--从哪个位置开始复制,dest--目标数组,destPos--目标数组的位置,length--复制的长度
        int[] arr={20,14,34,23,17,17};
        int[] dest=new int[arr.length];
        System.arraycopy(arr,2,dest,2,4);
        for (int i : dest) {
            System.out.print(i+" ");
        }
        //2. System.currentTimeMillis()获取当前系统时间，单位毫秒
        long start=System.currentTimeMillis();
        for(int i=-999999;i<9999999;i++){
            for(int j=-999999;j<9999999;j++){
                int result=i+j;
            }
        }
        long end=System.currentTimeMillis();
        System.out.println();
        System.out.println("用时："+(end-start));
        //3.System.gc() 告诉垃圾回收
        //4. System.exit 退出jvm
        System.exit(0);//0 正常退出; 非0 异常退出
        System.out.println("程序结束了");
    }
}

8. 总结

内部类：
- 在一个类的内部在定义一个完整的类
- 成员内部类、静态内部类、局部内部类、匿名内部类
Object类：
- 所有类的直接或间接父类，可存储任何对象
包装类：
- 基本数据类型所对应的引用数据类型，可以使Object统一所有数据
String类：
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享
BigDecimal：
- 可精确计算浮点数

标签：常用,Java,String,int,System,println,public,out
来源： https://www.cnblogs.com/ray93/p/16293909.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9