Java包,正则表达式,定时器类,集合框架和泛型

最新推荐文章于 2022-09-15 21:19:50 发布

~jiamin

最新推荐文章于 2022-09-15 21:19:50 发布

阅读量412

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_47598133/article/details/109282705

版权

一.Java常用类的包

1.包的结构与功能介绍

Java是一门面向对象的语言，sun公司提供基于面向对象的帮助文档（API Application Program Interface），并针对不同的版本生成的API

API中根据不同的功能分如下包（package）

java.applet.* : java的小应用程序
java.awt.* 和 java.swing.* : java的图形用户界面（开发单机版的小游戏）
java.lang.* : java的语言包
java.util.* : java的工具类包、集合框架包
java.io.* ： java文件读写包（Input 、Output）
java.net.* : java的网络编程包（Socket机制相关，URL）
java.sql./ javax.sql. : java的数据库操作
java.lang.reflect.* 反射相关包

2.java的lang包

1、包装类

定义:Java 的8个基本数据类型对应的对象类型,称为它们的包装类.

为什么需要包装类:

基本数据类型不能提供方法,不能与其它引用类型进行转换(基本数据类型和引用数据类型不能强转),此时包装类作为该基本数据类型的对象类型，不仅提供常用的方法，还可以 “装箱”、“拆箱”以及与其他数据类型互相转换.

除Character和Boolean类型外,其它包装类的默认值都是空.

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

问题：基本数据类型、包装类以及字符串的相互转换

public static void main(String[] args) {
   
        // 1、byte 的包装类   Byte
        // 创建包装类的对象
        byte b=123;
        Byte obj1 = new Byte(b);
        //1、 包装类 转字符串   包装类对象.toString()
        String s1 = obj1.toString();

        //2、字符串转包装类      new 包装类(s) 或者   包装类.valueOf(s)
        String s2="100";
        Byte obj2 = new Byte(s2);
        // 或者
        Byte obj3 = Byte.valueOf(s2);



        //3  获取包装类的数值，包装类转基本数据类型  Byte  - >  byte
        //  包装类.valueOf(基本数据类型) 或者 byteValue()
        byte b2 = obj2;  // 包装类可以直接复制给基本数据类型  ，这个过程 “拆箱”过程
        byte b3 = Byte.valueOf(obj2);

        // 4、字符串转 基本类型     包装类.paseByte(s)
        byte b4 = Byte.parseByte(s2);

         //基本类型转字符串
        byte b5=122;
        String s5 = new Byte(b5).toString();


    }

再以 Integer 举例

public static void main(String[] args) {
   

        int n=250;
        // 转包装类
        Integer obj1 = new Integer(n);
        //包装类转基本数据类型
        int n3 = Integer.valueOf(obj1);

        // 转字符串
        String s1 = obj1.toString();
        //  字符串再转成  Integer
        Integer obj2 = Integer.parseInt(s1);
        Integer obj3 = new Integer(s1);

        // 字符串转int
        int n2 = Integer.valueOf(s1);
        // int  转 转字符串
        String s3 = new Integer(n2).toString();

        System.out.println("-------------Intger的常用方法------");
        int num = Integer.bitCount(2);  // 个位数 + 高位数的和
        System.out.println(num);
        // n1>n2 返回1   n1==n2 返回0   n1<n2 -1
        //比较两个数是否相等
        System.out.println(Integer.compare(100,200));

        System.out.println(Integer.decode("123"));

        //equals  比较两个数是否相等  对于基本数据类型的包装类比较他们的数值
        Integer  n1  = new Integer(90);
        Integer n4 = new  Integer(90);
        System.out.println(n1.equals(n4));// 比较两个对象的 值
        System.out.println(n1 == n4);// 比较 两个对象的地址

        int n5 =100;
        int n6 =100;
        System.out.println(n5==n6);// 对于基本数据类型 == 比较的值


        // 进制转换
        System.out.println(Integer.toBinaryString(18));//转成二进制表示形式
        System.out.println(Integer.toHexString(15));//转成16进制表示形式
        System.out.println(Integer.toOctalString(10));//转成8进制表示

    }

