Java-常用类

Java常用类

内部类

• 内部类定义

  • 在一个类的内部再定义一个完整的类

  • 内部类编译之后，可生成独立的字节码文件

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

• 成员内部类

  • 该类与外部类中的变量和方法地位相同
  • 创建成员内部类时，先实例化外部类，再实例化内部类

  Outer outer = new Outer();
  Inner inner = outer.new Inner();
  

  • 成员内部类与外部类属性相同时，访问外部类属性时

  Outer.this.属性
  

  • 成员内部类中不能包含静态成员，但可以有静态常量。

• 静态内部类

  • 不依赖于外部类对象，可以直接创建或者通过类名访问，类中可以有静态成员

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

  • 级别与外部类相同
  • 静态内部类中调用外部类中的属性

  Outer outer = new Outer();  --先实例化外部类
  outer.外部类属性
  

  • 静态内部类访问类中的静态属性

  Inner.内部类属性
  

  • 只有内部类才能有static修饰

• 局部内部类

  • 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
  • 不能加任何访问修饰符，级别同局部变量
  • 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final

  package innerClass;
  
  public class LocalInnerClass {
      private int age;
      private String name;
      
      public void show(){
          String address = "南京";
          
          //不加修饰符，级别同局部变量
          class Inner{
              private String phone;
              //不能声明静态成员，但可以声明静态常量
              private static final int count = 0;
              
              public void display(){
                  //访问外部类的属性:Outer.this.age
                  System.out.println(age);
                  //访问内部类属性:this.phone
                  System.out.println(phone);
                  //访问局部变量，JDK1.7要求，局部变量必须为常量，JDK1.8局部变量自动添加final
                  System.out.println(address);
              }
          }
          //局部内部类的使用范围为方法中
          Inner inner = new Inner();
          inner.display();
      }
  }
  

• 匿名内部类

  • 没有类名的局部内部类（一切特征与局部内部类相同）
  • 必须继承一个父类或者实现一个接口

  Usb为一个接口：

  Usb usb = new Usb(){
      @Override
      public void show(){
          //
      }
  }
  

Object类

• 所有类的父类，默认继承

• Object类方法：

  • getClasss():通常判断两个引用中实际存储对象类型是否一致

  • hashCode():返回该对象的哈希码值

  • toString()；返回该对象的字符串形式（完整的类路径+哈希值）。可以根据程序需求覆盖该方法，如：展示对象的各个属性值。

    @Override
    public String toString(){
        return "姓名："+name+"\n""年龄："+age
    }
    

  • equals():比较两个对象地址是否相同。可进行重写，比较两个对象内容是否相同。

    @Override
    public boolean equals(Object obj){
        //判断对象的地址是否相同
        if(this == obj){
            return true;
    	}
        //判断对象是否为空
        if(obj == null){
            return false;
        }
        //判断对象是否属于同一类型
        if(obj instanceof Student){
            //强制类型转化
            Student stu = (Student)obj
            //判断对象内容是否相同
            if(stu.name.equals(this.name) && this.age == stu.age){
                return true;
            }
        }
        return false;
    }
    

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

    • 垃圾对象：没有有效引用指向此对象时，为垃圾对象
    • 垃圾回收：由GC销毁垃圾对象，释放数据的存储空间
    • 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
    • 手动回收机制：使用System.gc()，通知JVM执行垃圾回收

包装类

• 定义：基本数据类型所对应的引用数据类型。默认值为null。

• 基本数据类型对应的包装类型：byte->Byte,short->Short,int->Integer,long->Long,float->Float,double->Double,boolean->Boolean,char->Character

• 类型转换与装箱、拆箱：基本->引用（装箱），引用->基本（拆箱）(Xlad反编译软件，class文件->java)

  //JDK1.5之前，装箱和拆箱
  int age = 10;
  Integer interger1 = new Integer(age);//装箱方法一
  Integet integer2 = Integer.valueof(age);//装箱方法二
  
  Integer integer3 = new Integer(10);
  int num = integer3.intValue();//拆箱
  
  //JDK1.5之后，装箱和拆箱
  Integer integer4 = age; //装箱
  int num1 = innteger4;//拆箱
  

