常用类

Object 类

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

getClass() 方法

  • public final Class<?> getClass(){}
  • 返回引用中存储的实际对象类型,返回值是class类型;
  • 应用:通常用于判断两个引用中实际存储对象类型是否一致
Person s1 = new Person();
Class c = s1.getClass();
----执行结果------
class com.chen.Demo01.Person

hashCode()方法

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

toString()方法

  • public String toSring(){}
  • 返回该对象的字符串表示(表现形式)
  • 可以根据程序需求覆盖(重写)该方法 ,快捷键 Ctrl+O
Person s1 = new Person();
System.out.println(s1.toString());
-------执行结果-------------
com.chen.Demo01.Person@74a14482  // 直接打印 包+类名+哈希值

equals()方法

  • public boolean equals(Object obj){}
  • 默认实现 比较两个对象地址是否相同
  • 可进行覆盖,比较两个对象的内容是否相同
Student s4 = new Strudent("小明", 17);
Student s5 = new Strudent("小明", 17);
Student s6 =s5;
System.out.println(s4.equals(s5)); // false 堆中地址不同
System.out.println(s6.equals(s5)); // true

// 重写 改变其比较内容
/*
步骤  1. 比较两个应用是否指向同一个对象
     2. 判断obj是否为null
     3. 判断两个引用只想的实际对象类型是否一致
     4. 强制类型转换
     5. 依次比较各个属性值是否相同
*/

@override
public boolean equals(Object obj){
  // 1.
  if(this == obj){    //this和obj 都是对象
    return true;
  }
  // 2.
  if(obj == null){
    return false;
  }
  // 3.
  // if(this.getClass() == obj.getClass()){
  //
  // }
  // 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() 方法

  • 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
  • 垃圾对象:没有有效引用指向此对象时,为垃圾对象
  • 垃圾回收:由gc销毁垃圾对象,释放数据存储空间
  • 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
  • 手动回收机制:使用System.gc();通知JVM执行垃圾回收
@Override    // 在 Student 类中被重写
protected void finalize() throws Throwable{
  System.out.println(this.name + "对象被回收了");
}

public static void main(String[] args){
  Student s1 = new Student("aaa", 29);  // 不是垃圾
  new Student("bbb", 30);   // 是垃圾 会被回收
  System.gc();  //回收垃圾
  System.out.println("回收垃圾");
}
------执行结果--------
 回收垃圾
 bbb对象被回收了

包装类

  • 基本数据类型所对应的引用数据类型
  • Object 可统一所有数据,包装类的默认值是null
基本数据类型 包装类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character

类型转换与装箱、拆箱

  • 8种包装类提供不用类型间的转换方式:
    1. Number父类中提供的6 个共性方法
    2. parseXXX( )静态方法 :返回XXX类型
    3. valueOf( )静态方法:返回Integer对象
  • 注意:需保证类型兼容,除数字之外不要有其它字符,否则抛出NumberFormatException异常
 public static void main(String[] args){
    // 装箱, 基本类型 → 引用类型
    int num1 = 18;
    Integer integer1 = new Integer(num1);
    Integer integer2 = Integer.valueOf(num1);

    // 拆箱, 引用类型 → 基本类型
    int num = 100;
    Integer integer3 = new Integer(num);
    int num2 = integer3.intValue();//Number父类中方法
    // 上述为jdk1.5之前方法,之后提供了自动装箱拆箱

    int age = 30;
    // 自动装箱
    Integer integer4 = age;
    // 自动拆箱
    int age2 = integer4;

    // 基本类型和字符串之间转换
    // 1. 基本类型转成字符串
    int n1 = 8;
    // 1.1 使用+号
    String s1 = n1 + "";
    // 1.2 使用Integer中的toString()方法
    String s2 = Integer.toString(n1);
    String s3 = Integer.toString(n1, 2); // x为进制数,将n1转换为x进制数并转换为字符串
    String s4 = Integer.toBinaryString(n1);//与上一行同义
    // 2. 字符串转成基本类型
    String str = "150";
    // 使用Integer.parseXXX();
    int n2 = Integer.parseInt(str);

    // boolean 字符串形式转成基本类型,"true" ---> true     非“true" ———> false
    String str2 = "true";
    boolean b1 = Boolean.parseBoolean(str2);
}

Integer缓冲区

  • Java预先创建了256个常用的整数包装类型对象
  • 在实际应用当中,对已创建的对象进行复用
 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.valueOf();
        Integer integer4 = 100;                   //自动装箱
        System.out.println(integer3 == integer4); // true

        Integer integer5 = 200;                   //自动装箱
        Integer integer6 = 200;                   //自动装箱
        System.out.println(integer5 == integer6); // false
        // 因为缓存区数组 [-128, 127] 在这之内 地址 一样
    }

