【实训笔记】第五天：常用类

 

目录

常用类

1、Object类

2、包装类

3、日期相关的类(会用即可)

4、可变参数 

---

常用类

常用的包java.lang包：该包是java语言的核心包，并且该包中的所有内容都由java虚拟机自动导入。
如:System类、String类...
java.util包：该包是java语言的工具包，里面提供了大量工具类以及集合类。
如:scanner类、Random类、List集合...
java.io包-该包是java语言中的输入输出包，里面提供了大量读写文件相关的类。
如:FiieInputstream类.Fileoutputstream类...
java.net包-该包是java语言中的网络包，里面提供了大量网络编程相关的类，
如:ServerSocket类.Socket类.。。

1、Object类

(1)基本概念java.lang.Object类是java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类
(2)常用的方法(重点)
boolean equals(Objec obj)
用于判断调用对象是否与参数对象根等
该方法默认比效较两个对象的地址，与==的效果等价
若希望比较两个对象的内容，则需要重写该方法
若该方法重写时，应该重写hashCode方法
Int hashCode()
用于获取调用对象的哈希码(内存地址的编号)
若两个对象调用equals方法的结果相同，则各自调用hashCode方法的数值必须相等
若两个对象调用equals方法的结黑不同，则各自调用hashCode方法的数值应该不相等
String toString()
用于返回调用对象的字符串形式
默认字符串的内容有:包名.类名@哈希吗值的无符号十六进制形式
为了返回更有意义的数据内容需要重写该方法
使用print()或println()打印或+拼接时，都会自动调用toString方法

package com.java.object01;

/**
 * @author zn
 * 编程实现Student类的封装，特征
 */
public class Student {
    private String name;
    private int id;

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

    //    @Override
//    public boolean equals(Object o){
//        return this.getId() == ((Student)o).getId();
//    }
    @Override
    public boolean equals(Object o){
        //表示两个引用指向同一个地址
        if(this == o){
            return true;
        }
        if(null == o){
            return false;
        }
        //判断o是否是Student类或是否是子类的实例
        if(o instanceof Student){
            Student student = (Student) o;
            if (this.getName().equals(student.getName()) && this.getId() == student.getId()){
                return true;
            }
        }
        return false;
    }

    public Student() {
    }

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



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}

package com.java.object01;

/**
 * @author zn
 * == 和 equals()
 * ==：基本数据类型，比较的是数值的大小
 *     引用数据类型，比较的是引用的地址
 * equals()：默认比较两个对象的地址，若想要比较两个对象的内容时，需要重写这个方法
 */

public class StudentTest {
    public static void main(String[] args) {
        //new出来的对象，引用地址肯定不一样
        Student student1 = new Student("张三", 1001);
        Student student2 = new Student("张三", 1001);
        //  false
        System.out.println(student1);
        //  false
        System.out.println(student1.equals(student2));
    }

}

2、包装类

Person p = new Person()：表示声明Person类型的引用指向Person类型的对象，p代表对象int num = 10：-表示声明一个int类型的变量num初始值为10，num不代表对象，Java语言是一门纯面向对象的编程语言，万物皆对象！

包装类的概念：通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。

常用的包装类：int => java.lang.Integer类 char => java.lang.Character类 其它类型都是将首字母改为大写即可

Integer类

(1)基本概念：java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到string类之间的转换等方法。

(2)常用的方法
Integer(int value)：根据参数指定的整数来构造对象
Inteqer(String s)：根据参数指定的字符串来构造对象
int intValue()：获取调用对象中的整数值并返回
static Integer valueOf：根据参数指定整数值得到Integer类型对象
static int parseInt(Stxing s)：将字符串类型转换为int类型并返回
注意:JDK5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱“和“装箱"换作，JDK5增加了自动"装箱和拆箱”的功能

public class IntegerDemo01 {
    public static void main(String[] args) {
        //根据参数指定的整数来构造对象
        Integer it1 = new Integer(10);
        System.out.println("it1 = " + it1);
        //将Integer类型的对象，转变为int的数值，叫做手动拆箱
        int i = it1.intValue();
        System.out.println("i = " + i);

        //将int类型的数值，转变为Integer类型的对象，叫做手动装箱
        System.out.println("---------------");
        Integer integer = Integer.valueOf(i);
        System.out.println(integer);
        //根据参数指定的字符串来构造对象
        Integer it2 = new Integer("20");
        System.out.println("ti2 = " + it2);

        System.out.println("____________");
        //JDK1.5开始提供了自动装箱和拆箱的机制
        Integer i1 = 12;
        int i2 = i1;
        System.out.println(i1);
        System.out.println(i2);
        System.out.println("----------");
        String str = "123";
        //将字符串类型转换为int类型并返回
        int i3 = Integer.parseInt(str);
        System.out.println(i3);
    }
}