• 基本类型和字符串之间的转换

  //基本数据类型->字符串
  int age = 10;
  String str1 = age+"";//第一种方法
  String str2 = Integer.toString(age);//第二种方法
  
  //字符串->基本数据类型
  int age1 = Integer.parseInt(str1);
  
  //boolean字符串转换为基本类型，“true”->true,非“true”都为false
  String res = "true";
  boolean b = Boolean.parseBoolean(res);//true
  String res = "dds";
  boolean b = Boolean.parseBoolean(res);//false
  

• 整数缓冲区：Java预先创建了256个（-127-128）常用的整数包装类型对象

Integer integer1 = 100;//Integer integer1 =Integer.valueof(100);
Integer integer1 = 100;
System.out.println(integer1 == integer2)//true

Integer integer1 = 200;//Integer integer1 =Integer.valueof(200);
Integer integer1 = 200;
System.out.println(integer1 == integer2)//false

String类

• 字符串是常量，创建之后，不可更改（不能修改数据，可以更改内存地址）。存储在方法区的常量池中，可以被共享

• String str = new String(“hello”);堆和常量池各创建一个对象

• 常用方法：

  • public int length();返回字符串的长度

  • public char charAt(int index):根据下标获取字符

  • public boolean contain(String str):判断当前字符串是否包含str

  • public char[] toCharArray():将字符串转换为数组

  • public int indexOf(String str):查找str首次出现的下标，存在，返回该下标，不存在，则返回-1

  • public int lastIndexOf(String str)::查找str最后一次出现的下标

  • public String trim();//去除字符串前后空格

  • public String toUpperCase():将小写转换为大写，toLowerCase();大写转换为小写

  • public boolean endsWith(String str):判断字符串是否以str结尾.startsWith():以什么开始

  • public String replace(char oldChar,char newChar):新字符或字符串替换旧字符或字符串

  • public String[] split(String str):根据str做拆分。split("[ ,]+")//空格和逗号可以出现一个或多个

  • equals:比较两个字符串是否相等。equalsIgnoreCase()：忽略大小写的比较

  • compareTo():比较两个字符串的大小。(字典表的位置比较)

    String str1 = "abc";//a-97
    String str2 = "xyz";//x-120
    str1.compareTo(str2);//-23
    
    String str1 = "abc";
    String str2 = "abcxyz";
    str1.compareTo(str2);-3,比较长度
    

  package string;
  
  import java.util.Arrays;
  
  public class StringMethod {
      public static void main(String[] args) {
  
          String str = "this is a text";
          String res = "";
  
          //提取字符串中的每个单词
          String[] strArray = str.split(" ");
          for (String s : strArray) {
              System.out.println(s);
          }
  
          //替换字符串中的内容
          String strReplace = str.replace("text","picture");
          System.out.println(strReplace);
  
          //插入字符串
          String strInsert= str.replace("text","easy text");
          System.out.println(strInsert);
  
          //将字符串中的每个单词大写
          for (int i = 0; i < strArray.length; i++) {
              char first = strArray[i].charAt(0);
              char upperfirst = Character.toUpperCase(first);
              res +=upperfirst+strArray[i].substring(1)+' ';//截取字符串
          }
          System.out.println(res);
      }
  }
  

• 可变字符串：

  • StringBuffer:可变长字符串，JDK1.0提供，运行效率慢，线程安全。比String的运行效率高
    • append:追加字符串
    • insert:任意位置插入字符串
    • replace:替换字符串，replace(start,end,str),含头不含尾。
    • delete:删除字符串，delete(start,end,),含头不含尾。
  • StringBuilder:可变长字符串，JDK5.0提供，运行效率块，线程不安全
    • append:追加字符串
    • insert:任意位置插入字符串
    • replace:替换字符串，replace(start,end,str),含头不含尾。
    • delete:删除字符串，delete(start,end,),含头不含尾。

BigDecimal类

• 很多实际应用中需要精确运算，而float，double是近似值存储，不能解决需求(例如银行业务），需要借助BigDecimal类

package bigDecimal;

import java.math.BigDecimal;

public class BigDecimalUse {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法：subtract。加法;add。乘法：multiply.divide:除法
        BigDecimal bd3 = bd1.subtract(bd2);
        System.out.println(bd3);

        //divide除不尽时，需设置保留的小数位数，否则报错
       BigDecimal bd4  =  new BigDecimal("10").divide(new BigDecimal("3"),3,BigDecimal.ROUND_HALF_UP);
       System.out.println(bd4);
    }

}

