Java常用类

内部类

在一个类的内部再定义类

public class Body {
    class Header{
        
    }
}

特点：

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

成员内部类

创建内部类对象时，必须依赖外部类对象

public class Outer {
    private String name = "张三";
    private int age = 20;
    
    class Inner {
        private String address = "北京";
        private String phone = "110";
        
        public void show() {
            System.out.println(name);
            System.out.println(age);
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        
        //Inner inner = new Outer().new Inner();
        
        inner.show();
    }
}
//当外部类、内部类存在重名属性时，优先访问内部类，如要访问外部类Outer.this.name

成员内部类不能定义静态成员，可以包含静态常量

静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员

public class Outer {
    private String name = "xxx";
    private int age = 18;
    
    static class Inner { //级别和外部类相同
        private String address = "上海";
        private String phone = "111";
        private static int count = 1000;
        
        public void show() {
            //调用外部类的属性
            Outer outer = new Outer();
            System.out.println(outer.name);
            System.out.println(outer.age);
            System.out.println(address);
            System.out.println(Inner.count);
        }
    }
}

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

局部内部类

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

public class Outer {
    private String name = "刘德华";
    private int age = 35;
    
    public void show() {
        String address = "深圳";
        //局部内部类
        class Inner {//不能加任何访问修饰符，不能包含静态内部成员
            private String phone = "15588888888";
            private String email = "liudehua@qq.com";
            
            public void show2() {
                 //访问外部类的属性
                System.out.println(name);
                System.out.println(age);
                //访问内部类的属性
                System.out.println(phone);
                System.out.println(email);
                //访问局部变量，jdk1.7要求变量必须是常量final，jdk1.8自动添加final
                System.out.println(address);
            }
        }
        Inner inner = new Inner();
        inner.show2();
    }
}

public class Test {
    Outer outer = new Outer();
    outer.show();
}

匿名内部类

没有类名的局部内部类，一切特征都与局部内部类相同

必须继承父类，或者实现一个接口

public interface Usb {
    void service();
}

public class Mouse implements Usb {
    @Override
    public void service() {
        System.out.println("连接电脑成功，鼠标开始工作了")
    }
}

public class Test {
    public static void main(String[] args) {
        /*Usb usb = new Mouse();
        usb.service();*/
        
        //局部内部类
        class Fan implements Usb {
            
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了")
            }
        }
        Usb usb = new Fan();
        usb.service();
        
        //使用匿名内部类优化(相当于创建了一个匿名内部类)
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了")
            }
        };
        usb.service();
    }
}

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

Object类

Object类中所定义的方法，是所有对象都具备的方法

getClass方法

返回引用中存储的实际对象类型

通常用于判断两个引用中实际存储对象类型是否一致

public class Student {
    private String name;
    private int age;
    public Student(){
        
    }
    
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    
    public String getName(){
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 22);
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if(class1==class2) {
            System.out.println("s1和s2属于同一个类型");
        }
        else{
            System.out.println("s1和s2不属于同一个类型");
        }     
        
        
        //hashCode方法
        System.out.println(s1.hashCode());  //366712642
        System.out.println(s2.hashCode());  //182916470
        Student s3 = s1;
        System.out.println(s3.hashCode()); ////366712642
        
        
        //toString方法
        System.out.println(s1.toString()); //包名.类名@15db9742
        System.out.println(s2.toString());
        
        //重写toString
         @Override
        public String toString() {
            return name + ":" + age;  //aaa:20,bbb:22
        } 
        
        
        //equals方法
        System.out.println(s1.equals(s2)); //false
        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);
        System.out.println(s4.equals(s5)); //false
        
        //重写equals方法
        @Override
        public boolean equals(Object obj) {
            if(this==obj){
                return true;
            }
            if(obj==null){
                return false;
            }
            /*if(this.getlass()==obj.getClass()){                
            }*/
            if(obj instanceof Student) {
                Student s = (Student)obj;
                if(this.name.equals(s.getName())&&this.age==s.getAge()) {
                    return true;
                }
            }
        }
        return false;
    }
    
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了"); 
    }
    
}

hashCode方法

public int hashCode(){}

哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码

toString方法

返回该对象的字符串表示，可以根据需求覆盖该方法

equals方法

比较两个对象地址是否相同，可进行覆盖

比较两个对象的内容是否相同

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

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

finalize方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。

垃圾对象：没有有效引用指向此对象时，为垃圾对象

垃圾回收：由GC销毁垃圾对象，释放数据存储空间

自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象

手动回收机制：使用System.gc()；通知JVM执行垃圾回收

