【JavaAPI】

最新推荐文章于 2024-09-30 10:36:33 发布

不知那场雨

最新推荐文章于 2024-09-30 10:36:33 发布

阅读量132

点赞数 3

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/2302_77085842/article/details/137411170

版权

本文详细介绍了Java中的Object类，包括其在对象表示和默认toString方法的应用。讲解了equals方法与==的区别，以及如何重写equals方法。还涉及数组操作、自动装箱拆箱、日期处理、Math和Random类的使用实例。

摘要由CSDN通过智能技术生成

Object类

import java.util.Arrays;

public class TestPerson {
    /*
    Object 可以表示java中任意的类
     */
    public static void main(String[] args) {
        new Person().hashCode();
        new int[10].clone();//数组也继承object

        Person p1 = new Person("张三",18);

        /*
        输出一个对象，但对象在内存中存储，是不能输出的，
        当输出一个对象时，会默认调用此对象的toString()，
        如果类中没有定义toString()，会调用Object类中toString().
        Object类中toString().是把对象在内存的哈希值返回（16进制）
        把对象信息以字符串形式输出

        我们自己类中可以对Object类中的toString()进行重写，后面调用时，就调用我们自己定义的toString()
         */

        System.out.println(p1);
    }
}

public class Person extends Object {
    private String name;
    private int age;

    public Person(){

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {//重写toString方法
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Person) {
            Person other = (Person) obj;
            return name.equals(other.name) && age == other.age;
        }
        return false;
    }
}
 /*
 ==和equals的区别
 
 ==比较等号两边是否相等
当==用于基本类型比较时，比较的是变最值是否相等
当==开于引用类型比较时,比较的是对象的地址是否相等
boolean equals(object obj) 判断两个对象是否相等
Object类中的equals
  public boolean equals(object obj){
       return(this == obj):默认比较的是两个对象的地址是否相等
       }*/

public class TestPerson2 {
    public static void main(String[] args) {

        /*
        == 比较等号两边是否相等

        当 == 用于基本类型比较时，比较的是变量值是否相等
        当 == 用于引用类型比较时，比较的是对象的地址是否相等
         */



        /*
        boolean equals(Object obj)  判断两个对象是否相等
        Object类中的equals

        默认比较的是两个对象的地址是否相等，我们就可以使用 == 代替它

        在其它类中一般都重写equals()方法，把它改造成比较对象中的内容是否相等
         */
        Person p1 = new Person("张三",18);
        Person p2 = new Person("张三",18);

        System.out.println(p1.equals(p2));


    }
}

Arrays类

import java.util.Arrays;

public class Arrays1 {
    public static void main(String[] args) {
        /*
        比较两个数组的内容是否相等
         */
        int[] a = {1,2,3,4,5};
        int[] b = {1,2,3,4,3};

        System.out.println(Arrays.equals(a,b));


     /*
     copyOf 数组复制
        将原数组内容复制到一个指定长度的新数组中
      */
        int[] c = new int[5];
        c[0] = 1;
        c[1] = 2;
        c[2] = 3;
        c[3] = 4;
        c[4] = 5;

        int[] d = Arrays.copyOf(c,10);
        System.out.println(Arrays.toString(d));


        /*
        fill()  用指定的值，将指定数组中的每个元素填充
         */
        int[] e = {1,2,3,4,5};
        Arrays.fill(e,0);
        System.out.println(Arrays.toString(e));
      //toString() 将数组中的元素内容拼接成一个字符串输出
    }
}

import java.util.Arrays;

public class Arrays2 {
    public static void main(String[] args) {
        /*
    sort()  对指定的数组进行升序的排序
     */
        long[] a = {5,4,3,2,1};
        //Arrays.sort(a);//0-length-1
        //System.out.println(Arrays.toString(a));


        //Arrays.sort(a,开始排序的位置，结束排序位置（不包含）)
        Arrays.sort(a,0,3);
        System.out.println(Arrays.toString(a));



        /*
     binarySearch() 二分搜索算法查找指定元素位置，如果位置未找到，返回负数，前提是数组有序
     */
        int[] b = {2,3,4,1,5};
        Arrays.sort(b);
        int index = Arrays.binarySearch(b,3);
        System.out.println(index);
    }

}

