Java学习笔记-基础语法Ⅴ

学习一些Java常用的API

---

Math：包含执行基本数字运算的方法

如果没有构造方法，一般类的成员都是静态的，通过类名可以直接调用

Java中有两种random函数，Math.Random()函数能够返回带正号的double值，该值≥0且<1，注意这里是小于1不能取等号

Random函数中的Random，可以是无参构造，也可以是带参构造(种子)，且方法中的形参是上限

import java.util.Random;

public class demo2 {
    public static void main(String[] args) {
        Random ran1 = new Random(10);
        System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: ");
        for (int i = 0; i < 10; i++) {
            System.out.print(ran1.nextInt(10) + " ");
        }
        System.out.println();
        Random ran2 = new Random(10);
        System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: ");
        for (int i = 0; i < 10; i++) {
            System.out.print(ran2.nextInt(10) + " ");
        }
    }
}

使用种子为10的Random对象生成[0,10)内随机整数序列:
3 0 3 0 6 6 7 8 1 4
使用另一个种子为10的Random对象生成[0,10)内随机整数序列:
3 0 3 0 6 6 7 8 1 4

System中主要注意以下两个函数：

exit和currentTimeMills

public class demo1 {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis()*1.0/1000/3600/24/365);
        long start = System.currentTimeMillis();
        for(int i = 0;i<1000;i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("-----------");
        System.out.println("运行1000次输出需要的时间是："+(end-start)+"ms");
        System.exit(0);
        System.out.println(System.currentTimeMillis());
    }
}

Object类：是类层次结构的根，每个类都可以将Object作为超类，所有类都直接或间接继承该类

public String toString()

返回对象的字符串表示形式。总的来说，这 toString方法返回一个字符串，“以文本方式表示”这个对象。其结果应该是一个简洁，但翔实的代表性，是一个容易阅读的人。建议所有子类都重写此方法。