public class Test {
    public static void main(String[] args) {
        new Student("aaa",20); //aaa对象被回收了
        new Student("bbb",20);
        new Student("ccc",20);
        new Student("ddd",20);
        new Student("eee",20);
        System.gc();
        Syystem.out.println("回收垃圾")
    }
}

包装类

基本数据类型所对应的引用数据类型

Object可统一所有数据，包装类的默认值是null

//byte->Byte short->Short int->Integer long->Long 
//float->Float double->Double boolean->Boolean char->Character

类型转换与装箱、拆箱

public class Demo1 {
    public static void main(String[] args) {
    	/*int num1 = 18;
        Integer integer1 = new Integer(num1); //装箱
        Integer integer2 = Integer.valueof(num1);
        
        Integer integer3 = new Integer(100); 
        int num3 = integer3.intValue();//拆箱*/
        
        //jdk1.5之后，提供自动装箱和拆箱
        int age = 30;
        Integer integer4 = age;
        
        int age2 = integer4;
    }
}

基本类型和字符串转换

public class Demo2 {
    public static void main(String[] args) {
    	int n1 = 15;
        //1 基本类型转换成字符串
        //1.1 使用+号
        String s1 = n1 + "";
        
        //1.2 使用Integer的toString()方法
        String s2 = Integer.toString(n1);
        String s3 = Integer.toString(n1,16); //16进制
        //toBinaryString(int i)、toHexString(int i)、toOctalString(int i)
        System.out.println(s1);  //15
        System.out.println(s2);  //15
        System.out.println(s3);  //f
        
        //2 字符串转成基本类型
        String str = "150";
        int n2 = Integer.parseInt(str);
        System.out.println(n2);  //150
        
        //boolean字符串形式转成基本类型 "true"--->true
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1); //true 只要str2不为true，就输出false
        
    }
}

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

Integer缓冲区

public class Demo3 {
    public static void main(String[] args) {   	
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2); //false  地址不一样
        
        Integer integer3 = 100; //自动装箱Integer integer3 = Integer.valueof(100);
        Integer integer4 = 100;
        System.out.println(integer3==integer4); //true
        
        Integer integer5 = 200; //自动装箱
        Integer integer6 = 200;
        System.out.println(integer5==integer6); //false 
    }
}

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

String类

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

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

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

public class Demo4 {
    public static void main(String[] args) {   	
        String name = "hello"; //"hello" 常量存储在字符串池中
        name = "zhangsan";//给字符串赋值时，没有修改数据，而重新开辟一个空间
        
        String name2 = "zhangsan";
        
        String str = new String("java");
        String str2 = new String("java");
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//true
    }
}

String常用方法

public class Demo5 {
    public static void main(String[] args) {
        
        
        String content = "java是世界上最好的java编程语言";
        System.out.println(content.length());//返回字符串的长度 19
        System.out.println(content.charAt(content.length()-1));//返回某个位置的字符
        System.out.println(content.contains("java"));//判断是否包含某个子字符串 true
        System.out.println(content.contains("php")); //false
        
        //返回字符串对应的数组  [j,a,v,a,是,世,界,上,最,好,的,j,a,v,a,编,程,语,言]
        System.out.println(Arrays.toString(content.toCharArray()));  
        System.out.println(content.indexOf("java"));//返回子字符串首次出现的位置 0
        System.out.println(content.indexOf("java",4)); //11
        System.out.println(content.lastIndexOf("java"));//返回字符串最后一次出现的位置11
        String content2 = "   hello world   ";
        System.out.println(content2.trim());//去掉字符串前后的空格 hello world
        System.out.println(content2.toUpperCase());//大小写转换   HELLO WORLD
        System.out.println(content2.toLowerCase());
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));//判断是否已str结尾(开头)true
        System.out.println(filename.startsWith("hello")); //true
        
        
        System.out.println(content.replace("java","php"));//替换某个字符或字符串
        //php是世界上最好的php编程语言
        
        String say = "java,is the best programing language";
        String[] arr = say.split(" "); //say.split("[ ,]"); say.split("[ ,]+");
        System.out.println(arr.length);  //6
        for(String string : arr) {
            System.out.println(string);
        }    //对字符串进行拆分
        
        
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true
        
        String s3 = "abc";//97
        String s4 = "xyz";//120
        System.out.println(s3.compareTo(s4)); // -23
        
        String s5 = "abc";
        String s6 = "abcxyz";
        System.out.println(s5.compareTo(s6)); // -3
        
    }
}
//char upperfirst = Character.toUpperCase(first);
String str = "abcd";
str.substring(1);//bcd
str.substring(1,3); //bc

