JavaSE之工具类

作者: 金石_832e | 来源:发表于2019-03-13 19:00 被阅读0次

1.Object类

Java当中所有类的父类，祖宗。是一个唯一没有父类的类。

1.1equals()方法

在使用equals()方法之前，一定要知道equals方法在哪个类下，例如String类下的equals方法是经过重写后的方法，使用时可能会与Object类下的equals方法有区别。（自己去看两个类下equals（）源码）

①Object中equals()比较的是两个对象的引用地址。而String中equals()比较的是两个对象的值。

==：比较基本数据类型或引用数据类型，比较基本数据类型时，是比较真实的值；比较引用数据类型时，比较的是地址是否相等。
字符串的字面量会以对象的形式保存在字符串的常量池中（在方法区）。

举例：

public class ObjectDemo {
    
    public static void main(String[] args) {
        // Object类的equals方法比较的是地址
        ObjectDemo o = new ObjectDemo();
        ObjectDemo o1 = new ObjectDemo();
        System.out.println(o == o1);
        System.out.println(o.equals(o1));

        // String类的equals方法比较的是值（重写Object的equals方法）
        String a = "hello";
        String b = "hello";
        System.out.println(a.equals(b));
}
}

面试题1：描述a1和a2的区别

        String a1 = "hello";
        String b1 = new String("hello");

a1在常量池中只创建了一个叫hello的对象。
b1先在常量池中创建了一个hello的对象，然后在堆中创建了新对象，把常量池中的引用交给了新对象。

面试题2，给出结果

    String str1 ="hell"+"o";
    String str2 ="hello";
    System.out.println(str1==str2);
    System.out.println(str1.equals(str2));

结果：true,true
str1在常量池产生了三个对象，最终对象为hello，所以str1==str2为true。
字符串.equals（字符串）始终比较的是值，所以为true。

面试题3，给出结果

    String str3 ="hell"+new String("o");
    String str4 ="hello";
    System.out.println(str3==str4);
    System.out.println(str3.equals(str4));

结果：false,true
见到new就是产生新对象，==比较的是对象引用，对象都不一样，引用肯定不一样，所以false。

1.2hashCode()

    HashCodeDemo d = new HashCodeDemo();
    System.out.println(d); // 十六进制
    System.out.println(d.hashCode());// 十进制

如果两对象用equals比较返回true，两个对象的哈希码必定一样。
两个对象的哈希码一样，如果两个对象用equals比较不一定返回true

2.包装类

基本数据类型分为四类八种，分别为byte,short,int,long,double,float,char,boolean，他们所对应的包装类分别为Byte,Short,Integer,Long,Double,Float,Character,Boolean。基本数据类型转换成对应的包装类称为自动装箱，反过来叫自动拆箱。

为什么要引用包装类：在某网站上购买东西，当我们填写购买数量时，后台默认接受的数据类型为字符串类型。当程序计算我们所需要支付的金额时，字符串是不能参与运算的，因此要将其转换成数值类型。

作用：①包装类转换成字符串。②字符串转换成包装类。

举例：

public class PackingDemo {
    public static void main(String[] args) {
        int num = 100;
        // 自动装箱：基本数据类型直接赋值给包装类对象。
        Integer num1 = 100;
        // 自动拆箱：基本数据类型直接与包装类运算。
        System.out.println(num + num1);

        String str1 = "1000";
        String str2 = "2000";
        // 求和。
        int num2 = Integer.parseInt(str1);
        int num3 = Integer.parseInt(str2);
        System.out.println(num2 + num3);

        // 3.包装类转换成字符串
        int num4 = 100;
        String str3 = num4 + "";
        String str4 = String.valueOf(num4);
        String str5 = Integer.toString(num4);
    }
}

3.String类

String:代表一组“不可变”的字符串，字符串常量。对String的所有修改，都是在创建新的字符串，不是在原有的基础上修改的。
StringBuffer：在原有的字符串的基础上进行修改，不产生新的对象，节约内存。

