常用类

Object类

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

getClass（）方法

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

package com.Class.demo01;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",22);
        //判断是s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2属于同一个类型");
        }
    }
}

hashCode（）方法

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

//hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3=s1;
System.out.println(s3.hashCode());

toString（）方法

```
public String toString(){}
```
返回该对象的字符串表示（表现类型）

可以根据程序需求覆盖该方法，如：展示对象各个属性值。

//toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());

重写toString方法：在类中

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

equals（）方法

```
public boolean equals(Object obj){}
```
默认实现为（this==obj），比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。

equals()方法覆盖步骤

idea可直接输入equals快速生成

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

public boolean equals(Object obj){
//判断两个对象是否是同一引用
if (this==obj){
    return true;
}
// 判断obj是否为null
if (obj==null){
    return false;
}
//判断是否为同一个类型
 //if (this.getClass()==obj.getClass())
    if (obj instanceof Student){
        //强制类型转换
        Student s=(Student) obj;
        //比较属性
        if (this.name.equals(s.getName())&&this.age==((Student) obj).age){
            return true;
        }
    }
return false;
}

finalize（）方法

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

package com.Class.demo01;

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

重写finaliza类

protected void finalize() throws Throwable {
    System.out.println(this.name+"对象被回收了");
}

包装类

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

类型转换与装箱、拆箱

把栈里面的变量装到堆里面中变成对象叫装箱
把堆里面的对象拆到栈里面变成变量叫拆箱

package com.Class.demo02;

public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转为引用类型
        //基本类型
        int num1=18;
        //使用Integer类创建对象
        Integer integer = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer);
        System.out.println(integer2);
        //拆箱：引用类型转为基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //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);

        //基本类型和字符串之间的转换
        //1.基本类型转为字符串
        int n1=100;
        //1.1使用+号
        String s1 = n1 + "";
        //1.2使用Integer中的toString（）方法
        String s2 = Integer.toString(n1,8);
        System.out.println(s1);
        System.out.println(s2);
        //2.字符串转为基本类型
        String str="150";
        //使用Integer.paeseXXX（）；
        int n2=Integer.parseInt(str);
        System.out.println(n2);
        //boolean字符串形式转成基本类型."true"====>true 非”true“====》false
        String str2="true";
        boolean b1=Boolean.parseBoolean(str2);
        System.out.println(b1);
    }
}

注意：需要保证类型兼容，否则抛出NumberFormatException异常。

整数缓冲区

Integer.valueOf方法中给创建好了一个范围为-128到127的一个数组，其元素为-128到127的整数对象称位整数缓冲区，为了更方便的释放内存

package com.Class.demo02;

public class Demo02 {
    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 integer4 = 100;
        System.out.println(integer3 == integer4);//true
        //因为自动装箱 相当于调用了Integer.valueOf方法
        //而在valueOf方法中已经给你创建了-128到127范围的数组对象
        //其值为100则去调用缓冲区里已经创建好的对象，所以其内存地址也是一样的所以为true
        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println(integer5 == integer6);//false
        //因为200的值超出了-128到127这个范围，所以他的对象是重新创建的，所以地址不一样
    }
}

String类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池（在方法区）中，可以共享。

package com.Class.String;

public class Demo01 {
    public static void main(String[] args) {
        String name="hello";//"hello"常量存储在字符串池当中，
        name="zhangsan";//”zhangsan“赋值给name变量，给字符串赋值时，并没有修改数据
        //而时在字符串池中重新开辟了一个空间内容为”zhangsan“
        String name2="zhangsan";
        //当在把“zhangsan”重新赋值给一个新的常量时，之间去字符串中找“zhangsan”，并赋值给name2
        System.out.println(name==name2);

        //演示字符串的另一种方式 new String();
        String str = new String("java是最好的语言");//创建了2个对象一个在堆中一个在方法区
        String str2 = new String("java是最好的语言");
        System.out.println(str == str2);

    }
}

常用方法

length（）；返回字符串的长度
charAt（int index）;返回某个位置的字符
contains（String str）；判断是否包含某个子字符串

String name="java是世界上最好的编程语言java";
//字符串方法的使用
System.out.println(name.length());
System.out.println(name.charAt(name.length() - 1));
System.out.println(name.contains("java"));
System.out.println(name.contains("php"));

toCharArray()；将字符转换为数组
indexOf（String str）；查找str首次出现的下标，存在，则返回改下标；不存在，则返回-1；
lastIndexOf（String str）；查找字符串在当前字符串中最后一次出现的下标索引

System.out.println(Arrays.toString(name.toCharArray()));
System.out.println(name.indexOf("言"));
System.out.println(name.indexOf("java",4));
System.out.println(name.lastIndexOf("java"));

trim（）；去掉字符串前后的空格
toUpperCase（）；将小写转为大写
toLowerCase（）；将大写转为小写
endWith（String str）：判断字符串是否以str结尾
startsWith（String str）；判断字符串是否已str开头

String name2="   hello world   ";
System.out.println(name2.trim());
System.out.println(name2.toUpperCase());
System.out.println(name2.toLowerCase());
String name3="hello.world";
System.out.println(name3.endsWith(".world"));
System.out.println(name3.startsWith("hello"));

replace（char oldChar，char newChar）：将旧字符串替换成新字符串
split（String str）：根据str拆分。