Date

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

package date;

import com.sun.xml.internal.ws.util.xml.CDATA;
import java.util.Date;

public class DateUse {

    public static void main(String[] args) {
        //创建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());

        //方法after和before,比较两个时间的先后顺序
        boolean b = date1.after(date2);
        System.out.println(b);

        //比较compareTo(),毫秒数相减
        int d = date1.compareTo(date2);
        System.out.println(d);

        //equals，比较两个时间是否相等
        boolean b2 = date1.equals(date2);
        System.out.println(b2);

    }
}

Calendar

• Calendar类提供获取设置各种日历字段的方法
• 构造方法protected Calendar():由于修饰符为protected,所以无法直接创建该对象
• 常用方法：
  • static Calendar getInstance():实例化日历
  • void set(int year,int month,int day,int hoyrofday,int minute,int second):设置日历的年，月，日，时，分，秒
  • int get(int field)::返回给定日历字段的值，字段比如年，月，日等
  • void setTime(Date date):用给定的Date设置此日历的时间
  • Date getTime(():返回一个Date表示此日历的时间
  • void add(int field,int amount):按照日历的规则，给指定的字段添加或减少时间量
  • long getTimeMillies():毫秒为单位返回该日历的时间值

package calendar;

import java.util.Calendar;

public class UseCalendar {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal.getTime().toLocaleString());
        //获取年月日时分表
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH);
        int day = cal.get(Calendar.DAY_OF_MONTH);
        int hour = cal.get(Calendar.HOUR_OF_DAY);//HOUR:12小时，HOUR_OF_DAY:24小时
        int minute = cal.get(Calendar.MINUTE);
        int second = cal.get(Calendar.SECOND);
        System.out.println(year+":"+(month+1)+":"+day+":"+hour+":"+minute+":"+second);

        //set方法修改时间
        cal.set(Calendar.DAY_OF_MONTH,7);
        System.out.println(cal.getTime().toLocaleString());

        //add方法修改时间
        cal.add(Calendar.HOUR,-1);
        System.out.println(cal.getTime().toLocaleString());

        //补充方法:当月第一天和最后一天
        int max = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = cal.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max+":"+min);
    }
}

SimpleDateFormat

• 是一个以与语言环境有关的方式格式化日期和解析日期的具体类
• 格式化（日期->文本），解析（文本->日期）

package simpleDateFormat;

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

public class UseSimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        //创建SimpleDateFormat
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        //创建Date对象
        Date date = new Date();

        //格式化:日期->字符串
        String str = sdf.format(date);
        System.out.println(str);

        //解析:字符串->日期
        Date date1 = sdf.parse("1990年10月11日02:02:02");
        System.out.println(date1.toLocaleString());

    }
}

Sysetm类

• 主要获取系统的属性数据和其它操作，构造方法私有
• 常用方法
  • static void arraycopy():复制数组
  • static void surrentTimeMillis():获取当前系统时间，返回的是毫秒值
  • static void gc():建议JVM赶快启动垃圾回收期回收垃圾
  • static void exit(int status):t退出jvm,如果参数是0正常退出非0表示异常退出jvm,

package system;

public class UseSystem {
    public static void main(String[] args) {
        //数组复制
        int[] array = {12,45,13,123,121,31};
        int[] des = new int[6];
        //src:源数组
        //srcPos:开始复制的位置
        //des:目标数组
        //destPro:目标数组开始接收复制数据的位置
        //length:源数组复制的长度
        System.arraycopy(array,0,des,0,array.length);
        for (int de : des) {
            System.out.println(de);
        }

        //获取当前时间,返回毫秒，用于计时
        long time = System.currentTimeMillis();
        System.out.println(time);

        //垃圾回收
        new Student("hddd");
        new Student("ssss");
        new Student("frrg");
        System.gc();

        //退出jvm
        System.exit(0);
        System.out.println("wdcevh");
    }
}