Java教程

JAVA自学笔记(Object常用类)

本文主要是介绍JAVA自学笔记(Object常用类),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1、Object类

  • 超类、基类,所有类的直接或者间接父类,位于继承树的最顶层

  • 任何类,如果没有书写extends显示继承某个类,全都默认直接继承Object类,否则为间接继承

  • Object类中所定义的方法,是所有对象都具备的方法

  • Object类型可以存储任何对象。

    • 作为参数,可接受任何对象

    • 作为返回值,可以返回任何对象。

1.1、getClass()方法

  • public final Class<?> getClass(){}

  • 返回引用中存储的实际对象类型

  • 应用:通常用于判断两个引用中实际存储对象类型是否一致。

  • public class TestgetClass {
        public static void main(String[] args) {
            Student student1 = new Student("张三",15);
            Student student2 = new Student("李四",18);
            Square square = new Square(12);
            Class class1 = student1.getClass();
            System.out.println(class1);
            Class class2 = student2.getClass();
            Class class3 = square.getClass();
            if(class1 == class2){
                System.out.println("s1和s2是同一个类型");
            }else {
                System.out.println("s1和s2不是同一个类型");
            }
            if(class1 == class3){
                System.out.println("s1和Square是同一个类型");
            }else {
                System.out.println("s1和Square不是同一个类型");
            }
        }
    }
    //输出结果
     class com.qf.day12_2.Student(Student student1 = new Student("张三",15);      Class class1 = student1.getClass();)
     s1和s2是同一个类型  //(class1 == class2)
     s1和Square不是同一个类型  //(class1 == class3)

1.2hashCode()方法

  • public int hashCode(){}。

  • 返回该对象的哈希码值。

  • 哈希值根据对象的地址字符串数字使用hash算法计算出来的int类型的数值。

  • 一般情况下相同对象返回相同的哈希码。

  • 同类型对象返回的哈希值不一样。

  • public class TestgetClass {
        public static void main(String[] args) {
            Student student1 = new Student("张三",15);
            Student student2 = new Student("李四",18);
            int hashCode1 = student1.hashCode();
            int hashCode2 = student1.hashCode();
            int hashCode3 = student2.hashCode();
            if(hashCode1 == hashCode2){
                System.out.println("s1两次返回的哈希值一样");
            }else {
                System.out.println("s1两次返回哈希值不一样");
            }
            if(hashCode1 == hashCode3){
                System.out.println("s1和s2的哈希值一样");
            }else {
                System.out.println("s1和s2的哈希值不一样");
            }
        }
    }
    //输出结果
    s1两次返回的哈希值一样
    s1和s2的哈希值不一样

1.3、toString()方法

  • public String toString (){}

  • 返回该对象的字符串表示(表现形式)

  • 可以根据程序需求覆盖该方法。如:展示对象各个属性。

Student student2 = new Student("李四",18);
System.out.println(student2.toString());
//输出结果
com.qf.day12_2.Student@73035e27(哈希值)

1.4、equals()方法

  • ==(基础数据类型比较数值,引用类型比较地址)

  • public Boolean equals(Object obj){}

  • 默认实现为(this = = obj),比较两个对象地址是否相等。

  • 可以进行覆盖,比较两个对象的内容是否相等。(覆盖步骤)

    • 比较两个引用是否指向同一个对象

    • 判断obj是否为null

    • 判断两个引用指向的实际对象类型是否一致

    • 强制类型转换

    • 依次比较各个属性值是否相等

@Override
public boolean equals(Object obj) {
    //判断两个引用是否指向同一个对象
    if(this == obj){
        return true;
    }
    //判断obj是否为null
    if(obj == null){
        return false;
    }
    //判断两个运用指向的实际对象是否一致
    if(obj instanceof Student) {
        //强制类型转换
        Student s = (Student)obj;
        //依次比较各个属性值是否相等
        if(this.name.equals(s.getName()) && this.age == s.getAge()){
            return true;
        }
    }
    return false;
}

