Java工作学习----第九课 Java中内部类 Object类 System类 Date类基本数据类型的包装类 String类 Bigdecimal 2021.2.1

最新推荐文章于 2024-08-17 12:50:12 发布

秀才大大

最新推荐文章于 2024-08-17 12:50:12 发布

阅读量192

点赞数 1

分类专栏： java学习文章标签： java 内部类类 object

本文链接：https://blog.csdn.net/xiucai5211314/article/details/113530677

版权

java学习专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Object类

是一个超类，是所有类的一个父类。

Object中所定义的方法，是所有对象都具备的方法

getClass 方法

返回当前对象的类型

hashCode 方法

返回值是int型

根据对象的地址，hash值根据对象的地址字符串或者数字计算出来的int类型的数值

**同一对象返回同一哈希码值 **

toString 方法

返回值是字符串类型，返回对象的字符串形式，上边是数字形式

返回的是包名跟哈希值地址，地址表现形式是十六进制的，与上边十进制的数字进行进制转换以后是相同的

equals

返回值是boolean

比较两个对象是否相同，因为字符串类是引用的，所以用这个

equals重写步骤，在alt +ins中也有重写步骤

finalize（）

垃圾对象，是JVM自动调用,不存在引用时

光开辟空间，没有具体指

手动回收垃圾，System.gc();

包装类

什么时包装类？

基本数据类型类型所对应引用数据类型，直接存储在栈里边，基本类型中没有属性跟方法。

需要特别主义的时Integer跟Character，包装以后数据放在栈里边了

类型转换装箱跟拆箱

装箱:把栈里边的数据放在堆里边

拆箱：把堆里边的数据放在栈里边

Number类是上边包装类的父类，其中存在几个方法，把

  //创建对象
        Integer integer1 = new Integer(num1);//使用构造函数
        Integer integer2=Integer.valueOf(num1);//使用静态方法

 //拆箱

        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();

在这里边注意两个方法一个是valueof 一个是 intvalue，怎么记住呢，value在前时表明现在要转换成对象，因为"值在前"

在jdk 1.5之前使用以上的方法

1.5之后，可以使用以下方法，在生成的字节码文件中会给我们补全在上边的方法。

   //自动装箱
        Integer integer = num1;
        //自动拆箱
        int num3=integer;

基本类型跟字符串的转换

将基本类型转成字符串类型

//第一种方法
int i=1;
String n1=i+"";
//第二种方法
String n2=Integer.toString(n1);

将字符串类型转成基本类型

       String str="150";
        int n3=Integer.parseInt(str);
        System.out.println(n3);

调用Integer中静态方法parseInt 注意不能再str中出现其他字符，连小数都不行

如果出现小数，就变成下列的相关内容

 String str="150.00";
        double n3=Double.parseDouble(str);
        System.out.println(n3);

对于字符串类型转布尔类型时，如果str为true则转出来的结果时true，如果为其他的值就不行。

Integer缓存区

自动装箱如果给的数值再-128到127，从cache数组里去调用这个值

三种情况

一. 两个对象是不是相等，这里肯定输出false

Integer integer4=new Integer(100);
Integer integer5=new Integer(100);
System.out.println(integer4==integer5);

二.进行自动装箱以后，进行了强制数据转换，并且valueof（）执行的是从堆里边找到的100的数值的地址把他给了integer，

Integer integer6=100;
Integer integer7=100;
System.out.println(integer6==integer7);

三.进行自动装箱以后，尽管进行了强制类型转换。但是200不在堆的数组里边，所以说，要重新建立一个新的对象跟地址，在进行比较的时候反而不想等了

Integer integer8=200;
Integer integer9=200;
System.out.println(integer8==integer9);

String类

字符串是常量，创建之后不可改变。

存在字符串池中，可以共享。

String name="hello";//此时常量的地址跟方法区里边的数据都以及完成了
name="张三";//又进行了一次赋值，没有修改数据，实际上再方法区里边重新开辟了一个空间
name2="张三";//跟上边张三指向一样的地址

