Java学习随笔

Object类的toString方法

将一个对象返回为字符串形式，但一般使用的时候会覆盖重写toString方法 Object类是所有类的父亲

1//
2public class Person {
3    private String name;
4    private int age;
5//=============================================================================
6    public String toString(){//toString方法被覆盖重写，返回了一个固定格式的内容。
7       return  "我的名字是"+this.name+"今年我"+this.age+"岁了";
8    }
9//=============================================================================
10    public Person() {
11    }
12
13    public Person(String name, int age) {
14        this.name = name;
15        this.age = age;
16    }
17
18    public String getName() {
19        return name;
20    }
21
22    public void setName(String name) {
23        this.name = name;
24    }
25
26    public int getAge() {
27        return age;
28    }
29
30    public void setAge(int age) {
31        this.age = age;
32    }
33}
34
35
36public class personMain {
37
38    public static void main(String[] args) {
39        Person person = new Person();
40        person.setAge(18);
41        person.setName("迪丽热巴");
42        System.out.println(person.toString());
43    }
44}

Object类中的equals方法

equals方法默认比较的是对象的地址值，经常需要重写equals方法

重写equals方法

1//person类
2public class Person {
3    private String name;
4    private int age;
5
6    public boolean equals(Object obj){
7        //传递参数如果是this本身，为了提高效率，直接返回true
8        if (obj == this) {
9            return true;
10        }
11        //传递参数如果是null,为了提高效率，直接返回false；
12        if (obj == null)
13            return false;
14   //==========================================================//主要部分
15        //向下转型，因为这是一个隐含的多态，多态无法访问子类特有内容
16        //Object obj = p2 = new Person("迪丽热巴", 19);
17        Person p = (Person) obj;
18        //this表示传过去的第一个，p表示传过去的第二个
19        boolean b = this.name.equals(p.name)&&this.age==p.age;
20        return b;
21  //============================================================
22    }
23    //也可以通过自动实现
24   /* @Override
25    public boolean equals(Object o) {
26        if (this == o) return true;
27        if (o == null || getClass() != o.getClass()) return false;
28        Person person = (Person) o;
29        return age == person.age &&
30                Objects.equals(name, person.name);
31    }
32
33    @Override
34    public int hashCode() {
35        return Objects.hash(name, age);
36    }*/
37
38    public Person() {
39    }
40
41    public Person(String name, int age) {
42        this.name = name;
43        this.age = age;
44    }
45
46    public String getName() {
47        return name;
48    }
49
50    public void setName(String name) {
51        this.name = name;
52    }
53
54    public int getAge() {
55        return age;
56    }
57
58    public void setAge(int age) {
59        this.age = age;
60    }
61}
62
63
64//主类
65public class equalsMain {
66
67    public static void main(String[] args) {
68        Person person1 = new Person();
69        Person person2 = new Person();
70
71        person1.setName("江疏影");
72        person1.setAge(18);
73        person2.setName("江疏影");
74        person2.setAge(18);
75
76        System.out.println(person1.equals(person2));
77    }
78}

object类中的equals和objects类中的equals的区别，objects类中的equals可以防止空指针异常。

Date类

打印当前系统时间：

1public class Data {
2    public static void main(String[] args) {
3        Date date = new Date();
4
5        System.out.println(date);
6    }
7}

格式化系统的时间格式

y--->年 M--->月 d--->日
H--->时 m--->分 s--->秒

1public class dateformate {
2
3    public static void main(String[] args) {
4        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");//写出固定格式的构造方法
5        Date date = new Date();//创建一个时间
6        System.out.println(date);
7        String str = sdf.format(date);//调用format
8        System.out.println(str);
9
10    }
11}

按照固定格式将文本解析为日期

1public class dateformat2 {
2
3    public static void main(String[] args) throws ParseException {//throws是异常抛出，
4        SimpleDateFormat stf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");//创建固定格式的构造方法
5        Date date = stf.parse("2019年07月29日 17时29分03秒");//定义Date类来接收
6        System.out.println(date);
7    }
8}

得到毫秒值

1public class gettime {
2
3    public static void main(String[] args) {
4        Date date = new Date();
5        long time = date.getTime();
6        System.out.println(time);
7    }
8}

案例--计算出生天数

1import java.text.ParseException;
2import java.text.SimpleDateFormat;
3import java.util.Date;
4import java.util.Scanner;
5
6public class birthday {
7    public static void main(String[] args) throws ParseException {//异常抛出
8        System.out.println("请输入您的生日：格式：yyyy-MM-dd");
9        Scanner sc = new Scanner(System.in);
10        String birthday = sc.next();//输入日期
11        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//写固定格式的构造方法
12        Date date = sdf.parse(birthday);//将日期转换成Date类型的日期
13        long beforeTime = date.getTime();//将出生时间转换为毫秒值
14        long nowTime = new Date().getTime();//将当前系统时间转换为毫秒值
15        long time = nowTime - beforeTime;
16        System.out.println(time/1000/60/60/24);//将毫秒值转换为天
17    }
18}

Calendar类

1public class calendarl {
2
3    public static void main(String[] args) {
4        Calendar c = Calendar.getInstance();//获取日历信息
5        System.out.println(c);//将会输出一堆与当前日历有关的信息
6    }
7}