1.5、finalize()方法

  • 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列

  • 垃圾对象:没有有效引用指向此对象时,为垃圾对象

  • 垃圾回收:由GC销毁垃圾对象,释放数据存储空间

  • 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象。

  • 手动回收机制:使用System.gc();通知JVM执行垃圾回收。

2、包装类

2.1、什么是包装类

  • 基本数据类型所对应的引用数据类型。(基础数据类型直接存储在栈内存中,引用类型存放在堆内存中)

  • Object可统一所有数据,包装类的默认值是null;

  • 包装类对应关系

基本数据类型包装类型
intInteger
shortShort
longLong
doubleDouble
charCharacter
booleanBoolean
floatFloat
byteByte

2.2、类型转换和装箱与拆箱

  • 装箱:基本数据类型装换为引用数据类型

  • int i = 100;
    Integer integer = new Integer(100);
  • 拆箱:引用数据类型转换为基本数据类型

  • int n2 = integer.intValue();
  • JDK1.5之后提供自动装箱和拆箱

  • num = integer3.valueOf()  //自动拆箱
  • parseXXX()静态方法,(装换为XXX类型)

  • valueOf()静态方法。

  • 注意:需要保证类型兼容,否则抛出NumberFormatException异常。

2.3、Integer缓冲区

  • JAVA预先创建了256个常用的整数包装类型对象。【-128~127】,256个常用整数已经提前创建好,内存地址已经分配好了。在实际开发中,对已经创建的对象进行复用。节省内存消耗

public static void main(String[] args) {
    Integer integer1 = new Integer(100);
    Integer integer2 = new Integer(100);
    System.out.println(integer1 == integer2);//false
​
    Integer integer3 = Integer.valueOf(127);
    Integer integer4 = Integer.valueOf(127);
    System.out.println(integer3 == integer4);//true
​
    Integer integer5 = Integer.valueOf(-128);
    Integer integer6 = Integer.valueOf(-128);
    System.out.println(integer5 == integer6);//true
​
    Integer integer7 = Integer.valueOf(128);
    Integer integer8 = Integer.valueOf(128);
    System.out.println(integer7 == integer8);//false,内存地址不一样
}

