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 ...

随机推荐

UP9616移动电源快充案例
第一版的UP9616快充(地址在此 ),从选料到线路板的布局走线都还算不错,实现了当初定下的设计目标,但也有一点小小的遗憾,就是在输出滤波电容这里有点随便了,为了弥补这个遗憾,秉着工程师的" ...
关于js中this指向的总结
js中this指向问题一直是个坑,之前一直是懵懵懂懂的,大概知道一点,但一直不知道各种情况下指向有什么区别,今天亲自动手测试了下this的指向. 1.在对象中的this对象中的this指向我们创建的对 ...
HTML5存储方式
由于之前在参加面试或者笔试的过程中经常会被问到HTML5存储的内容,包括它们之间的区别.特征和应用范围,所以看到一篇介绍不错的文章,把里面的个人觉得适合我的内容按照自己的理解总结如下.方便以后忘记了进 ...
纯JS实现KeyboardNav(学习笔记)二
纯JS实现KeyboardNav(学习笔记)二这篇博客只是自己的学习笔记,供日后复习所用,没有经过精心排版,也没有按逻辑编写这篇主要是添加css,优化js编写逻辑和代码排版 GitHub项目源码 ...
java中如何使用接口继承（Extending Interfaces）
5.接口继承(Extending Interfaces)和通话talk的功能.而Moto888更为高级,除了照相和通话功能以外,还有mp3的功能.接口继承到底有什么意义呢?马克-to-win:1)通过 ...
微信支付之微信H5支付(坑,ajax不支持重定向跳转)
这里讲的是微信h5支付, 是微信以外的手机浏览器调用微信h5支付 h5支付: H5支付是指商户在微信客户端外的移动端网页展示商品或服务,用户在前述页面确认使用微信支付时,商户发起本服务呼起 ...
拼写检查-c++
[问题描述] 作为一个新的拼写检查程序开发团队的成员,您将编写一个模块,用已知的所有形式正确的词典来检查给定单词的正确性. 如果字典中没有这个词,那么可以用下列操作中的一个来替换正确的单 ...
由浅入深，从掌握Promise的基本使用到手写Promise
由浅入深,从掌握Promise的基本使用到手写Promise 前言在ES6之前,对于一些异步任务的处理始终没有很好的方案可以解决,处理异步的方案可谓是十分混乱,在业务需求下异步请求的套用,就形成了回 ...
script标签中defer和async的区别（稀土掘金学习）
如果没有defer或async属性,浏览器会立即加载并执行相应的脚本.它不会等待后续加载的文档元素,读取到就会开始加载和执行,这样就阻塞了后续文档的加载. 下图可以直观的看出三者之间的区别: 其中蓝色 ...
Java基础之浅谈泛型
简单的介绍了Java泛型类型的使用.上手容易,深入很难.

Java学习笔记-基础语法Ⅴ

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

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

随机推荐

热门专题