//演示字符串的另一种创建方式
String str=new String("张三");//再堆里创建一个空间存在常量池里的张三 常量池存在一个张三，在常量池跟堆里边都创造对象

常用的方法

length（），返回字符串长度
charAt（int x），返回某个位置的字符
contains（String str）是否包含某个子字符串

toCharArray 将字符串转换成数组
indexOf(str) 查找str首次出现的下标，数组中的表示对应的数字应该加1
lastIndexOf(String str) 查找字符串在当前字符串最后一次出现的下标索引

trim 去掉字符串前后的空格
toUpperCase 将小写转成大写

endWith（结尾）判断字符串以什么结尾

 String str2 = "           黄志航是最帅的男孩子aaaaa";
        System.out.println(str2.trim());//取消空格
        System.out.println(str2.toUpperCase());
        System.out.println(str2.endsWith("a"));//是否以a结尾

replace（旧字符，新字符）用旧字符换成新字符
split（字符分隔符）对字符串分割

String str2 = "黄 志 航 是 最 帅 的男孩子aaaaa";
        System.out.println(str2.replace("最","醉"));//找个字替换
        String[]arg= str2.split(" ");//对进行分割 "[ ,]" 里边可以多写几个，一个空格 一个逗号，或者的意思
        System.out.println(arg.length);

        System.out.println(Arrays.toString(arg));
        for (String string: arg) {
            System.out.println(string);
        }

compare();//比较大小比较在ascall码中的位置

//把所有单词首字母大写
        for (int i = 0; i <arg.length;i++ ) {

           char fist = Character.toUpperCase(arg[i].charAt(0));
          String newFrist=  fist + arg[i].substring(1);
           System.out.println(newFrist);

        }

可变字符串

StringBuffer类：String的增强了，提前开辟了缓存区，线程安全，效率慢

StringBuilder类：StringBuilder，跟下边例子一样的，包括方法

两者都比Sting效率高，而且比他内存节省。

几个方法

append（）//追加
delete（起始位置，末尾位置）//删除
insert（插入的位置，后边的字符都往后）
replace（起始位置，末尾位置，需要的字符串）

//append 追加功能
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("黄志航");
        System.out.println(stringBuffer.toString());
        stringBuffer.append("真帅");
        System.out.println(stringBuffer.toString());
//输出   黄志航 
//输出   黄志航真帅
   

// 插入添加 insert
        stringBuffer.insert(1,"我" );
        System.out.println(stringBuffer.toString());
//输出 黄我志航真帅
 
//replace 指定位置进行添加,三个参数，开始的位置，结束的位置
        stringBuffer.replace(0, 1, "唔");
        System.out.println(stringBuffer.toString());

//输出 唔我志航真帅
//delete 删除, 两个参数 起始位置，结束位置
        stringBuffer.delete(0, 1);
        System.out.println(stringBuffer.toString());

//输出 我志航真帅

验证Buffer比Builder低

注意必须数量级比较大的情况下

package String;

public class domo {


        public static void main(String[] args) {
         /*
            // 使用String的时间检测方法
            long start = System.currentTimeMillis();
            String string = "";
            for (int i = 0;i<50000;i++ ) {
                string+=i;

            }
            System.out.println(string);
            long end = System.currentTimeMillis();
 System.out.println( "用string："+(end-start));
*/

            // 使用StringBuffer的时间检测方法

            long start = System.currentTimeMillis();

            StringBuffer string1 = new StringBuffer("");
            for (int i = 0;i<90000;i++ ) {
                string1.append(string1);

            }
            System.out.println(string1);
            long end = System.currentTimeMillis();
            System.out.println( "用stringBuffer："+(end-start));

            // 使用StringBuilder的时间检测方法

            start = System.currentTimeMillis();

            StringBuilder string2 = new StringBuilder("");
            for (int i = 0;i<90000;i++ ) {
                string2.append(string2);

            }
            System.out.println(string2);
            end = System.currentTimeMillis();
            System.out.println( "用stringBuilder："+(end-start));





        }
    }