3、String类

  • 字符串是常量,创建之后不可改变

  • 基础类型转换换成字符串

    • //字符串转换为String类型
      int num = 10;
      //1.:使用 +
      String  s = num + "";  //输出:10
      
      //2.使用Integer提供的方法
      String s2 = Integer.toString(num); //输出:10
      
      //二进制字符串类型
      String s3 = Integer.toBinaryString(num);//输出:1010
      
      //十六进制字符串类型
      String s4 = Integer.toHexString(num); //输出:A
      
      //字符串转换为基础类型
       String s5 = "1000";
       int n = Integer.parseInt(s5);  //输出: 1000
      
       //特殊Boolean类型转换
       String  s6 = "true"; // 字符串除了true之外,转化为Boolean全是false
       boolean b = Boolean.parseBoolean(s6);  //输出:true
  • 字符串字面值存储在字符串池,可以共享。JDk1.7之前存储在方法区中,JDK1.7之后移动到堆中

  • String name = "hello";//"hello"常量存储在字符串池中

  • String name = "hello";//"hello"常量存储在字符串池中
    name = "zhangsan";//“zhangsan”赋值给name变量,给字符串赋值时,并没有修改数据,而是重                     //新开辟空间赋给name

  • String name = "hello";//"hello"常量存储在字符串池中
    name = "zhangsan";//“zhangsan”赋值给name变量
    String name2 = "zhangsan";//首先去字符串池中寻找“zhangsan”,如果有,则                                      //将“zhangsan”的地址给name2,如果没有,创建空间存储

  • String s = "Hello ";产生一个对象,字符串池中存储

  • String str = new String("java "); 创建两个对象,堆、池各存储一个。

  • ==比较地址 String中的equal被重写,比较char数组,内容一样就返回true

  • String address = "北京";
    String address1 = new String("北京");
    System.out.println(address==address1);  //输出结果:false
    System.out.println(address.equals(address1);//输出结果:true
    
    String address2 = new String("北京");
    System.out.println(address2==address1);//输出结果:false
    System.out.println(address2.equals(address1);//输出结果:true
  • String str = new String("java ");

String str2 = new String("java ");

System.out.println(str == str2); //false

3.1、常用方法

  • public int length ()返回字符串长度(空格也算字符)

  • String  test = "adSHOqwno45668asdas";
    int i = test.length();
    System.out.println("字符串的长度:"+i);
    //输出结果:字符串的长度:19
  • public char charAt(int index)根据下标获取字符

  • char c = test.charAt(5);
    System.out.println("test的第5个下标的字符是:"+c);
    //输出结果:test的第5个下标的字符是:q
  • public boolean contains(String str)判断当前字符串中是否包含str

boolean b = test.contains("wno456");
System.out.println("test中包含wno456:"+ b);
//输出结果:test中包含wno456:true
  • public char[] toCharArray() 将字符串转换成数组

  • System.out.println(Arrays.toString(test.toCharArray()));
    //输出结果:[a, d, s, h, o, q, w, n, o, 4, 5, 6, 6, 8, a, s, d, a, s]
  • public int indexOf(String str) 查找str首次出现的下标,存在则返回该下标,不存在返回-1

  • System.out.println(test.indexOf("wno456"));
    //输出结果:6
  • public int lastIndexOf(String str)查找字符串在当前字符串中最后一次出现的下标索引。

  • System.out.println(test.lastIndexOf("as"));
    //输出结果:17
  • public String trim() 去掉字符串前后的空格

  • System.out.println(test.trim());
    //输出结果:adSHOqwno45668asdas
  • public String toUpperCase() 将小写转成大写

  • System.out.println(test.toUpperCase());
    //输出结果:ADSHOQWNO45668ASDAS
  • public boolean endWith(String str) 判断字符串是否以str结尾

  • System.out.println(test.endsWith("as"));
    //输出结果:true
  • public String replace(char oldChar , char newChar)将旧字符串替换成新字符串

  • System.out.println(test.replace("6","@"));
    //输出结果:adSHOqwno45@@8asdas
  • public String[] split(String str) 根据str将字符串拆分,[ a,]可以选择多个分隔符,使用两个分割标记,[ a,]+“+”表示可以出现多个a或者,进行分割 + 正则表达式表示前面的空格可以出现一次或者多次

  • System.out.println(Arrays.toString(test.split(&quot;a&quot;)));
    //输出结果:[, dSHOqwno45668, sd, s]
  • equalsIgnoreCase:忽略大小写比较

  • String s1 = "hello";
    String s2 = "HELLO";
    System.out.println(s1.equalsIgnoreCase(s2));
    //输出结果:true
  • compareTo() 通过字典比较大小

String s3 = "abc"; //a在字典97
String s4 = "xyz";  //z在字典122
System.out.println(s3.compareTo(s4));
//输出结果:-23
  • compareTo() 通过字典比较大小,第一个比完比第二个。如果s4的长度大于s3,并且s3的全部和s4的前面一样,此时返回长度的差异,两个一模一样返回:0

  • String s3 = "abc"; 
    String s4 = "abczty";  
    System.out.println(s3.compareTo(s4));
    //输出结果:-3
public static void main(String[] args) {
    String  string = "java是世界最好的语言,我爱java,java真香";
    //返回指定下标的字符
    char c = string.charAt(string.length()-1);
    System.out.println(c);  //输出结果:香
    //判断传递的参数是否在字符串中
    boolean b = string.contains("最好");
    boolean b1 = string.contains("PHP");
    System.out.println(b);  //输出结果:true
    System.out.println(b1);  //输出结果:false
    //将字符串转成字符串数组
    char[] chars = string.toCharArray();
    System.out.println(chars);   //输出结果:java是世界最好的语言,我爱java,java真香
    System.out.println(chars.length);  //输出结果:26
    
    //返回参数字符串在字符串的首次出现的位置    从下标6开始
    int pos=string.indexOf("java",6);
    System.out.println(pos);   //输出结果:15
    //需求:打印Java出现的所以位置
    //返回字符串的长度
    System.out.println(string.length());26
    //trim(),去掉字符串的前后空格。
    String str2 = "   hello   word    ";
    System.out.println(str2);   //输出结果:      hello   word  
    System.out.println(str2.trim());   //输出结果:hello   word

    //将字符串转换为大写(toUpperCase) ,小写(toLowerCase)
    System.out.println(str2.trim().toUpperCase());   //输出结果:HELLO   WORD

    //判断字符串是否以参数结尾
    String filename = "HelloWord.java";
    System.out.println(filename.endsWith(".java"));  //输出结果:true
    //判断字符串是否以参数开始
    System.out.println(filename.startsWith("Hello"));   //输出结果:true

    //replace  替换,将旧字符串转换为新字符串
    String  str3 = string.replace("java","PHP");
    System.out.println(str3);   //输出结果:PHP是世界最好的语言,我爱PHP,PHP真香

    //split:拆分
    String city  = "北京,上海,南京,郑州";
    String[] cities = city.split(",");
    for(String c1 : cities){
        System.out.print(c1+"\t");   //输出结果:北京,上海,南京,郑州    
    }

    //subString  截取(含头不含尾)
    String str4 = string.substring(string.indexOf("我"));
    System.out.println(str4);   //输出结果:我爱java,java真香
}

4、StringBuilder和StringBuffer(可变长字符串)

  • 概念:可在内存中创建可变的缓存空间,存储频繁改变的字符串。效率远高于String

  • StringBulider:可变长字符串,JDK5.0提供,运行效率快、线程不安全

  • StringBuffer:可变字长符串,JDK1.0提供,运行效率慢、线程安全

  • StringBulider和StringBuffer常用方法

public static void main(String[] args) {
    StringBuilder sb = new StringBuilder();
    //追加(append)
    sb.append("java是最好的语言");
    sb.append(",我爱PHP");
    sb.append(",我讨厌C语言");
    System.out.println(sb);   //java是最好的语言,我爱PHP,我讨厌C语言
    //添加(insert)
    sb.insert(0,"hello,");
    System.out.println(sb);  //hello,java是最好的语言,我爱PHP,我讨厌C语言
    //替换(replace) 含头不含尾
    sb.replace(0,1,"H"); 
    System.out.println(sb);//Hello,java是最好的语言,我爱PHP,我讨厌C语言
    //删除(delete)含头不含尾 从0开始
    sb.delete(0,6);
    System.out.println(sb);  //java是最好的语言,我爱PHP,我讨厌C语言
    //清空
    sb.delete(0,sb.length());
    System.out.println(sb.length());  //0
    //reverse   反转
    StringBuilder sb = new StringBuilder("java是世界最好的语言,我爱java,java真香");
    System.out.println(sb);   //java是世界最好的语言,我爱java,java真香
    System.out.println(sb.reverse());  //香真avaj,avaj爱我,言语的好最界世是avaj
}
  • StringBuilder运行效率

  • long start = System.currentTimeMillis();
    StringBuilder sb = new StringBuilder();
    for(int i=0 ;i<99999;i++){
        sb.append(i);
    }
    long end = System.currentTimeMillis();
    System.out.println("用时:"+ (end-start));   //用时:10
String sb = "";
long start = System.currentTimeMillis();
for(int i=0 ;i<99999;i++){
    sb = sb +i;
}
long end = System.currentTimeMillis();
System.out.println("用时:"+ (end-start)); //用时:4138

5、BigDecimal类

  • 很多实际应用中需要精确运算,但是double是近似值存储,不符合要求,所以使用BigDecimal提高精度。

  • 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
  • 位置:java.math包中

  • 作用:精确计算浮点数

  • 创建方式:

    BigDecimal   bd   =   new   BigDecimal  (" 1.0 ")  ;
  • 常用方法

  • //add  加法
    System.out.println((new BigDecimal("1.0")).add(new BigDecimal("0.9")));  //1.9
    //subtract  减法
    System.out.println((new BigDecimal("1.0")).subtract(new BigDecimal("0.9")));  //0.1
    //multiply  乘法
    System.out.println((new BigDecimal("1.0")).multiply(new BigDecimal("0.9")));  //0.90
    //divide  除法  BigDecimal.ROUND_HALF_UP  四舍五入     2  保留两位小数
    System.out.println((new BigDecimal("20")).divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP));  //6.67
    
      //除法的问题,除不尽的时候需要保留小数的位数(scale),四舍五入(roundingMode.HALF_UP)五舍六入(roundingMode.HALF_DOWN)
            BigDecimal bd3 = new BigDecimal("10");
            BigDecimal bd4 = new BigDecimal("3");
            BigDecimal result5 = bd3.divide(bd4,21, RoundingMode.HALF_UP);
            System.out.println(result5);

6、Math类

System.out.println(Math.E);   //  2.718281828459045
//圆周率
System.out.println(Math.PI);  //3.141592653589793
//立方根
System.out.println(Math.cbrt(27));  //3.0
//平方根
System.out.println(Math.sqrt(9));  //3.0
//返回大于或者等于这个数的最小整数
System.out.println(Math.ceil(3.8));  //4.0
//返回小于或者等于这个数的最大整数
System.out.println(Math.floor(5.5));   //5.0
//pow  返回a数的b次幂
System.out.println(Math.pow(2,10));   //1024.0
//random  返回0-1之间的小数   不等于1,可以等于0
System.out.println(Math.random());    //0.9454350386657077
//需求:返回一个0-9之间的一个小数
System.out.println((int)(Math.random()*10));  //4
//需求  返回50-100之间的随机数  (a到b之间的数   Math.random()*(b-a+1)+a)
System.out.println((int)(Math.random()*51)+50);  //85
//需求  返回100-999之间的随机数  (999-100+1)
System.out.println((int)(Math.random()*(999-100+1))+100);   //466
//round() 返回整数  四舍五入取整
System.out.println(Math.round(3.1415926));  //3
System.out.println(Math.round(3.6663));   //4
//round()保留两位小数
System.out.println(Math.round(3.1415926*100)/100.0);   //3.14

//总结四舍五入的方法
// (1)System.out.printf   %.2f
//  (2)Math.round();
// (3)DecimalFormat类实现
DecimalFormat df = new DecimalFormat("#.00"); //#表示整数位置  ,00表示两位小数
System.out.println(df.format(3.1415926));   //3.14
//  (4)BigDecimal类实现
BigDecimal bd = new BigDecimal("3.1415926");
System.out.println(bd.setScale(2, RoundingMode.HALF_UP));   //3.14

7、Date类、Calenda类

  • Date表示特定的瞬间,精确到毫秒。Date类中的大部分方法已经被Calender类中的方法取代。

  • 事件单位

    • 1秒=1000毫秒

    • 1毫秒= 1000微秒

    • 1微秒 =1000纳秒

    //今天
    Date date = new Date();
    System.out.println(date.getTime());
    System.out.println(date.toString());
    //昨天
    Date yes = new Date(date.getTime()-60*60*24*1000);
    System.out.println(yes.toString());
    System.out.println("________________________________________________________");
    //创建日历对象
            Calendar calendar = Calendar.getInstance();
    //获取年
    System.out.println(calendar.get(Calendar.YEAR));   //2021
    //获取月
    System.out.println(calendar.get(Calendar.MONTH)+1);  //6
    //获取日
    System.out.println(calendar.get(Calendar.DAY_OF_MONTH));   //5
    //获取小时
    System.out.println(calendar.get(Calendar.HOUR_OF_DAY));  //15
    //获取分钟
    System.out.println(calendar.get(Calendar.MINUTE));    //31
    //获取秒
    System.out.println(calendar.get(Calendar.SECOND));   //10
    
    //设置时间
    //创建  2010-10-1 15:30:20
    Calendar calendar1 = Calendar.getInstance();
    calendar1.set(2010,9,1,15,30,20);
    System.out.println(calendar1.getTime().toString());   //Fri Oct 01 15:30:20 CST 2010
    
    //add 添加或者减少指定的时间
    Calendar yes1 = Calendar.getInstance();
    yes1.add(Calendar.DAY_OF_MONTH,-1);
    System.out.println(yes1.getTime().toString());   //Fri Jun 04 15:31:10 CST 2021
    
    Calendar tomorrow  = Calendar.getInstance();
    tomorrow.add(Calendar.DAY_OF_MONTH,1);
    System.out.println(tomorrow.getTime().toString());  //Sun Jun 06 15:31:10 CST 2021
      //当前月的最小条数,最大天数
     System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));  //30
     System.out.println(calendar.getActualMinimum(Calendar.DAY_OF_MONTH));   //1