String 类

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

  • 操作量较少时使用

  • 字符串字面值存储在字符串池中,可以共享,使用字符串赋值String name=“zhangsan”,程序先检查字符串常量池中有没有这个常量,如果有,无需创建直接共享,如果没有,重新创建。

  • String s = "Hello";"Hello"常量存储在字符串池中

  • String s = "Hello";产生一个对象,字符串池中存储

  • String s = new String("Hello"); 产生两个对象,堆、池各一个

  •     String str="";
        for (int i = 0; i <99999; i++) {
            str+=i;                //使用 + 进行拼接
        }
      
        StringBuilder str=new StringBuilder();
        for (int i = 0; i <99999; i++) {
            str.append(i);
        }
        System.out.println(str);//   二者结果一样,但后者花费时间少
    
            String s=1+2+"a";  //  3a
            String s3="a"+1+2; //  a12
            int s1=1+2+'a';    //  100 字符当做数字
            int s2='a'+1+2;    //  100 字符当做数字
    

常用方法

 public static void main(String[] args) {

        String str=new String("java");
        String str2=new String("java");
        System.out.println(str == str2);//false 方法区常量池中”java“是同一个,但堆中对象不是同一个
        System.out.println(str.equals(str2));// true  比较的是数据“java”,而不是地址

// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串

        String content = "java是最好的语言";
        System.out.println(content.length()); // 10
        System.out.println(content.charAt(content.length() - 1)); // 言
        System.out.println(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应字符数组  char[]
// 5. indexOf(); 返回该字符串首次出现的位置   的字符串首位
// 6. lastIndexOf(); 返回该字符串最后一次出现的位置   的字符串首位

        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.toCharArray());
        System.out.println(content.indexOf("java")); // 0
        System.out.println(content.indexOf("好", 4)); // 从索引4开始找 返回6
        System.out.println(content.lastIndexOf("java")); // 0

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头

        String ct = " hello world ";
        System.out.println(ct.trim()); // "hello world"
        System.out.println(ct.toUpperCase()); // " HELLO WORLD "
        System.out.println(ct.toLowerCase()); // " hello world "
        System.out.println(ct.endsWith(" ")); // true  空格也算字符
        System.out.println(ct.startsWith("hello")); // false

// 10. replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分

        System.out.println(content.replace("java", "php")); // ”php是最好的语言“

        String say = "java is the best language";
        String[] arr = say.split(" ");// "[ ,]+" 表示空格或逗号切分 +表示切分可以多个 比如多个空格
        System.out.println(arr.length); // 5
        for(String st : arr){
            System.out.println(st);
        }

        //java
        //is
        //the
        //best
        //language

        // equals/compareTo();比较大小
        // compareTo(); 两字符不同比较字符ascii码,字符相同时比较长度并返回差值
        String s1 = "hello";
        String s2 = "HELLO";
        String s3 = "HELLO,World!";
        System.out.println(s1.equalsIgnoreCase(s2));// 忽略大小写比较  true
        System.out.println(s1.equals(s2));// false

        System.out.println(s1.compareTo(s2));// 32 ascii码:h-H  如果第一位相同,继续比较第二位
        System.out.println(s1.compareToIgnoreCase(s2));// 0   代表完全相同

        System.out.println(s3.compareTo(s2));// 7   字符相同,返回长度差值 s3-s2
        System.out.println(s3.compareToIgnoreCase(s2));// 7   字符相同,返回长度差值 s3-s2
    }

案例演示

需求:

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

可变字符串

  • StringBuffer : 可变长字符串,运行效率慢、线程安全,多线程数据量大时使用

  • StringBuilder : 可边长字符串、运行效率快、线程不安全,单线程数据量大时使用

  • 二者效率都比String高且节省内存

  • StringBuffer 事先开辟好缓冲区,直接在缓冲区中进行操作,所以效率高而且省内存

  • 二者仅仅在线程安全方面有区别

  • 单线程情况下,优先用StringBuilder

 public static void main(String[] args){
        // StringBuffer 和 StringBuilder 用法一致
        StringBuffer sb = new StringBuffer();
        System.out.println(sb);//  ""
        // 1. append(); 追加
        sb.append("java no1");
        System.out.println(sb);  //"java no1"
        System.out.println(sb.toString());  //"java no1"
        // 2. insert(); 插入
        sb.insert(0, "在第一个位置插入");
        System.out.println(sb);  // "在第一个位置插入java no1"
        // 3.replace(); 替换
        sb.replace(0, 9, "chenshubo"); // 左闭右开
        System.out.println(sb);  // "chenshuboava no1"
        // 4. delete(); 删除
        sb.delete(0, 5); // 左闭右开
        System.out.println(sb);  // "huboava no1"
        // 5. 清空
        sb.delete(0, sb.length());
        System.out.println(sb);  //  ""
    }