问题：数据类型的装箱和拆箱

装箱: 将基本数据类型自动转换成它的包装类，可以使用包装类的方法和属性

 // 自动装箱： 100自动转成 Integer 
        Integer num1 = 100;

拆箱: 将包装类型自动转成对应的基本数据类型。

// 自动拆箱:  Integer 自动转成  int
        int num2 = num1;

面试题:基本数据类型的装箱

 public static void main(String[] args) {
   
        // 包装类
        // 自动装箱： 100自动转成 Integer
        Integer num1 = 100;
        // 自动拆箱:  Integer 自动转成  int
        int num2 = num1;

        Integer n1 =100;
        Integer n2 =100;
        System.out.println(n1.equals(n2)); //true
        System.out.println(n1 == n2);// 应该true   他们同时指向常量池100


        Integer n3 = 150; // 等价于 Integer n3 = new Integer(150);
        Integer n4 = 150; // 等价于 Integer n4 = new Integer(150);
        System.out.println(n3.equals(n4));//true
        System.out.println(n3 == n4);//false

        Integer n6 = new Integer(100);// 一定会创建新对象
        System.out.println(n6 == n1); // false

    }
         //结论:
		      对于 -128 <=Integer的值 <=127 之间（一个byte范围)时,装箱时不会创建新对象,而是直接引用常量池中的值.如果超出byte的范围，则自动创建新对象,各自指向新对象的内存.自动装箱不用手动创建,系统直接new对象即系统按情况分类有默认操作.

2、Object类

Object类是lang包提供的 ,对于lang包的类不需要import,所以 Object类无处不在,不需要自己再创建.Object类是lang包类的根基类.

1. 常用方法

a、getClass：返回该对象的类型任何类都有它的类型

b、equals : Java中所有的equals 方法都是重写的Object类中的方法

原生的即Object类的equals 比较的是对象的地址，我们通常说的 equals比较两个对象的值是因为几乎所有的数据类型（包装类，String）都重写了equals 方法.

 public boolean equals(Object obj) {
   
        return (this == obj);
    }

c、 hashCode() ：返回该都对象的hash值

  // Object中的hashCode 本身没有实现 ，
        /**
         * 1、对于基本数据类型的包装类 其值就是其本身
         * 2、对于String类型的HashCode ，也是String自己实现的,其算法目的尽可能减少hash冲突
         * 3、对于自定义类，需要你自己重写HashCode ，如果不重写 就在程序运行期间 JVM根据内存地址
         *    类自动分配。（原则: 根据每个有意义的属性值，计算各自的hashCode 相加等一系列操作得到）
         */
//引用类型之间的比较:对象的hashcode(唯一标识)值相等时表示是同一个内存,地址(object--》object.toString()-->hashcode值)相等对象相等,内容/值相等对象不一定相等,这是哈希冲突,为了避免哈希冲突需要根据业务需求重写 hashCode()方法.

d：finalize() 资源回收时调用该方法,当对象地址不再被引用时,会被资源回收器回收并调用该方法

Object obj = null ;

e: toString() : 返回该对象的字符串表现形式（通常会被子类重写）

f: wait（）：线程等待

g: notify（）：唤醒其中一个等待的线程

h: notifyAll：唤醒所有等待中的线程

2.对象的比较

public class Student {
   
    private  int id; //学生编号
    private String sname;
    private Integer age;

    public void showInfo(){
   
        System.out.println( sname +"---"+ age);

    }

    public Student(){
   

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

    @Override
    public boolean equals(Object obj) {
   
        if(this == obj){
   
            return true;
        }
        // 判断类型 是否一致
        if(obj  instanceof  Student){
   
            // 强转
            Student stu = (Student)obj;
            // 开始比较 id 和 sname
            if(this.id == stu.id &&  this.sname.equals(stu.sname)){
   
                    return true;
            }
        }
        return false;


    }

    @Override
    public int hashCode() {
   
        return id;
    }
}