StringBuffer和StringBuilder

StringBuffer：可变长字符串，运行效率慢、线程安全

StringBuilder：可变长字符串，运行效率快，线程不安全

public class Demo6 {
    StringBuffer sb = new StringBuffer();
    
    //1.append();追加
    sb.append("java世界第一");
    System.out.println(sb.toString());//java世界第一
    sb.append("java真香");
    System.out.println(sb.toString());//java世界第一java真香
    
    //2.insert();添加
    sb.insert(0,"我在最前面");
    System.out.println(sb.toString());//我在最前面java世界第一java真香
    
    //3.replace();
    sb.replace(0,5,"hello");
    System.out.println(sb.toString());//hellojava世界第一java真香
    
    //4.delete();
    sb.delete(0,5);
    System.out.println(sb.toString());//java世界第一java真香
    
    //5.清空
    sb.delete(0,sb.length());
    
    //StringBuilder的操作与其一样
    
}

BigDecimal类

public class Demp7 {
    double d1 = 1.0;
    double d2 = 0.9;
    System.out.println(d1-d2);//0.0999999999998
    
    BigDecimal bd1 = new BigDecimal("1.0");
    BigDecimal bd2 = new BigDecimal("0.9");
    BigDecimal r1 = bd1.subtract(bd2);
    System.out.println(r1); //0.1
    
    BigDecimal r2 = bd1.add(bd2);
    System.out.println(r2); //1.9
    
    BigDecimal r3 = bd1.multiply(bd2);
    System.out.println(r3); //0.90
    
    BigDecimal r4 = new BigDecimal("1.4")
        .subtract(new BigDecimal("0.5"))
        .divide(new BigDecimal("0.9"));
    System.out.println(r4); //1
    
}

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

Date类

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

public calss Demo1 {
    public static void main(String[] args) {
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString()); //Sun Mar 07 8:38:47 CST 2021
        System.out.println(date1.toLocalString()); //2021-3-7 8:38:47
        
        //昨天
        Date date2 = new Date(date1.getTime()-60*60*24*1000);
        System.out.println(date2.toLocalString()); //2021-3-6 8:38:47
        
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        
        int d = date1.compateTo(date2); //1 0 -1
        
        boolean b2 = date1.equals(date2);//false
    }
}

Calendar类

//protected Calendar(); 无法直接创建该对象

public class Demo2 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocalString());//2021-3-7 8:58:00
        System.out.println(calendar.getTimeInMillis());
        
        //获取时间信息
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int hour = calendar.get(Calendar.HOUR_OF_DAY); //12小时，HOUR_OF_DAY24 
        int minude = calendar.get(Calendar.MINUTE);
        int second = calenar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
        
        //修改时间
        Calendar calendar2 = calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,6);//昨天
        System.out.println(calendar2.getTime().toLocalString());
        
        //add方法修改时间
        calendar2.add(Calendar.HOUR,1); //加了一个小时
        
        //补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max); //31
        System.out.println(min); //1
    }
}

SimpleDateFormat类

public class Demo3 {
    public static void main(String[] args) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        Date date = new Date();
        
        //格式化Date
        String str = sdf.format(date);
        System.out.println(str); //2021年03月07日09:17:00
        
        //解析 把字符串转成日期
        Date date2 = sdf.parse("2021年03月07日09:17:00")
        
    }
}

System类

public class Demo4 {
    public static void main(String[] args) {
        //复制数组
        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]);
        }
        
        System.out.println(System.currentTimeMillis());
        //计时
        long start = System.currentTimeMillis();
        for(int i = 0; i < 99999999; i++) {
            for(int j = 0; j < 99999999; j++){
                int result = i + j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
        
        //System.gc(); 垃圾回收
        new Student("aaa", 19); //创建之后没被引用的对象被回收
        
        //退出jvm
        System.exit(0);
        System.out.println("程序结束了"); //不被执行
    }
}

posted @ 2021-03-07 09:44 Barrymeng 阅读(76) 评论(0) 收藏举报

刷新页面返回顶部

Barrymeng

Java常用类

Java常用类

内部类

成员内部类

静态内部类

局部内部类

匿名内部类

Object类

getClass方法

hashCode方法

toString方法

equals方法

finalize方法

包装类

类型转换与装箱、拆箱

基本类型和字符串转换

Integer缓冲区

String类

String常用方法

StringBuffer和StringBuilder

BigDecimal类

Date类

Calendar类

SimpleDateFormat类

System类

公告