Calendar中的get方法 可以返回给定日历字段的值

1public class calendarget {
2
3    public static void main(String[] args) {
4        Calendar c = Calendar.getInstance();//获取calendar类的对象
5        int year = c.get(Calendar.YEAR);//得到年
6        System.out.println(year);
7        int month = c.get(Calendar.MONTH);//得到月
8        System.out.println(month);
9        int date = c.get(Calendar.DATE);//得到日
10        System.out.println(date);
11    }
12}

Calendar中的set方法 设置年月日

1public class calendset {
2
3    public static void main(String[] args) {
4        Calendar c = Calendar.getInstance();
5        c.set(Calendar.YEAR,2000);//将年设置为2000年
6        c.set(Calendar.MONTH,11);//将月设置为11月
7        c.set(2000,03,03);//同时设置年月日
8        System.out.println(c.get(Calendar.YEAR)+" "+c.get(Calendar.MONTH)+" "+c.get(Calendar.DATE));
9    }
10}

calendar中的add方法 把指定字段增加或减少指定的值，正数为增加，负数为减少 public class calendset {

1public static void main(String[] args) {
2    Calendar c = Calendar.getInstance();
3
4    c.set(2000,03,03);//同时设置年月日
5    c.add(Calendar.YEAR,2);//把年增加两年
6    c.add(Calendar.MONTH,-2);//把月减少两个月
7    System.out.println(c.get(Calendar.YEAR)+" "+c.get(Calendar.MONTH)+" "+c.get(Calendar.DATE));
8}

}

calendar中的getTime方法 将日历转换为日期，即准换为Date格式

1public class calendset {
2
3    public static void main(String[] args) {
4        Calendar c = Calendar.getInstance();
5
6        c.set(2000,03,03);//同时设置年月日
7        Date time = c.getTime();//将日历格式转换为日期
8        System.out.println(time);
9
10    }
11}

System类的常用方法

System类中的currentTimeMillis方法 返回以毫秒为单位的当前时间，可以计算程序的运行时间

1public class currenttime {
2
3    public static void main(String[] args) {
4        long start = System.currentTimeMillis();
5        for (int i = 0; i < 9999; i++) {
6            System.out.println(i);
7        }
8        long end = System.currentTimeMillis();
9        System.out.println(end-start);
10    }
11}

System类中的arraycopy方法

从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 static void arraycopy(源数组, 源数组起始位置, 目标数组, 目标数组, 要复制的数组元素的数量。 )

1public class arraycopyl {
2
3    public static void main(String[] args) {
4        int[] array1 = {1,2,3,4,5};
5        int[] array2 = {6,7,8,9,10};
6        System.arraycopy(array1,0,array2,0,3);
7        System.out.println(Arrays.toString(array1));
8        System.out.println(Arrays.toString(array2));
9    }
10}

StringBuilder中常用的方法

StringBuilder中的append方法 像此序列中追加一个数据，数据可以是任何类型 StringBuilder是一个字符缓冲区，可以提高效率

1public class StringBuilderappend {
2
3    public static void main(String[] args) {
4        StringBuilder s = new StringBuilder();
5        s.append(1);
6        s.append('a');
7        s.append("fadsf");
8        s.append(1).append(2).append('i');//也可以这样连续添加数据
9        System.out.println(s);
10    }
11}
12

StringBuilder和String的互换 当我们需要对一个字符串进行频繁的删除添加操作的时候，使用stringBuiler的效率比较高。因为String是一个常量，使用一次就多一个字符串类型。

1public class StringandStringBuilder {
2
3    public static void main(String[] args) {
4        String str = "hello";
5        StringBuilder s = new StringBuilder(str);//将String类型转换为StringBuilder类型。
6        String str2 = s.toString();//通过toString把StringBuilder类型转换为String类型。
7        System.out.println(str2);
8    }
9}

装箱-->把基本数据类型包装到包装类中

可以使用构造方法和静态方法

1public class box {
2
3    public static void main(String[] args) {
4        Integer a = new Integer(3);//使用构造方法将3装进包装类中，但方法已过时
5        Integer b = Integer.valueOf(4);//使用方法将4放入包装类中
6    }
7}

拆箱-->在包装类中取出基本类型

1public class box {
2
3    public static void main(String[] args) {
4        Integer b = Integer.valueOf(4);//使用方法将4放入包装类中
5        int a = b.valueOf(b);//将包装类转换成整形
6    }
7}

自动装箱与自动拆箱

自动装箱

Integer a = 1;

自动拆箱

a = a+2;//直接运算

基本类型与字符串之间的转换

基本类型-->字符串类型

1. +“ ”
2. 包装类的静态方法toString;
3. String类的静态方法valueof();

字符串类型-->基本类型

1. 使用包装类的静态方法parseXXX；

1public class box {
2
3    public static void main(String[] args) {
4        int a = 1;
5        String str = a+" ";//使用加空字符的方法将基本类型转为字符串类型。
6
7        String str2 = Integer.toString(a);//包装类的静态方法toString;
8
9        String str3 = String.valueOf(a);//String类的静态方法valueof();
10
11        int i = Integer.parseInt(str);//使用包装类的静态方法parseXXX
12    }
13}