数学处理类
BigDecimal类

(1)基本概念：由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助
java.math.BigDecimal类型加以描述。
(2)常用的方法
BigDecimal(String val) ：根据参数指定的字符串来构造对象
BigDecimel add(BigDecimel add：用于实现加法运算
BigDecimal subtract(BigDecimal sub)：用于实现减法运算
BigDecimal multiply(BigDecimal mul)：用于实现乘法运管
BiqDecimal divide(BigDecimal div)：用于实现除法运算
static int ROUND_HALF_UP：向最接近的数字舍入，“四舍五入”;

import java.math.BigDecimal;

public class BigdecimalTest01 {
    public static void main(String[] args) {
        double d1 = 0.1 + 0.2;
        System.out.println(d1);
        System.out.println("--------");
        BigDecimal bd1 = new BigDecimal("0.1");
        BigDecimal bd2 = new BigDecimal("0.23");
        System.out.println(bd1.add(bd2));
        System.out.println(bd1.subtract(bd2));
        System.out.println(bd1.multiply(bd2));
        //四舍五入
        System.out.println(bd1.divide(bd2,BigDecimal.ROUND_HALF_UP));
    }
}

String类(重点)
java.lang.String类主要用于描述字符串内容，Java程序中所有字符串字面值都可以使用该类的实例(对象)加以描述，如:“abc”等。该类由final关键字修饰表示该类不能被继承。该类描述的字符串内容是个常量不可改变，因此可以被共享。如:String str1= “abc";其中"abc"这个字符丰是个常量不可改变，但str1的数值可以改变str1 = "123";表示将"123"字符串的地址赋值给变量str1,覆盖str1中原来的数值，也就是改变str1的指向并没有改变指向的内容
 

常量池(原理)
String str1 = “abc”；

String = str2=“123”；

//比较str1 == str2

Stringstr3 = “abe”；

//比较str1 = str3
由于字符串类型描述的字符串内容是个常量不可改变，因此Java虚拟机将首次出现的字符串放入常量中，若后续代码中出现了相同的字符串内容则直接使用池中已有的字符串对象而无需申请内存以及创建对象，从而提高了性能。

public class StringDemo01 {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "123";
        //false
        System.out.println(str1 == str2);

        String str3 = new String("abc");
        String str4 = new String("abc");
        //false
        System.out.println(str1 == str3);
        //false
        System.out.println(str3 == str4);

        String str5 = "abc";
        //true
        System.out.println(str1 == str5);
    }
}

常用的方法(练熟)
String()：使用无参方式构造对象得到空字符序列
String(byte[] bytes, int offset, int length)：使用bytes数组中下标从offset位置开始的length个
字节来构造对象
String(byte[] bytes)：使用bytes数组中的所有内容构造对象
String(String str)：根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本。
char charAt(int index)：方法charAt用于返回字符串指定位置的字符。index表示指定的位置
int length()：返回字符串字符序列的长度
boolean contains(Charsequence s)：用于判断当前字符串是否包含参数指定的内容
String toLowerCase()：返回字符串的小写形式
String toUpperCase()：返回字符串的大写形式
String trim()：返回去掉前导和后继空白的字符串
boolean startsWith(String prefix)：判断字符串是否以参数字符串开头
boolean endsWith(String suffix)：判断字符串是否以参数字符串结尾

 

public class StringDemo02 {
    public static void main(String[] args) {
        String str = new String("   Let me give you some color see see  ");
        //g
        System.out.println(str.charAt(7));
        System.out.println("Length: " + str.length());
        System.out.println("Having me? " + str.contains("me"));
        System.out.println("Upper case: " + str.toUpperCase());
        System.out.println("Lower case: " + str.toLowerCase());
        System.out.println("Delete blank: " + str.trim());
        System.out.println("Start with “Let” ?" + str.startsWith("Let"));
        System.out.println("End with “!” ？" + str.endsWith("!"));
        System.out.println("Index of “e”： " + str.indexOf("e", 5));
        System.out.println("Last index of “e”: " + str.lastIndexOf("e", 5));
        System.out.println("Sub String: " + str.substring(24, 29));

        String s = new String();
        //是""   不是null
        System.out.println("s = " + s);

        byte[] brr = {97,98,99,100,101};
        String str3 = new String(brr, 0, 5);
        System.out.println(str3);
    }
}