System.out.println(name.replace("java", "php"));
String say="java is the best programing language";
String[] s = say.split(" ");
System.out.println(s.length);
for (String s1:s){
    System.out.println(s1);
}

补充：equals、compareTo（）；比较大小

equalsIgnoreCase忽略大小写的比较

package com.Class.String;

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        String str="this is a text";
        //1.将str中的单词单独获取出来
        System.out.println(Arrays.toString(str.split(" ")));
        //2.将str中的text替换成practice
        String replace = str.replace("text", "practice");
        System.out.println(replace);
        //3.在text前面插入一个easy
        String replace1 = str.replace("text", "ease text");
        System.out.println(replace1);
        //4.将每个单词的首字母变成大写
        String[] s = str.split(" ");
        for (int i = 0; i < s.length; i++) {//遍历数组
            char c=s[i].charAt(0);//获取第一个单词
            char c1 = Character.toUpperCase(c);//转为大写
            String news=c1+s[i].substring(1);//拼接，substring截取
            System.out.print(news+" ");
        }
    }
}

可变字符串

StringBuffer：可变长字符串,JDK1.0提供，运行效率慢、线程安全
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。

区别：

比String效率要高
比String节省内存

StringBuffer和StringBuilder方法公用

package com.Class.String;

public class Demo04 {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        //1 append()；追加
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java无可匹敌");
        System.out.println(sb.toString());
        //2 insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());
        //3 replace（）;替换
        sb.replace(0,5,"hell0");
        System.out.println(sb.toString());
        //delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());
    }
}

BigDecimal

位置：Java.math包中
作用：精确计算浮点数
创建方式：BigDecimal bd=new BigDecimal（“1.0”）
减法：subtract（）；类之间

BigDecimal subtract = bigDecimal.subtract(bigDecimal2);
System.out.println(subtract);

加法：add（）；类之间

BigDecimal subtract2 = bigDecimal.add(bigDecimal2);
System.out.println(subtract2);

乘法：multiple（）；

BigDecimal subtract3 = bigDecimal.multiply(bigDecimal2);
System.out.println(subtract3);

除法：divide（BigDecimal bd，int scal，RoundingMode mode）；
参数scal：指定精确到小数点后几位
参数mode：
- 指定小数部分的取舍模式，通常采用四舍五入的模式
- 取值为BigDecimal.ROUND_HALF_UP.

BigDecimal subtract4=new BigDecimal("1.4")
        .subtract(new BigDecimal("0.5"))
        .divide(new BigDecimal("0.9"));
System.out.println(subtract4);

Date

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

package com.Class.Date;

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //今天
        Date date = new Date();
        System.out.println(date.toString());
        //昨天
        Date date2 = new Date(date.getTime()-(60*60*24*1000));
        System.out.println(date2.toString());
        //2方法 after before
        boolean after = date.after(date2);
        System.out.println(after);
        boolean after2 = date.before(date2);
        System.out.println(after2);
        //比较compareTo();
        int i = date.compareTo(date2);
        System.out.println(i);
        //比较是否相等equals（）
        boolean equals = date.equals(date2);
        System.out.println(equals);
    }
}

Calendar

Calendar提供了获取或设置各种日历字段的方法
构造方法
- protected Calendar（）：由于修饰符是protected，多以无法直接创建对象。

package com.Class.Calendar;

import java.util.Calendar;

public class Demo01 {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar instance = Calendar.getInstance();
        System.out.println(instance.getTime());
        System.out.println(instance.getTimeInMillis());//毫秒值
        //2获取时间信息
        //获取年
        int year=instance.get(Calendar.YEAR);
        //获取月 月的初始值为0所以输出时要+1
        int month=instance.get(Calendar.MONTH);
        //获取日
        int day=instance.get(Calendar.DAY_OF_MONTH);
        //获取小时
        int hour=instance.get(Calendar.HOUR_OF_DAY);
        //获取分钟
        int minute=instance.get(Calendar.MINUTE);
        //获取秒
        int second=instance.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
        //修改时间
        Calendar instance1 = Calendar.getInstance();
        instance1.set(Calendar.DAY_OF_MONTH,24);
        System.out.println(instance1.getTime().toLocaleString());
        //add加时间,若减时间则给-值
        instance1.add(Calendar.HOUR,1);
        System.out.println(instance1.getTime().toLocaleString());
        //补充方法
        int max=instance1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min=instance1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat

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

package com.Class.SimpleDateFormat;

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

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        //创建Date
        Date date=new Date();
        //格式化date 把时间转为字符串
        String str = sdf.format(date);
        System.out.println(str);
        //解析 把字符串转成时间
        Date parse = sdf.parse("1990/05/01");
        System.out.println(parse);
    }
}

System类

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

数组的复制：arraycopy（src,srcPos,dest,destPos,length）；

src：源数组
srcPos：从那个位置开始复制0
dest：目标数组
destPos：目标数组的位置
length：复制的长度

package com.Class.System;

public class Demo01 {
    public static void main(String[] args) {
        //arraycopy:数组的复制
        int[] arr={18,20,17,35,55};
        int[] dest=new int[5];
        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());

    }
}

posted @ 2020-12-23 23:33 酷酷的西瓜皮阅读(182) 评论(0) 收藏举报

刷新页面返回顶部

酷酷的西瓜皮

常用类

常用类