8、System类

//Systrm :系统类的使用
//arraycopy():复制数组
//src  复制的原数组  srcPos: 从哪个位置开始复制  dest:目标数组
//destPos:从目标数组的那个位置开始存放   length:复制的长度
int[] arr = {10,8,20,4866,6541,51};
int[] dest = new int[arr.length*2];
System.arraycopy(arr,0,dest,4,5);
System.out.println(Arrays.toString(dest));   //[0, 0, 0, 0, 10, 8, 20, 4866, 6541, 0, 0, 0]

//currentTimeMillis();返回从1790.1.1(UNIX出现)到现在的好描述,用来计算代码的执行时间
System.out.println(System.currentTimeMillis());   //1622880403100

//System.gc();  告诉垃圾回收器回收垃圾

//System.exit(status);0  表示正常退出  非0  非正常退出
System.exit(0);
System.out.println("程序结束.....");  //无输出

9、SimpleDateFormat类

Date date = new Date();
System.out.println(date.toString());  //Sat Jun 05 16:11:24 CST 2021
//格式化时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println(sdf.format(date));  //2021-06-05 04:12:05

//解析时间(字符串转化为时间)
String s = "2020-05-06 17:20:30";
Date date1 = sdf.parse(s);
System.out.println(date1);  //Wed May 06 17:20:30 CST 2020

10、Runtime类

// 获取运行时对象
Runtime runtime = Runtime.getRuntime();
System.out.println(runtime);
//exec();在单独的进程中执行命令
Process p = runtime.exec("notepad");  //打开记事本

Thread.sleep(5000);

//销毁进程
p.destroy();  //关闭记事本
//exit() 退出JVM   System中的exit调用的就是runtime的exit
//gc()    告诉垃圾回收器回收垃圾   System中的gc调用的就是runtime的gc
//打印程序所占(堆)的内存空间
System.out.println("总的内存大小:"+ runtime.totalMemory()/1024/1024 + "MB");  //总的内存大小:128MB
 System.out.println("空闲内存大小:"+ runtime.freeMemory()/1024/1024 + "MB");   //空闲内存大小:124MB
 System.out.println("最大内存大小:"+ runtime.maxMemory()/1024/1024 + "MB");    //最大内存大小:2018MB

这篇关于JAVA自学笔记(Object常用类)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!