StringBuilder类和StringBuffer类(重点)
基本概念：由于字符串类描述的字符串内容是个常量，不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。为了解决上述问题，可以使用java.lang.StringBuilder类和StringBuffer类来描述字符序列可以改变的字符串，如：“ab”、“abc”、“abcd”。其中StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低；StringBuilder类是从jdk 1.5开始存在，属于非线程安全的类，因此效率比较高；

常用的方法(练熟)
StringBuilder 类
StringBuilder()：构造一个不带任何字符的字符串生成器，初始容量为16个字符
StringBuilder(String str)：构造一个字符串生成器，并初始化为指定的字符串内容
int capacity()：返回当前容量
int length()：返回长度(字符数)
StringBuilder insert(int offset, String str)：插入字符串
StringBuilder append(String str)：追加字符串
StringBuilder delete(int start, int end)：删除字符串，前闭后开区间
StringBuilder replace(int start, int end,String str)：替换字符串
StringBuilder reverse()：字符串反转
int indexOf(String str)：查找字符串出现的位置
StringBuffer 类        上同

public class StringBufferDemo01 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        System.out.println("capacity: " + sb1.capacity());
        System.out.println("length: " + sb1.length());
        StringBuilder sb2 = new StringBuilder("heihei");
        System.out.println("capacity: " + sb2.capacity());
        System.out.println("length: " + sb2.length());
        System.out.println(sb2.insert(0, "zhangsan"));
        System.out.println(sb2.append("666"));
        System.out.println(sb2.delete(0, 8));
        System.out.println(sb2.replace(0, 5, "haha"));
        System.out.println(sb2.reverse());
        System.out.println(sb2.indexOf("h"));
    }
}

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println("capacity: " + sb1.capacity());
        System.out.println("length: " + sb1.length());
        StringBuilder sb2 = new StringBuilder("heihei");
        System.out.println("capacity: " + sb2.capacity());
        System.out.println("length: " + sb2.length());
        System.out.println(sb2.insert(0, "zhangsan"));
        System.out.println(sb2.append("666"));
        System.out.println(sb2.delete(0, 8));
        System.out.println(sb2.replace(0, 5, "haha"));
        System.out.println(sb2.reverse());
        System.out.println(sb2.indexOf("h"));
        
    }
}

3、日期相关的类(会用即可)

Date类
(1)基本概念：java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒。
(2)常用的方法
Date()：分配Date对象并初始化此对象，以表示分配它的时间(精确到毫秒)。
Dete(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间(称为“历元(epoch)"，即1970年1月1日00:00:00 GMT)以来的指定毫秒数
long getTime() ：返回自 1970 年1月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
void setTime(longtime) ：设置此Date对象，以表示1970 年1月1 日 00:00:00 GMT以后time毫
秒的时间点。

SimpleDateFormat类
(1)基本概念：java.text.SimpleDateFormat类主要用于实现日期类型和文本类型之间的转换。
(2)常用的方法
SimpleDateFormet()：用默认的模式和默认语言环境的日期格式符号构造SimpleDeteFormat
SimpleDateFormet(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormet

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

public class DateTest01 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        Date date1 = new Date(10000);
        System.out.println(date1);
        date1.setTime(1000);
        System.out.println(date1.getTime());
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println(format);
    }
}

 

4、可变参数 

一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。
语法:
        返回值类型 方法名称(数据类型...参数名称){
                //参数在方法内部，以数组的形式来接收

        }
注意:
        可变参数只能出现在参数列表的最后。

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(add());
        System.out.println(add(1, 2, 3));
        System.out.println(add(1, 2));
        System.out.println(add(1));
    }

    /**可变形参 看成数组  必须出现在参数列表的最后面*/
    public static int add(int...args){
        int sum = 0;
        for (int i = 0; i < args.length; i++) {
            sum += args[i];
        }
        return sum;
    }
}