三种效率比较方法，如何验证效率三句代码

 start = System.currentTimeMillis();
  long end = System.currentTimeMillis();
   System.out.println( "用stringBuilder："+(end-start));

Bigdecimal

为了解决小数的不精确问题，相似值，特别涉及到金融行业的

精度要求非常高

在java.math包中

面试题：

double result=（1.4-0.5）/0.9

输出不是1

运算：subtract 减法

 BigDecimal bigDismal = new BigDecimal("1.0");
 BigDecimal bigDismal2 = new BigDecimal("0.9");
           // bigDismal.subtract(bigDismal2);

System.out.println( bigDismal.subtract(bigDismal2));

add加法

 BigDecimal bigDismal = new BigDecimal("1.0");
 BigDecimal bigDismal2 = new BigDecimal("0.9");
           // bigDismal.subtract(bigDismal2);

System.out.println( bigDismal.add(bigDismal2));

multiply乘法

 BigDecimal bigDismal = new BigDecimal("1.0");
 BigDecimal bigDismal2 = new BigDecimal("0.9");
           // bigDismal.subtract(bigDismal2);

System.out.println( bigDismal.multiply(bigDismal2));

divide除法 divide(被除数,保留几位小数，采用什么方式保留，四舍五入（ROUND_HALF_UP）)

//解决 double result=（1.4-0.5）/0.9
System.out.println(
    new BigDecimal("1.4")
    .subtract(new BigDecimal(0.5))
    .divide(new BigDecimal("0.9"))
);

Date

   Date date1 = new Date();
        System.out.println(date1);
        Date date2 = new Date(date1.getTime()-60*60*24*1000);

        System.out.println(date2);
//after,1是否在2之后
        System.out.println(date1.after(date2));compareTo（

calendar

不能使用构造方法构造对象构造方法是保护类

//1.创建对象用getInstance（），不能使用new新建对象
//2.获取当前时间，getTime（），用toLcaleString转换格是
//3.程序运行的时间getTimeInMillis()
//4 使用get（对象.常量）
//5 修改时间 set（对象.常量,要修改的数字）
// 6 给时间增加
//7 实际存在的最大数

package xiucai;

import java.util.Calendar;

public class dome1 {
    public static void main(String[] args) {
        //1.创建对象 用getInstance（），不能使用new新建对象
        Calendar calendar = Calendar.getInstance();
        Calendar calendar1 = Calendar.getInstance();
        //2.获取当前时间，getTime（） ，用toLcaleString转换格是
        System.out.println(calendar.getTime().toLocaleString());
        //3.程序运行的时间getTimeInMillis()
        System.out.println(calendar.getTimeInMillis());

       //4 使用get（对象.常量）
        int year = calendar.get(Calendar.YEAR);
        //5  修改时间 set（对象.常量,要修改的数字）
     //  calendar.set(Calendar.YEAR,5);
       // calendar.set(Calendar.MONTH,2);
        System.out.println(calendar.getTime().toLocaleString());

        // 6 给时间增加
        calendar.add(Calendar.HOUR,1);
        calendar1.add(Calendar.MONTH,2);
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar1.getTime().toLocaleString());
        //7 实际存在的最大数
        System.out.println(calendar1.getTime().toLocaleString());
        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println("最大值"+max);
        System.out.println("最小值"+min);
    }

}

SimpleDateFormat

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
Calendar calendar = Calendar.getInstance();
String str = simpleDateFormat.format(calendar.getTime());
System.out.println(str);

主要方法：

1.格式化

第一步

SimpleDateFormat（）

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");

在构造函数的时候规定了时间格式

第二步

对象.format(现阶段时间)

String str = simpleDateFormat.format(calendar.getTime());

format方法就是把获取到的时间按照编译规则进行转换

2.反编译

用到的方法

对象.parse（）

必须是按照对象给定的格是进行反编译

System

arraycopy（要复制的数组，从哪个位置开始，复制到哪个数组，复制到的数组的开始，复制的长度，）

currentTimeMillis（）可以用来计算程序运行的时间