Object类的toString方法返回一个包含该类的对象是一个实例的名称字符串的符号` @ '，和符号进制表示的对象的哈希码。换句话说，此方法返回一个等于值的字符串：

getClass().getName() + '@' + Integer.toHexString(hashCode())

结果

对象的字符串表示形式。

public class Student {
    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    /*
        @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    */
}

public class Demo {
    public static void main(String[] args) {
        Student st = new Student(18,"林青霞");
        /*
        public void println(Object x) {
            String s = String.valueOf(x);
            if (getClass() == PrintStream.class) {
                // need to apply String.valueOf again since first invocation
                // might return null
                writeln(String.valueOf(s));
            } else {
                synchronized (this) {
                    print(s);
                    newLine();
                }
            }
        }
         */

        /*
        public static String valueOf(Object obj) {
            return (obj == null) ? "null" : obj.toString();
        }
         */

        /*
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
         */

        System.out.println(st);
        // Student@4eec7777
        // Student{age=18, name='林青霞'}
    }
}

在Student类中如果不重写toString方法，输出结果会比较难阅读，输出了Student@4eec7777，而如果重写了toString方法，则输出Student{age=18, name='林青霞'}

Object类中还有一个常用方法，是equals，之前在学习String的时候也学习了equals方法，当时理解的是==比较两者的地址值，而equals比较两者的值，但是Object中的equals却有些不同

// Student类见上
public class Demo3 {
    public static void main(String[] args) {
        Student st1 = new Student(20,"林青霞");
        Student st2 = new Student(20,"林青霞");
        /*
        public boolean equals(Object obj) {
            return (this == obj);
        }
         */
        System.out.println(st1.equals(st2));
    }
}

// false

这里明明用equals，但是却输出了false，是因为Object中的equals见上方注释，还是用==进行比较

在IDEA中重写toString方法和equals方法很简单，使用Alt+Insert，然后找到要添加的方法即可

getClass()返回对象的类的信息

冒泡排序：

public class demo1 {
    public static void main(String[] args) {
        int [] arr = {54,32,88,12,90,75,81};
        arrToString(arr);
        BubbleSort(arr);
        arrToString(arr);
    }
    public static void BubbleSort(int [] array){
        for(int i = 1;i<array.length-1;i++){
            for(int j = 0;j<array.length-i;j++){
                if(array[j]>array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }
    public static void arrToString(int [] array){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i = 0;i<array.length;i++){
            if(i==array.length){
                sb.append(array[i]);
            }else{
                sb.append(array[i]).append(", ");
            }
        }
        sb.append("]");
        String ss = sb.toString();
        System.out.println(ss);
    }
}

上述较复杂的过程，可用Arrays中的toString方法和sort方法实现

Arrays类包含用于操作数组的各种方法：

• toString返回指定数组的内容的字符串表示形式
• sort按照数字顺序排列指定的数组

// 使用Alt+Insert重写了equals方法，然后查看Arrays的equals方法使用
public class Student {
    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        Student st1 = new Student(18,"林青霞");
        Student st2 = new Student(18,"林青霞");
        Student st3 = new Student(19,"kkk");
        Student [] s1 = {st1};
        Student [] s2 = {st2};
        System.out.println(Arrays.equals(s1,s2));
    }
}
// 如果不重写equals，那么输出false
// 重写了equals，输出true

Arrays是一个工具类，设计思想为：

• 构造方法用private修饰(不让外界创建类)
• 成员用public static修饰(可以让外界直接调用静态方法)

基本数据类型包装类：

• 产生：基本数据类型使用不需要创建对象，但是集合的操作时需要将基本数据转化为对象
• 常用：Boolean、Character、Integer、Byte、Short、Long、Float、Double
• 再次强调，String不属于基本数据类型，是一个类，属于引用数据类型
• 提供：字符串、基本数据类型、对象之间相互转化的方式
• 属性：最大值、最小值
• 好处：将基本数据类型封装成对象的好处在于可以在对象中定义更多功能方法操作该数据(基本数据类型与字符串之间的转换)

public class IntegerDemo {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        Integer i1 = new Integer(100);
        System.out.println(i1);
        Integer i2 = Integer.valueOf(101);
        System.out.println(i2);
        // 报错
//        Integer i3 = Integer.valueOf("abc");
//        System.out.println(i3);
    }
}

Integer首先掌握构造方法，直接new Integer的方法已过时，现在一般用valueOf方法

把int、Integer和String转换好好研究一下，其他的用到再说

• int到Integer：使用Integer的静态函数valueOf
• String到Integer：使用Integer的静态函数valueOf
• Integer到int：调用intValue方法(非静态，不要搞错了)
• String到int：方法一使用Integer的静态方法ParseInt，方法二先使用Integer的静态方法valueOf，再调用intValue
• int到String：使用String的静态方法valueOf
• Integer到String：使用String的静态方法valueOf

public class IntegerDemo2 {
    public static void main(String[] args) {
        String s1 = "100";
        int n1 = 101;
        Integer it1 = Integer.valueOf(102);
        System.out.println("String:"+s1);
        System.out.println("int:"+n1);
        System.out.println("Integer:"+it1);

        // String转int
        int n2 = Integer.parseInt(s1);
        System.out.println("将String转int："+n2);
        // Integer转int
        int n3 = it1.intValue();
        System.out.println("将Integer转int"+n3);
        int n4 = Integer.valueOf(s1).intValue();
        System.out.println("将String先转Integer再转int"+n4);

        // int转Integer
        Integer it2 = Integer.valueOf(n1);
        System.out.println("将int转Integer"+it2);
        // String转Integer
        Integer it3 = Integer.valueOf(s1);
        System.out.println("将String转Integer"+it3);

        // int转String
        String s2 = String.valueOf(n1);
        System.out.println("将int转String："+s2);
        // Integer转String
        String s3 = String.valueOf(it1);
        System.out.println("将Integer转String："+s3);
    }
}

在练习将字符串转换成字符串数组再排序的过程中，又加深了一点数组的理解，记录下来

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        /*
        String[] s1 = s.split("");
        for(int i = 0;i<s1.length;i++){
            System.out.println(s1[i]);
        }
         */
        String[] s1 = s.split(" ");
        int [] intArr = new int[s1.length];
        for(int i = 0;i<intArr.length;i++){
            intArr[i] = Integer.parseInt(s1[i]);
        }
        Arrays.sort(intArr);
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i = 0;i<intArr.length;i++){
            if(i==intArr.length-1){
                sb.append(intArr[i]);
            }else{
                sb.append(intArr[i]).append(", ");
            }
        }
        sb.append("]");
        String string = sb.toString();
        System.out.println(string);
    }
}

public class RegDemo {
    public static void main(String[] args) {
        String s = "abc student  'ijk'   sklearn    pytorch";
        String[] strings = s.split("\\s+");
        for(int i=0;i<strings.length;i++){
            System.out.println(strings[i]);
        }
    }
}

/*
abc
student
'ijk'
sklearn
pytorch
*/

数组元素可以不是基本类型，可以是引用类型，并且数组一旦创建就不可改变(是的，本身内容是不可以改变，但是指向是可以改变的)

而且，除了基本类型数据可以创建数组，引用类型数据也可以

public class Student {
    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

}

public class Test {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5,6};
        arr[1] = 4;
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        Student st1 = new Student(18,"林青霞");
        Student st2 = new Student(10,"张曼玉");
        Student st3 = new Student();
        st3.setAge(40);
        st3.setName("王祖贤");
        Student [] st = {st1,st2};
        st[1] = st3;
        for(int i = 0;i<st.length;i++){
            System.out.println(st[i]);
        }
    }
}

也即原来的那块空间对应的内容不会变，但是指向了新的地址，对应新的内容

装箱：把基本数据类型转换为对应的包装类类型

拆箱：把包装类类型转换为对应的基本数据类型

public class Boxing_Demo {
    public static void main(String[] args) {
        // 自动装箱
        Integer i1 = 100;
        System.out.println(i1);
        // 自动拆箱再装箱
        i1 += 100;
        // i1 = i1.intValue()+200
         System.out.println(i1);
        // 如果是null，在调用intValue时则报错
        // NullPointerException
        Integer i2 = null;
        if(i2 != null){
            i2 += 100;
        }
    }
}

使用包装类型时，如果做操作，最好判断是否为null

推荐只要是对象，在使用前就必须进行判断是否为null

Date大多方法已过时，这里掌握两个主要方法，一个无参构造，展示当前时间，一个带参构造，传入参数时间，返回1970年1月1日0时0分0秒加上该时间后的时间

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        // Date的无参构造方法
        Date d1 = new Date();
        System.out.println(d1);
        // Date的带参构造方法
        Date d2 = new Date(1000);
        System.out.println(d2);
    }
}

Date常用方法为getTime和setTime方法，比较简单

SimpleDateFormat是格式和语言环境敏感的方法解析一个类的具体日期，重点学习日期格式化和解析

主要掌握年月日时分秒，无参构造和带参构造方法，以及格式化和解析

• 年：y
• 月：M
• 日：d
• 时：H
• 分：m
• 秒：s

无参构造：SimpleDateFormat() 使用默认格式

带参构造：SimpleDateFormat(String pattern) 使用给定格式

格式化和解析：使用format和parse方法

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        // 直接输出util包下的Date结果，不利于阅读
        Date d1 = new Date();
        System.out.println(d1);
        // 现在使用SimpleDateFormat方法
        // 无参构造方法
//        SimpleDateFormat sdf = new SimpleDateFormat();
        // 带参构造方法
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        // 使用format格式化得到字符串
        String format = sdf.format(d1);
        System.out.println(format);
        // 解析字符串生成时间
        String s = "2022-01-01 00:00:00";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = sdf2.parse(s);
        System.out.println(parse);
    }
}

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

public class DateUtils {
    public String dateToString(Date date,String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String format1 = sdf.format(date);
        return format1;
    }
    public Date stringToDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date parse = sdf.parse(s);
        return parse;
    }
}

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

public class Demo {
    public static void main(String[] args) throws ParseException {
        DateUtils du = new DateUtils();
        Date d1 = new Date(1000);
        String format = "yyyy年MM月dd日 HH:mm:ss";
        String s1 = du.dateToString(d1, format);
        System.out.println(s1);
        System.out.println("-------");
        String s2 = "2022年01月01日 12:12:12";
        Date date = du.stringToDate(s2, format);
        System.out.println(date);
    }
}

黑马视频中明确写了这是一个工具类，工具类该有的特点是：

• 构造方法私有，这样外界就无法创建该类的对象
• 成员方法静态，这样可以通过类直接调用

Calendar：抽象类，为特定瞬间和一套calendar fields如YEAR、MONTH、DAY_OF_MONTH，HOUR之间的转换提供了方法

Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化

import java.util.Calendar;

public class Calendar_demo {
    public static void main(String[] args) {
        // 获取当前日历对象
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);
        // Calendar是抽象类，设置了领域来获取年月日星期月份等
        // 但是这些也都是静态的
        System.out.println(instance.get(Calendar.DATE));
        System.out.println(instance.get(Calendar.YEAR));
        System.out.println(instance.get(Calendar.MONTH));
        System.out.println("----------");
        instance.add(Calendar.YEAR,1);
        instance.add(Calendar.MONTH,2);
        System.out.println(instance.get(Calendar.YEAR));
        System.out.println(instance.get(Calendar.MONTH));
        System.out.println("----------");
        instance.set(2022,1,1);
        System.out.println(instance.get(Calendar.MONTH));
    }
}

Calendar常用方法：get、set和add

要注意Calendar是抽象类，用getInstance实例化，再用get领域内容得到属性值

// Calendar的应用
import java.util.Calendar;
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        System.out.println("请输入年份：");
        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);
//        System.out.println(c.get(Calendar.MONTH));
//        System.out.println(c.get(Calendar.YEAR));
//        System.out.println(c.get(Calendar.DATE));
        c.add(Calendar.DATE,-1);
        int date = c.get(Calendar.DATE);
        System.out.println(year+"年的二月份有"+date+"天");
    }
}