/*

   一个类要进行排序，那么这个类必须实现Comparable接口，指定一个排序的方法（这样所有的类都是以统一的方法进行排序）

 */
public class Student implements Comparable<Student> {
    private int ID;
    private String name;

    public Student(int ID, String name) {
        this.ID = ID;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "ID=" + ID +
                ", name='" + name + '\'' +
                '}';
    }

    /*
    用来指定排序规则：
    可以执行用类中那个属性作为排序的项
    这个方法在sort()方法的底层调用，来判断大小
     */

    @Override
    public int compareTo(Student o) {
        //return this.ID - o.ID;
        return this.name.compareTo(o.name);
    }
}

自动装箱和自动拆箱

public class IntegerDemo1 {
    public static void main(String[] args) {
        Integer a = new Integer(10);
        Integer b = new Integer(10);

        /*
        自动拆箱：把引用类型转为基本类型
         */
        int c = a.intValue();
        int d = b;
     /*
     自动装箱：把基本类型转为引用类型
             自动装箱 会默认的自动调用valueOf()方法
             在valueOf()中如果 基本类型值在-128--+127之间，会从缓存数组中直接取出一个Integer对象，减少创建次数
             如果两个值相同，获取同一个对象
             基本类型值如果不在这个区间，每次都创建一个新Integer对象返回
      */
        int x = 128;
        int yy = Integer.valueOf(x);
        System.out.println(yy);

        Integer y = x;//自动装箱 会默认的自动调用valueOf()方法

        Integer z = x;
        System.out.println(z.equals(x));
        System.out.println(y == z);//x = 10 true   x = 128 false
        System.out.println(y.equals(z));
    }
}

public class Intergerdemo {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.BYTES);

        Integer a = new Integer(10);//构造Integer对象，里面包着一个基本类型值，用该对象表示一个int值
        Integer b = new Integer("20");

        System.out.println(a);
        System.out.println(b);

        System.out.println(Integer.toBinaryString(6));
    }
}

Data类

/*
自定义日期工具类
 */
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtil {
    public static void main(String[] args) throws ParseException {
        String s = "2024-2-28";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = simpleDateFormat.parse(s);
        System.out.println(date);

        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日");
        String s1 = simpleDateFormat1.format(date1);
        System.out.println(s1);
    }
}

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();//获取程序运行时刻的时间
        System.out.println(date);
        System.out.println(date.getDate());// 方法上有删除线，表示此方法已弃用，有新的类替代，但是也可以使用
        //获取的是自1970 1.1 0：0：0 至程序运行时的毫秒值
        System.out.println(date.getTime());

        Date date1 = new Date();
        System.out.println(date1.getTime()-date.getTime());

        Date date2 = new Date(12232411223L);//将指定的long类型的时间戳构造出一个时间对象
        System.out.println(date2);
    }
}

String类

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);

        calendar.get(Calendar.YEAR);
        calendar.get(Calendar.DAY_OF_MONTH);
        calendar.get(Calendar.DAY_OF_WEEK);
        calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);
    }
}

Math类

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-3));//绝对值
        System.out.println(Math.sqrt(9));//平方根
        System.out.println(Math.pow(2,3));//2的3次幂

        System.out.println(Math.floor(9.9));//向下取近似值
        System.out.println(Math.ceil(9.1));//向上取近似值
        System.out.println(Math.round(9.3));
        System.out.println(Math.round(9.5));//四舍五入

        System.out.println(Math.max(18,5));
        System.out.println(Math.random());//返回0-1之间的随机数 可能会等于0
    }
}

Random类

import java.util.Arrays;
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextBoolean());
        System.out.println(random.nextInt());//在int取值范围之内随机返回一个整数
        System.out.println(random.nextInt(35)+1);//在给定范围内随机获取一个数 0=<res<给定数

        byte[] bytes = new byte[5];
        random.nextBytes(bytes);//随机取出数组长度个byte类型的随机数
        System.out.println(Arrays.toString(bytes));
    }
}

SimpleDateFormat

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        String s = "2002-2-3";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(s);
        System.out.println(date.getYear()+1900);

        /*
        把日期的对象转为指定格式的字符串
         */
        Date date1 = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        String  s1 = sdf1.format(date1);
        System.out.println(s1);
    }
}