常用类的学习

常用类的学习

内部类有：

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类
   ·没有类名的局部内部类（一切特征与局部内部类相同）
   ·必须继承一个父类或者实现一个接口
   定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
   优点：减少代码量
   缺点：可读性较差

Object类：

• 所有类的父类
• 任何类，如果没有书写extends显示继承某个类，都会默认直接继承Object类，否则为间接继承
• Object类中所定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象
  1.作为参数，可以接受任何对象
  2.作为返回值，可以放回任何对象

getClass()方法：

             1.返回引用中存储的实际对象类型
             2.应用：通用用于判断两个引用中实际存储对象类是否一致

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 Text {

    public static void main(String[] args) {
        //getClass方法
        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){//s1和s2属于同一个类型
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}

hashCode()方法：

               1. 返回该对象的哈希码值
               2. 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
               3. 一般情况下相同对象返回相同哈希码

还是用上面的类进行测试
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s3.hashCode());

toString()方法：
1. 返回该对象的字符串表示（表现形式）
2. 可以根据程序需求覆盖该方法，如：展示对象各个属性值

还是用上面的类测试（此时需要重写方法）
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;
    }

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

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
输出结果：   （不使用重写方法）会输出
aaa,20       CommonClass.getset.Student@154617c  @后就是哈希码值
bbb,22       CommonClass.getset.Student@a14482

equals()方法：

比较两个对象的地址
1. 默认实现为（this == obj），比较两个对象地址是否相同
2. 可进行覆盖，比较两个对象的内容是否相同

包装类

• 基本数据类型所对应的引用数据类型
• object可统一所有数据，包装类的默认值是null

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换与装箱、拆箱

装箱：将基本类型转换为引用类型的过程
拆箱 ：将引用类型转换为基本类型的过程

public static void main(String[] args) {
        int num=10;
        //类型转换：装箱，基本类型转换成引用类型的过程
        //基本类型
        int num1=18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);//这2中方法都可以
        System.out.println("装箱:");
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱，引用类型转换成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2=integer3.intValue();
        System.out.println("拆箱:");
        System.out.println(num2);

        
        //JDK1.5之后，提供自动装箱和拆箱
        int age=20;
        //自动装箱
        Integer integer4=age;
        System.out.println("自动装箱:");
        System.out.println(integer4);
        //自动拆箱
        Integer age1=integer4;
        System.out.println("自动拆箱:");
        System.out.println(age1);

    }

基本类型和字符转换

//基本类型和字符串之间的转换
        //1.基本类型转换成字符串
        int n1=100;
        //1.1使用+号
        String s1=n1+"";
        //1.2使用Integer中的toString()方法
        String s2=Integer.toString(n1);
        System.out.println(s1);
        System.out.println(s2);

        //2.字符串转换成基本类型
        String str="150";
        //使用Integer.parseXXX();
        int n2=Integer.parseInt(str);
        System.out.println(n2);

        //boolean字符串形式转换成基本类型，只有字符串的"true"--->true   ||"true"--->false 非true都是false
        String str2="true";
        boolean b1=Boolean.parseBoolean(str2);
        System.out.println(b1);

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  他们是引用类型了放在堆里面 地址不一样所以是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
        //思考为100是true，200为什么就是false？
        //valueOf中已经创建好了常用的包装对象在-128--127之间  超过这个范围就只能重新在堆里面开辟新的

    }

String类

• 字符串是常量，创建之后不可改变
• 字符串面值存储在 字符串（在方法区里面）池中，可以共享
• String s=“hello”;产生一个对象，字符串池中存储
• String s=new String(“hello”);//产生两个对象，堆、池各存储一个！
  

 public static void main(String[] args) {
        String name="hello";//"hello"常量存储在字符串池中
        name="zhangsan";//把zhangsan赋值给name,给字符串赋值时，并没有修改数据，而是重新开辟一个空间。这就是不可变性，原来的hello就变成垃圾了
        String name2="zhangsan";//把原来开辟的空间直接拿过来用
        System.out.println(name);
        System.out.println(name.equals(name2));//true

        //字符串的另一种创建方式:new String
        String str=new String("java");//堆和字符池中各一个java,所以出现了2个对象
        //面试题
        String str2=new String("java");//只要new就重新开辟
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//true

    }