public class StringDemo {
    public static void main(String[] args) {
    
        // 1.字符串比较：用equals方法比较的是内容是否相等。
        System.out.println("hello".equals("Hello"));
        System.out.println("hello".equalsIgnoreCase("Hello"));
        
        // 2.String toUpperCase() ; String toLowerCase()  ;
        System.out.println("helLo".toUpperCase());//字符串转大写
        System.out.println("helLo".toLowerCase());//字符串转小写
        
        // 3.char charAt(int) 返回指定索引处的字符
        System.out.println("helLo".charAt(0));
        
        // 4.String subString(int begin) //字符串截取
        // String subString(int begin,int end)
        System.out.println("HelloWorld".substring(5));
        System.out.println("HelloWorld".substring(0,5));
        
        // 5.int indexof(xxx) 返回一个字符串在另一个字符串当中第一次出现的索引。若没有则返回-1
        // int lastIndexOf(xxx) 返回一个字符串在另一个字符串当中最后一次出现的索引。若没有则返回-1
        System.out.println("HelloWorld".indexOf("o"));
        System.out.println("HelloWorld".lastIndexOf("o"));
        
        // 6.String trim() //掐头去尾去空格。
        System.out.println("  Hello  World  ".trim());
        
        // 7.concat //字符串连接 与“+”号作用相同，但是效率相对来说要高。
        
        // 8.String[] split(String regex) //把一个字符串按照一种规则切割成多个数组
        String str [] =("黑桃;红桃;方片;草花").split(";");
        for(String s : str) {
            System.out.println(s);
        }
        
        // 9.String replace(char oldChar,char newChar)
        System.out.println("张思博".replace("思博", "平"));
        
        // 10.boolean startsWith(String prefix) //判断是否以什么开头
        System.out.println("hello".startsWith("h"));
        
        // 11.boolean endsWith(String prefix) //判断是否以什么结尾
        System.out.println("hello".endsWith("ho"));
    }
}

* 3.1字符串比较：

用equals方法比较的是内容是否相等。

* 3.2 String toUpperCase() ; String toLowerCase() ;

字符串转成大写、小写

* 3.3 char charAt(int)

返回指定索引处的字符

* 3.4 String subString(int begin)；String subString(int begin,int end)

字符串截取

* 3.5 int indexof(xxx)

返回一个字符串在另一个字符串当中第一次出现的索引。若没有则返回-1； int lastIndexOf(xxx) 返回一个字符串在另一个字符串当中最后一次出现的索引。若没有则返回-1

* 3.6 String trim()

将一个字符串的开头和结尾的空格去掉。

* 3.7 concat()

与字符串之间拼接使用的+功能一致，但是效率高于加号，低于StringBuffer中的append（高不成低不就，鸡肋）。

* 3.8 String[] split(String regex)

将一个字符串按照一定规则切割成多个数组。

* 3.9 String replace(char oldChar,char newChar)

将一个字符串中的所有老字符用新字符替换。

* 3.10 boolean startsWith(String prefix)；boolean endsWith(String prefix)

判断字符串是否以某个字符串作为开头、结尾。

* 3.11 toString()

toString的价值在于重写输出对象，若不重写输出的就是十六进制的引用。

public class ToStringDemo {
    int age;
    String xname;
    @Override
    public String toString() {
        return this.age+" "+this.xname;
    }
    
    public ToStringDemo(int age, String xname) {
        super();
        this.age = age;
        this.xname = xname;
    }

    public static void main(String[] args) {
        ToStringDemo t =new ToStringDemo(28,"zhangsan");
        System.out.println(t);//System.out.println(t.toString())//.toString()默认省略
        // 意义在于重写，输出对象时返回重写的内容
        // 默认的返回值，对象的十六进制
    }
}

4.Math类

Math类是final类，没有子类，无法被继承，方法无法被重写。Math类中的好多方法都是静态（static）方法。

* 4.1 random（）返回[0,1)

* 4.2 ceil返回大于某个数的最小整数,向上取整。

* 4.3 floor返回小于某个数的最大整数,向下取整。

* 4.4 round四舍五入