BigDecimal 类

  • float和double在内存存储的都是近似值
  • 位置 java.math 包中
  • 作用:精确计算浮点数
  • 创建方式 BigDecimal bd = new BigDecimal("1.0");
        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"),
                6, BigDecimal.ROUND_HALF_UP);
        System.out.println(r4); // 1.000000  保留6位小数
        // 除不尽时 填保留位数    最后的参数为四舍五入之意

Date 类

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

时间单位:1s = 1,000ms = 1,000,000 μs = 1,000,000,000 ns

        // 创建Date对象
        Date date1 = new Date(); // 无参构造 默认当前时间,精确到毫秒
        System.out.println(date1);//  Mon Jun 21 16:46:30 CST 2021
        System.out.println(date1.toString()); //  Mon Jun 21 16:46:30 CST 2021
        System.out.println(date1.toLocaleString()); // 已过时 但也能用  2021-6-21 16:46:30

    // 创建昨天对象  有参构造方法:Date(long date);date表示从1970.1.1 00:00:00 GMT以来的指定毫秒数
        Date date2 = new Date(date1.getTime() - (60*60*24*1000));
        // getTime(); 获得此对象从1970.1.1 00:00:00 GMT以来的指定毫秒数
        System.out.println(date2.toLocaleString());// 2021-6-20 16:46:30

        // 方法 after();  before();
        boolean b1 = date1.after(date2);
        System.out.println(b1); //true
        boolean b2 = date1.before(date2);
        System.out.println(b2); //false

        // 比较compareTo(); 比较毫秒数
        int d = date1.compareTo(date1);
        System.out.println(d); // 大的为 1 小的为 -1  相同为 0

        // 比较是否相等 equals();
        boolean b3 = date1.equals(date2);
        System.out.println(b3); // false

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设置此日历时间
Date getTime() 返回一个date表示此日历的时间
void add(int field, int amount) 按照日历的规则,给指定字段添加或减少时间量
long getTimeInMilles() 毫秒为单位返回该日历的时间值;1970.1.1 00:00:00
        // 1. 创建 Calendar 对象
        Calendar calendar = Calendar.getInstance();
        //getInstance();使用当前时间获得一个calendar对象   
        System.out.println(calendar);
        //java.util.GregorianCalendar[time=1624273386200,areFieldsSet=true...
        System.out.println(calendar.getTime());// calendar.getTime(); 返回Date对象
        System.out.println(calendar.getTime().toLocaleString());
        // 2. 获取时间信息
        // 获取年
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);
        // 获取月   从 0 - 11
        int month = calendar.get(Calendar.MONTH);
        System.out.println(month);
        // 日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        // 小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY 24制   HOUR 12制
        System.out.println(hour);
        // 分钟
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println(minute);
        // 秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(second);
        // 3. 修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 3);// 直接设置为3
        System.out.println(calendar2.getTime().toLocaleString());
        // 4. add修改时间
        calendar2.add(Calendar.HOUR, 2); // 正就加 负就减
        System.out.println(calendar2.getTime().toLocaleString());
        // 5. 补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        // 给定此calendar2的时间值,返回指定日历字段可能拥有的最大值
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        // 给定此calendar2的时间值,返回指定日历字段可能拥有的最小值 
        System.out.println(max);// 30  当时是6月
        System.out.println(min);// 1

SimpleDateFormat

  • SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
  • 进行格式化(日期→文本)、解析(文本→日期)
  • 常用的时间模式字母
字母 日期或时间 示例
y 2019
08 年中月份 08
d 月中天数 10
H 一天中小时(0-23) 22
m 分钟 16
s 59
S 毫秒 356
            // 1. 创建对象
            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);  //2021年06月21日 20:23:11
            // 解析(字符串→日期)
            Date date2 = sdf.parse("2021年06月21日 21:23:25");
            System.out.println(date2.toLocaleString());// 2021-6-21 21:23:25

System类

主要用于获取系统的属性数据和其他操作,因为构造方法私有的,所以用的时候不需要创建对象;其中属性与方法为静态,所以直接用 System. 调用即可。

方法名 说明
static void arraycopy( Object src , int srcPos , Object dest , int destPos , int length ) 复制数组
static long currentTimeMillis(); 获取当前系统时间,返回毫秒值
static void gc(); 建议jvm赶快启动垃圾回收器回收垃圾
static void exit(int status); 退出jvm;如果参数是0表示正常退出;jvm 非0表示异常退出;退出后后面语句不会被执行
        int[] arr = {20, 18, 39, 3};
        int[] dest = new int [4];  //  默认是0
        System.arraycopy(arr, 1, dest, 0, 3);
        //src-原数组
        // srcPos-从哪个位置开始复制
        // dest-目标数组
        // destPos-在目标数组的起始位置
        // length-复制的长度
        for (int i = 0; i <4 ; i++) {
            System.out.print(dest[i]);//18,39,3,0
        }
posted @ 2021-06-22 14:02  bobochen  阅读(50)  评论(0)    收藏  举报