String常用方法

• public int length()：返回字符串的长度
• public char charAt(int index)：根据下标获取字符
• public boolean contains(String str)：判断当前字符串中是否包含str

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

        String content="java是世界上最好的java编程语言,java真好用";
        System.out.println(content.length());//15
        System.out.println(content.charAt(content.length()-1));//言
        System.out.println(content.contains("java"));//true    包含了就是true反之false
        System.out.println(content.contains("php"));//false

• public char[] toCharArray()：将字符串转换成数组
• public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
• public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的小标索引

//字符串方法的使用
        //4、toCharArray()；返回字符串对应的数组
        //5、indexOf()；返回子字符串首次出现的位置
        //6、lastIndexOf()；返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java",4));//4 是字符的脚标从0开始数
        System.out.println(content.lastIndexOf("java"));

• public String toUpperCase():将小写转换成大写
• public String trim():去掉字符串前后的空格
• public boolean endWith(String str):判断字符串是否以str结尾

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

        String content2="   hello World   ";
        System.out.println(content2.trim());//hello World
        System.out.println(content2.toUpperCase());//   HELLO WORLD
        System.out.println(content2.toLowerCase());//   hello world

        String contnet3="hello.java";
        System.out.println(contnet3.endsWith("java"));//true
        System.out.println(contnet3.startsWith("hello"));//true

• public String replace(char oldChar,char newChar);将旧的字符串替换成新的字符串
• public String[] split(String str);根据str做拆分

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

        //String content="java是世界上最好的java编程语言,java真好用";
        System.out.println(content.replace("java","php"));//php是世界上最好的php编程语言,php真好用

        String say="java is the best programing language";
        String[] arr=say.split(" ");//还可以选择多个进行拆分[ ,]就是将空格和，都拆分了
        System.out.println(arr.length);//6
        for (String string : arr){
            System.out.println(string);
        }

        //补充两个方法equals、compare();比较大小
        String s1="hello";
        String s2="HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true。equalsIgnoreCase忽略大小写进行比较

        String s3="abc";//a 97
        String s4="xyz";//x 120
        System.out.println(s3.compareTo(s4));//-23  从一个数起出现了不同就进行比较（仅此一次）上面就是a与x的比较
        //另一种情况是字符同一列没有相同的了且一方字符少，那就进行长度的比较
        String s5="abc";
        String s6="abcopl";
        System.out.println(s5.compareTo(s6));//-3

例题：
已知String str = “this is a text”;
1.将str中的单词单独获取出来
2.将str中的text替换成practice
3.在text前面插入一个easy
4.将每个单词的首字母改成大写

public static void main(String[] args) {
        String str = "this is a text";
        //1.将str中的单词单独获取出来
        String[] arr=str.split(" ");
        for (String string:arr){//遍历
            System.out.println(string);
        }

        //2.将str中的text替换成practice
        System.out.println(str.replace("text","practice"));
        //也可以这样写
        String str2=str.replace("text","practice");
        System.out.println(str2);

        //3.在text前面插入一个easy
        String str3=str.replace("text","easy text");
        System.out.println(str3);

        //4.将每个单词的首字母改成大写
        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);//substring截取片段 1代表从第二个字符开始截取
            System.out.println(news);
        }
    }

可变字符串

• StringBuffer:可变长字符串，JDK1.0就开始提供了，运行效率慢、线程安全
• StringBuilder:可变长字符串，JDK5.0开始提供，运行效率快，线程不安全

public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
       // StringBuilder sb = new StringBuilder();//和StringBuffer一样
        //1.append();追加
        sb.append("java世界第一");
        System.out.println(sb.toString());//java世界第一
        sb.append("java真香");
        System.out.println(sb.toString());//java世界第一java真香
        sb.append("java好用");
        System.out.println(sb.toString());//java世界第一java真香java好用

        //2.insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());//我在最前面java世界第一java真香java好用

        //3.replace();替换
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());//hellojava世界第一java真香java好用

        //4.delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());//java世界第一java真香java好用

        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.toString());
        
    }

