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+"天");

    }

}

Java学习笔记-基础语法Ⅴ的更多相关文章

Java学习笔记-基础语法Ⅳ
多态:同一个对象,在不同时刻表现出来的不同形态例如: 猫 cat = new 猫(); 动物 animal = new 猫(); 这里的猫在不同时刻表现出来不同的形态,这就是多态多态的前提和体现: ...
Java学习笔记-基础语法
Java基础包含关键字,标识符,注释,常量和变量,运算符关键字关键字的定义和特点定义:被Java语言赋予了特殊含义的单词特点:关键字中所有字母都为小写 Java的关键字用于定义数据类型的关键 ...
Java学习笔记-基础语法Ⅹ-进程线程
学习快一个月了,现在学到了黑马Java教程的300集打印流的特点: 只负责输出数据,不负责读取数据有自己的特有方法字节打印流:PrintStream,使用指定的文件名创建新的打印流 import ...
Java学习笔记-基础语法Ⅷ-泛型、Map
泛型泛型本质上是参数化类型,也就是说所操作的数据类型被指定为一个参数,即将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型,这种参数类型可以用在类.方法和接口中,分别为泛型类.泛型方法 ...
JAVA 学习笔记 - 基础语法 2
---恢复内容开始--- 1.数组的申明和应用数据类型数组名称[] = null; //在堆栈中申明变量名称数组名称 = new 数据类型[10]; // ...
JAVA 学习笔记 - 基础语法1
1. 类的定义 public class 与 class的区别一个java文件只有一个public class, 而且类名必须与文件名一致. 一个java文件可以有多个class定义,javac ...
Java学习笔记-基础语法ⅩⅠ-UDP、TCP
网络编程三要素:IP地址.端口.协议 IP地址:使用ipconfig查看,如果装了VM的话,会有VMnet1.VMnet8和WLAN,net1不能从虚拟机到主机,net8不能从主机到虚拟机,net0 ...
Java学习笔记-基础语法Ⅸ-文件
File File是文件和路径名的抽象表示,File封装的并不是一个真正存在的文件,是一个路径名,可以存在也可以不存在常用方法: 创建文件:createNewFile() 创建目录:mkdir() ...
Java学习笔记-基础语法Ⅶ-集合
集合集合类特点:提供一种存储空间可变的存储模型,存储的数据容量可以随时发生改变这里需要回顾一下,因为数组和字符串一旦创建,就不可改变,需要区分一下 import java.util.ArrayLi ...

随机推荐

PowerDesigner生成MySQL脚本,表和字段进行转义
打开Power Designer数据库建模工具,软件基本信息如下如果PowerDesigner内置的(table_option)表物理操作没有,请看以下步骤打开 Edit Current DBMS ...
Zookeeper Watcher 机制 -- 数据变更通知 ?
Zookeeper 允许客户端向服务端的某个 Znode 注册一个 Watcher 监听,当服务端的一些指定事件触发了这个 Watcher,服务端会向指定客户端发送一个事件通知来实现分布式的通知功 ...
学习Docker（一）
一.docker介绍 docker是半虚拟化,比完全虚拟化性能高,可以使用物理机性能100% Docker 镜像(Images): 用于创建 Docker 容器的模板 Docker 容器(Contai ...
学习 Haproxy （六）
HAProxy HAProxy是免费高效可靠的高可用及负载均衡解决方案,该软件非常适合于处理高负载站点的七层数据请求,HAProxy的工作模式使其可以非常容易且安全地集成到我们现有的站点架构中.使 ...
Python - 字符串基础知识
数据库之“日期处理函数：date_add（）与 date_sub（）与 datediff（）与 timedifff（）与 date_format（）”
一.加减某个时间间隔:date_add()与 date_sub()函数 1. date_add() :加 select date_add('2019-12-12', interval 1 day) d ...
i2c总线编码
i2c总线编码发送启动信号S 在同步时钟线SCL 为高电平时,数据线出现的由高到低的下降沿. 启动信号子程序STA 1 /************************************** ...
【分享】WeX5的正确打开方式（6）——数据组件初探
本文是[WeX5的正确打开方式]系列的第6篇文章,简单介绍一下WeX5中数据组件的特性和结构形式. 数据组件的由来上一篇 WeX5绑定机制我们实现了一个简单的记账本应用,当时所有数据都用 JSON ...
关于sqlite数据库与sqlite studio
今天使用了AS自带的sqlite实现了连接数据库,但是不能同步,比较麻烦,然后使用sqlite studio去设法实现同步,但是依旧无法创建成功,明天会继续调试.
MongoDB从bson文件中恢复数据
首先需要到mangodb的安装目录的bin下面找到mongorestore.exe WIN10系统MongoDB安装目录bin文件夹下没有mongorestore.exe 先下载工具 https:/ ...

Java学习笔记-基础语法Ⅴ

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

Java学习笔记-基础语法Ⅴ的更多相关文章

随机推荐

热门专题