 public static void main(String[] args) {
   
          // 创建对象   比较对象是否相等
        // 比较内存相等 或 比较值（对象的属性）相等
        Student stu1 = new Student(1001,"敖园",22);
        Student stu2 = new Student(1001,"敖园",22);
        System.out.println(stu1==stu2);  // 比较两个对象的地址 （不相等）    false
        System.out.println(stu1.equals(stu2));   // true
        // 由于equals本身没办法解决两个对象因id 和name相等时业务上是同一个对象的问题
        // 所以需要重写 equals 和 hashcode方法 。
         // 为什么要重写HashCode呢?因为在JMV中如果HashCode不相等，一定不能认为是同一个对象

        Student stu3 = stu1;  // stu3 的地址与stu1的地址是同一个

    }

总结: 对象之间的比较，通常是比较属性值，如果属性值相等，我们可以认为是同一个对象，

此时需要重写 equals 和hashcode方法,以最大程度地降低哈希冲突(但有时仍不可避免):

hash冲突:对象不同,但是产生了相同的哈希码.

为什么要重写HashCode呢?

回答: 在JMV中如果HashCode不相等(hashcode方法返回一个hashcode数值,这个数值作为其存储空间的索引.这个方法被用于hash table,比如:hashmap)，表示对象存储内存不同,从而一定不能认为是同一个对象.

Java对象的eqauls方法和hashCode方法是这样规定的：

1、相等（相同）的对象必须具有相等的哈希码（或者散列码).

2、如果两个对象的hashCode相同，它们并不一定相同.

参考:https://www.cnblogs.com/Qian123/p/5703507.html#_label1

3、System类

public static void main(String[] args) {
   
        // System 属于系统类
       //  System.out; // 获取控制台的打印流
        // 设置JVM运行时系统参数
        System.setProperty("encoding","UTF-8");
        System.out.println("获取："+System.getProperty("encoding"));
        // 时间从 1970-01-01
        System.out.println("获取当前系统的时间毫秒数："+ System.currentTimeMillis());

        System.exit(0); // 0 ： 表示JVM正常退出    -1 表示非正常退出

    }

4、字符串类

java.lang.String类，Java中所有的字符串都是该类的实例 ,它可以对字符串进行查找，检索，转变大小写，截取等一系列操作，并提供了大量的字符串操作方法.

1.String类的特点：

它是一个不可变字符串，它的值创建后不能被改变

2.String的构造器

      // 创建字符串对象
        String s1="abc";
        String s2 = new String("abc");
        //通过字符数组构建
        char [] chars = {
   'a','b','c'};
        String s3 = new String(chars);  //  或指定长度构建字符串
        String s4 = new String(chars,0,2);
        //或根据字节数组构建
        byte [] byts = {
   97,98,99};
        String s5 = new String(byts);//转换成十进制ASCII码值(字节数)对应的字符后连接成字符串  0:48 A:65 a:97

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println(s5);

       //内存空间分析:
        // 字符串是一个不可变的对象
        // class类被JVM装载时，会分配一个存放字符串的常量池（String Pool）
        // 在类加载时 先检查常量池中是否有“abc”常量，如果有，直接将ss1指向该常量
        // 如果没有，则创建常量abc
        // 创建2个对象
        String ss1 = "abc";
        //  abc是常量不能改变,则再创建 abcd的常量，由ss1重新指向
        ss1+="d";

 // 创建3个对象
        String ss2 ="abcd";  // abcd
        String ss3 = "aaa";  // aaa
        ss2 += ss3;  // abcdaaa   重新创建abcdaaa并由ss2重新指向

    String a1="abc";
        String b1="abc"; // 两个地址同时指向一个常量 “abc”
        System.out.println(a1==b1);  // true
        System.out.println(a1.equals(b1));

        String c1=new String("abc"

最低0.47元/天解锁文章

~jiamin

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java包,正则表达式,定时器类,集合框架和泛型

一.Java常用类的包1.包的结构与功能介绍Java是一门面向对象的语言，sun公司提供基于面向对象的帮助文档（API Application Program Interface），并针对不同的版本生成的APIAPI中根据不同的功能分如下包（package）java.applet.* : java的小应用程序java.awt.* 和 java.swing.* : java的图形用户界面（开发单机版的小游戏）java.lang.* : java的语言包java.util.* : ja
复制链接

扫一扫