验证StringBuilder效率高的方法如下：

 public static void main(String[] args) {
        //开始时间
        long start=System.currentTimeMillis();
//        String string="";
//        for (int i=0;i<9999;i++){
//           string+=i;
//        }
//        System.out.println(string);
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<9999;i++){
            sb.append(i);
        }
        System.out.println(sb.toString());
        long end=System.currentTimeMillis();
        System.out.println("用时:"+(end-start));//用时:351  String    StringBuilder 用时:16
    }

BigDecimal的使用

• 位置：java.math包中
• 作用：精确计算浮点数
• 创建方式：BigDecimal bd=new BigDecimal(“1.0”);
• 方法：
  1.BigDecimal add（BigDecimal bd） 加法
  2.BigDecimal subtract（BigDecimal bd） 减法
  3.BigDecimal multiply（BigDecimal bd） 乘法
  4.BigDecimal divide（BigDecimal bd） 除法

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

public static void main(String[] args) {
        double d1=1.0;
        double d2=0.9;
        System.out.println(d1-d2);//0.09999999999999998

        //面试题
        double result=(1.4-0.5)/0.9;
        System.out.println(result);//0.9999999999999999

        //BigDecimal,大的浮点数精确计算
        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);//09

        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));//除
        System.out.println(r4);//1
    }

Date类

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

public static void main(String[] args) {
        //1.创建Date对象
        //今天
        Date date1=new Date();
        System.out.println(date1);//Thu Jul 29 16:40:53 CST 2021
        System.out.println(date1.toLocaleString());//2021-7-29 16:44:42
        //昨天
        Date date2=new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());//2021-7-28 16:44:42

        //2.方法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(date2);
        System.out.println(d);//1

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

    }

Calendar类

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

 public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());//打印本地时间
        System.out.println(calendar.getTimeInMillis());//1970年到现在的毫秒

        //2.获取时间信息
        //获取年
        int year=calendar.get(calendar.YEAR);
        //月
        int month=calendar.get(calendar.MONTH);
        //日
        int day=calendar.get(calendar.DAY_OF_MONTH);//Date
        //小时
        int hour=calendar.get(calendar.HOUR_OF_DAY);
        //分钟
        int minute=calendar.get(calendar.MINUTE);
        //秒
        int second=calendar.get(calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

        //3.修改时间
        Calendar calendar2=Calendar.getInstance();
        calendar2.set(calendar.DAY_OF_MONTH,28);//修改日
        System.out.println(calendar2.getTime().toLocaleString());

        //4.add方法修改时间
        calendar2.add(calendar.HOUR,-1);//修改小时
        System.out.println(calendar2.getTime().toLocaleString());

        //5.补充方法
        int max=calendar2.getActualMaximum(calendar.DAY_OF_MONTH);//当前月最大天数
        int min=calendar2.getActualMinimum(calendar.DAY_OF_MONTH);//当前月最小天数
        System.out.println(max);
        System.out.println(min);
    }

SimpleDateFormat类

public static void main(String[] args) throws ParseException {
        //1.创建SimpleDateFormat对象  y年M月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2.创建Date
        Date date = new Date();
        //格式化date(把日期转换成字符串)
        String str=sdf.format(date);
        System.out.println(str);

        //解析(把字符串转换成日期)
        Date date2=sdf.parse("2021/02/02");//要跟上面new的类型一致
        System.out.println(date2);

    }

System类

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

 public static void main(String[] args) {
        //1.arraycopy;数组的复制
        //src：源数组
        //srcPos：从那个位置开始复制0
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] arr={20,18,15,8,35,26,45,90};
        int[] dest=new int[8];
        System.arraycopy(arr,4,dest,4,4);
        for (int i=0;i<dest.length;i++){//遍历
            System.out.println(dest[i]);//打印
        }

        //2.System.currentTimeMillis()；获取毫秒数
        //3.System.gc();告诉垃圾回收期回收
        //4.退出JVM
        System.exit(0);//后面的代码就不会执行了

        System.out.println("程序结束了...");
    }

总结

• 内部类：

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

• 成员内部类、静态内部类、局部内部类、匿名内部类

• Object类：
  所有类的直接或间接父类，可存储任何对象

• 包装类：
  基本数据类型所对应的引用数据类型，可以使Object统一所有数据

• String类：
  字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享

• BigDecimal类：
  可精确计算浮点数

• Date类
  特定时间

• Calendar类
  日历

• SimpleDateFormat类
  格式化时间

• System类
  系统类