* 4.5 abs绝对值

* 4.6 min、max 最小值最大值

System.out.println(Math.ceil(9.8));
System.out.println(Math.floor(9.8));
System.out.println(Math.ceil(-9.8));
System.out.println(Math.floor(-9.8));
System.out.println(Math.round(-9.8));

5.StringBuffer类

String:定义一组不可变的字符串常量。
StringBuffer：定义的字符串是可变的，每次修改都是在原有的基础上修改，节省内存，效率高，线程安全（数据同步）。
StringBuilder：同StringBuffer都是可变的字符串，效率更高，但是线程不安全（数据不同步）。

* 5.1 equals()

StringBuffer中的equals方法没有重写过！如果两个StringBuffer对象比较，比较的是引用地址。如果相比较值，必须要通过toString方法转换成String类型再比较。

* 5.2 StringBuffer reverse()

字符串反转。

* 5.3 void setCharAt(int,char)

设置索引位置用一个字符替换。

* 5.4 append()

线程安全的情况下，拼接字符串的最高效写法。

* 5.5 .void insert(int i,String regex)

指定为只插入一个字符串。

public class StringBufferDemo {
    public static void main(String[] args) {
        // String：代表一组字符串常量
        // StringBuffer：代表一组可变的字符串，对他的所有修改都是在原有基础上进行的。数据同步
        // StringBuilder:效率更高，但是线程不安全（数据不同步）。
        
        // 面试题String、StringBuffer、StringBuilder三者区别：
        
        // 1.StringBuffer中的equals方法没有重写过！
        StringBuffer sb = new StringBuffer("hello");
        System.out.println(sb.equals("hello"));

        // 上面结果为：false。如果想将StringBuffer对象与字符串比较时，必须要转换成String类型
//      String s = sb.toString();
        System.out.println(sb.toString().equals("hello"));
        //如果想将两个StringBuffer对象值比较，必须都要转到String类型，再比较。

        // 2.StringBuffer reverse() //反转，String类中没有该方法
        System.out.println(sb.reverse());
        
        // 3.void setCharAt(int,char) //将指定索引位置用一个字符替换
        sb.setCharAt(0,'z');
        System.out.println(sb);
        
        // 4.append //字符串拼接效率最高的！！！！
        sb.append("hahahahaahaha");
        System.out.println(sb);
        
        // 5.void insert()  //指定索引插入数据
        System.out.println(sb.insert(1, "88"));
    }
}

6.SimpleDateFormatDemo类

将日期格式(Date类)的数据转换成字符串(String类)

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        // SimpleDateFormat 类 是完成字符串与日期之间转换的类；
        // Date转String ，调用SimpleDateFormat类中format方法
        // String转Date ，调用SimpleDateFormat类中parse方法
        Date d = new Date();
        /*
         * yyyy：年 
         * MM：月 
         * dd：日 
         * hh：小时，12进制 
         * HH：消失，24进制 
         * mm：分钟 
         * ss：秒
         */
        // Date转String
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str1 = sdf.format(d);
        System.out.println(str1);

        // String转Date
        String str2 = "1990-08-17";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date d2 = sdf2.parse(str2);
            System.out.println(d2);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
无论是日期转成字符串，还是字符串转成日期。SimpleDateFormat的有参构造方法提供了一个接收初始化日期格式的参数。
日期转换成字符串：format（Date d）
字符串转换成日期：parse（String str）

7.Date类

目前还活着的主要方法getTime()

public class DateDemo1 {
    public static void main(String[] args) {
        // Date 日期类，Date构造器能接收毫秒。
        Date d=new Date();
        System.out.println(d);
        // public long getTime() 获取时间戳 ---从1970年1月1日00：00：00到现在经过的毫秒数
        long l=d.getTime();
        System.out.println(l);
        
        // Calendar抽象类:可以设置时间
        Calendar date =Calendar.getInstance();
        date.getTime();
        date.set(2017, 1, 1);
        System.out.println(date);
        System.out.println(date.getTime());
        System.out.println();
    }
}