Java API

于 2021-05-27 00:29:49 发布
阅读量158 收藏
点赞数
文章标签： javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40634016/article/details/117309037
版权

文章目录

Java API

API（Application Programming Interface，应用程序接口）是一些预先定义的函数，或指软件系统不同组成部分衔接的约定。 目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问原码，或理解内部工作机制的细节。

一、Object 类

  • Object类是Java语言中所有类的根，所有的类都直接或间接的继承了Object类；
  • 数组也继承了Object类；
  • Object类中定义了equals方法public boolean equals Object，用来比较两个对象的虚地址，如果虚地址相同则返回true，否则返回false；

1.1 equals 方法

  • Object类中定义了equals方法public boolean equals( Object obj )，用来比较两个对象的虚地址，如果虚地址相同则返回true，否则返回false；
  • Object类中的equals方法的作用，与==相同，都是比较两个对象的虚地址；

很多类覆盖了equals方法，用来比较两个对象的属性值，如果属性值相同，则认为两个对象相等；例如，String类就覆盖了equlas方法，用来比较两个字符串的字符序列值

package com.singerw.objdet;

public class TestStudent {

	public static void main(String[] args) {

		Student s1 = new Student(1, "水文");
		Student s2 = new Student(1, "水文");

		System.out.println(s1 == s2);// 地址 false
		System.out.println(s1.equals(s2)); // 调用Object方法 结果依然是false

		// 程序业务有个需求，如果学号和姓名是相同的.我们就认为这两个学生是同一个学生.
		System.out.println(s1.equals(s2)); // true
	}
}

false
true
true

package com.singerw.objdet;

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

		// 字符串对象创建
		String str1 = new String("abc");
		String str2 = new String("abc");
		// 方法,从Object继承而来，但是重写了.依次比较两个字符串中字符的内容
		boolean flag = str1.equals(str2);

		System.out.println(flag);
		
		System.out.println(str1.hashCode());

	}

}

true
96354

如果需要使用equals比较对象的属性值等，可以进行覆盖；例如：

package com.singerw.objdet;

public class TestObject01 {

	public static void main(String[] args) {

		Obj obj1 = new Obj();

		Obj obj2 = new Obj();

		// == 引用类型来说比较的是地址,内存中存储区域是否相同
		System.out.println(obj1 == obj2);// ? false

		// 当且仅当x和y引用相同的对象（ x == y具有值 true）时，该方法返回true 。
		System.out.println(obj1.equals(obj2));// ? false

		Obj obj3 = obj2;// 将obj2赋值给Obj3 等价于obj3和obj2指向的地址一一样的

		System.out.println(obj2 == obj3);
		System.out.println(obj2.equals(obj3));

		System.out.println(obj1.hashCode());
		//obj2 obj3指向同一个对象
		System.out.println(obj2.hashCode());
		System.out.println(obj3.hashCode());
	}
}

class Obj extends Object {

}

false
false
true
true
460141958
1163157884
1163157884

equals 小练习：

public class Test {
    public static void main(String[] args) {
        String str = "ILoveJava";
        String str1 = "I";
        String str2 = "Love";
        String str3 = "Java";
        System.out.println(str == (str1 + str2 + str3));

        String str4 = "I" + "Love" + "Java";
        System.out.println(str == str4);

        String str5 = (str1 + str2 + str3).intern();
        String str6 = str5;
        System.out.println(str == str6);
    }
}

false
true
true

package com.singerw.stringdemo;

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Date d1 = new Date(100000L);
        Date d2 = new Date(100000L);
        System.out.println(d1.equals(d2));
    }
}

true

1.2 hashCode 方法

  • Object类中定义了hashCode方法public int hashCode() ，用来返回对象的哈希码；
  • 默认情况下【即没有重新hashCode方法时】，当两个引用的虚地址相同时，hashCode返回相同的值，否则返回不同的值；
  • 可以使用IDEA 和 Eclipse的工具重写equals和hashCode方法；

事实上，基于哈希的集合在使用hashCode的时候，基本都是和equals一起使用；

二、String类

  • String无法子类化，因为String类是一个final类。因为Sting是这样定义的：public final class String extends Object，里边有final关键字，所以不能被继承。
  • 字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，它们可以被共享。

什么时候用可变字符串？什么情况选择String?

答：频繁对字符串进行拼接，而我们业务要求知识得到最后拼接的那个结果而已。用StringBuffer或者StringBuilder

2.1 字符串特性

**不可变性：**不可变的意思是，一旦一个字符串被创建后，它的值就不能被修改。

  • 不变性，字符串一旦赋值，那么在内存中存储后，
  • 如果我们改变引用的值，原来存储的位置的值还是不变的。
  • 只是引用的指向改变了而已。
package com.singerw.stringdemo;

/**
 * 不变性，字符串一旦赋值，那么在内存中存储后，
 * 如果我们改变引用的值，原来存储的位置的值还是不变的。
 * 只是引用的指向改变了而已。
 */
public class TestString_03 {
    public static void main(String[] args) {
        String str = "abc";
        System.out.println(str);
        str += "xyz";
        System.out.println(str);
    }
}
  • 为了能够重用这些不变的字符串，Java使用了字符串常量池
  • 凡是用=直接赋值的方式得到的字符串，都存储在常量池中；相同的共用一个具体字符串；
  • 而使用new创建的字符串不适用常量池，每次都会分配新的存储空间
package com.singerw.stringdemo;

// java.lang包默认导入，无需手动导入
public class TestString_01 {
    public static void main(String[] args) {
        String str1 = new String();
        String str2 = new String("hello");
        String str3 = new String("hello");
        System.out.println(str2 == str3); // 地址
        System.out.println(str2.equals(str3)); // 底层原理：转换为字符数组，依次比较

        //存储位置在常量池中。
        String str4 = "java";
        String str5 = "java";
        System.out.println(str4 == str5);  // 地址
        // 底层原理：转换为字符数组，依次比较
        // 但是如果按照上字面值的方式来赋值，直接判断==的时候，str4与str5的地址是一样的。
        System.out.println(str4.equals(str5));

        String str6 = new String("java");
        System.out.println(str6 == str5);
        System.out.println(str6.equals(str5));
    }
}

2.2 常见方法API

  • charAt(int index) ：返回char指定索引处的值
  • index of：返回指定字符第一次出现的字符串内的索引
  • length() ：返回此字符串的长度
  • intern() ：返回字符串对象的规范表示
  • startsWith(String prefix, int toffset) ：
  • endsWith(String suffix) ：
  • split()：将此字符串分割为给定的匹配
  • substring(int beginIndex) ：
  • substring(int beginIndex, int endIndex) ：
  • replace：替换
  • trim() ：返回一个字符串，并删除任何前面和后面的空格
package com.singerw.stringdemo;

public class TestString_04 {
    public static void main(String[] args) {
        String str = new String("zhangsingerw@gmail.com");
        // 1.charAT
        char ch = str.charAt(0);
        System.out.println(ch);

        // 2.lenght方法，提前字符串长度
        int le = str.length();
        System.out.println(le);
        // 提取最后一个字符
        System.out.println(str.charAt(le - 1));

        // 3.index 有找到返回索引位置，没找到返回-1
        int index1 = str.indexOf("@");
        System.out.println("index:" + index1 + "位");

        // 4.startsWith endsWith
        boolean flag1 = str.startsWith("zhang");
        System.out.println(flag1);

        boolean flag2 = str.endsWith(".com");
        System.out.println(flag2);

        // 5.intern  返回字符串对象的规范表示
        String intern = str.intern();
        System.out.println(intern);

        // 6.split
        String str2 = "hello ,world ,l ,am ,java";
        String[] array = str2.split(",");
        System.out.println(array.length);
        for (String s : array) {
            System.out.println(s);
        }

        // 7.substring
        System.out.println(str2.substring(12));
        // 所有12-17，不包括17
        System.out.println(str2.substring(12, 17));

        // 8.replace 替换 --> 做过滤的
        String str3 = "singerw.com";
        System.out.println(str3.replace("singerw", "zhangsingerw"));

        // 9.trim 去首尾空格（如在用户输入用户名和密码时，需要去除空格）
        System.out.println(" j a v a ".trim().length());
    }
}

package com.singerw.Task;

public class Test {
    public static void main(String[] args) {
        String str = "string@sima.com";
        String[] arr = str.split("@");
        System.out.println(arr.length);
        // 替换，会在新的内存区域存储
        str.replace("@", "#");
        
        int index = str.indexOf("@");
        String username = str.substring(0, index);
        System.out.println(username);
    }
}

2.3 StringBuilder

  • 一个可变的字符序列。 此类提供与StringBuffer的API，但不保证同步。

​ 此类设计用作简易替换为StringBuffer在正在使用由单个线程字符串缓冲区的地方（如通常是这种情况）。 在可能的情况下，建议使用这个类别优先于StringBuffer ，因为它在大多数实现中将更快。

package com.singerw.stringdemo;

public class TestStringBuilder {
    public static void main(String[] args) {
        // 不能直接复制，new可变的字符串，常见方法append,在尾部添加新的字符串
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("abc");
        stringBuilder.append("xyz");
        System.out.println(stringBuilder);

        System.out.println(stringBuilder.capacity());
        System.out.println(stringBuilder.length());
        System.out.println(stringBuilder.reverse());  // 导致该字符序列被序列的相反代替。
    }
}

2.4 StringBuffer

  • 线程安全，可变的字符序列。 字符串缓冲区就像一个String ，但可以修改。
  • 字符串缓冲区可以安全地被多个线程使用。
  • StringBuffer线程同步 ==> 线程安全
  • 常见方法append，在尾部添加新的字符串
package com.singerw.stringdemo;

public class TestStringBuffer {

    public static void main(String[] args) {
        // 不能直接复制，new可变的字符串，常见方法append,在尾部添加新的字符串
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("abc");
        stringBuffer.append("xyz");
        System.out.println(stringBuffer);

        System.out.println(stringBuffer.capacity());
        System.out.println(stringBuffer.length());
        System.out.println(stringBuffer.reverse());
    }
}

三、包装类

2.1 包装类

Java语言中的8个包装器类型如下所示：

类型字节型短整型整型长整型单精度 浮点型双精度 浮点型字符型布尔型
基本数据类型byteshortintlongfloatdoublecharboolean
包装器类型ByteShortIntegerLongFloatDoubleCharacterBoolean

除了整型及字符型外，其他的包装器类型名字都是将基本数据类型首字母变大写即可；

以Integer类为例，可以把int类型转换成Integer引用类型；

		int a = 1;
        // Integer 大名
        // 可以通过引用名.属性和方法
        Integer i = 1;
		// 接下来就可以调用Integer类中的方法，例如：
        i.hashCode();

2.2 自动装箱与拆箱

  • 装箱：基本数据类型转换为包装器类型，称为装箱（boxing）；例如，int型转换为Integer类型；

  • 拆箱：包装器类型转换为基本数据类型，称为拆箱（unboxing）；例如Integer类型转换为int类型；

    JDK1.5以后，装箱拆箱可以自动进行；例如：

package com.singerw.box;

public class TestInt {
    public static void main(String[] args) {
        // opp语言-->万事万物皆对象
        // int 小名/昵称 ===> 简单的数学计算
        int a = 1;
        // Integer 大名
        // 可以通过引用名.属性和方法
        Integer i = 1;
        i.hashCode();

        // 字符串  ===> 转换为 int
        int n = Integer.parseInt("123");

        // 装箱
        int j = 1;
        Integer jj = j; // 基本类型可以直接赋值给包装类，这种操作叫 “装箱”
        // 拆箱
        Integer k = new Integer(1);
        int kk = k;  // Integer类型自动转换为-->int包装类型
    }
}

  • 在自动装箱拆箱过程中，Java使用到了常量池；（缓存）

  • 如前面所学习，常量池就是方法区的一部分，是内存的逻辑分区；

    如下代码所示,i1、i2使用到了自动装箱，i3和i4则没有使用：

package com.singerw.box;

public class TestPool {
    public static void main(String[] args) {
        // 池技术，直接复制存储在内存逻辑区  --》 方法区  --》 常量池
        Integer i1 = 20;
        Integer i2 = 20;
        // 所以我们说,i1和i2只想的数据地址是相同的。
        System.out.println("i1 == i2 " + (i1 == i2));
        
        // 而每次new操作，new对象是堆在存储的，地址一定不同。
        Integer i3 = new Integer(20);
        Integer i4 = new Integer(20);
        System.out.println("i3 == i4 " + (i3 == i4));
    }
}

i1 == i2 true
i3 == i4 false

Java程序中基本类型的变量可以直接在常量池中读取字面量。基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean。另外Byte,Short,Integer,Long,Character这5种整型的包装类只是在对应值小于等于127时才可使用常量池。

  • 原因：在自动装箱拆箱过程中，只有数值是byte范围内的时候，才使用到常量池，否则都是分配新的内存空间；
  • 1000早就超出了byte的范围，所以i3/i4是两个空间；
package com.singerw.box;

public class TestPool2 {
    public static void main(String[] args) {
        // 池技术，直接复制存储在内存逻辑区  --》 方法区  --》 常量池
        Integer i1 = 1000;
        Integer i2 = 1000;
        // 所以我们说,i1和i2只想的数据地址是相同的。
        System.out.println("i1 == i2 " + (i1 == i2));

        // 而每次new操作，new对象是堆在存储的，地址一定不同。
        Integer i3 = new Integer(1000);
        Integer i4 = new Integer(1000);
        System.out.println("i3 == i4 " + (i3 == i4));
    }
}

i1 == i2 false
i3 == i4 false

package com.singerw.box;

public class Task {
    public static void main(String[] args) {
        double i0 = 0.1;
        Double i1 = new Double(0.1);
        Double i2 = new Double(0.1);
        // equals 方法在Double中有做了重写，比较的double值是否相等。
        System.out.println(i1.equals(i2));
        System.out.println(i1.equals(i0));

        // new不同地址比较
        System.out.println(i1 == i2);
        // i1和直接复制比较   包装类型 、简单类型
        // 直接理解为拆箱，二者比较值是否相等。
        System.out.println(i2 == i0); 
        
    }
}

true
true

false
true

四、Math 类

  • Math.PI
  • Math.E
  • Math.abs
  • Math.random // 随机数（0-1）
  • Math.ceil // 向上取整
  • Math.floor // 向下取整
  • Math.max // 返回结果最大值
  • Math.min // 返回结果最小值
  • Math.pow

五、random类

4.1 random类的使用

  • java.util包中的Random类可以用来生成不同类型的随机值，功能更为强大；
  • Random类创建对象两种方式：
方法声明方法描述
Random()创建Random对象，该对象每次生成的随机数不同
Random(long seed)使用一个种子参数创建Random对象，参数相同的Random对象，每次生成的随机数相同。

java.util包中的Random类有多个生成随机数的相关方法：

方法声明方法描述
int nextInt()生成int类型随机数，数值范围不定；
int nextInt(int n)生成int类型随机数，数值范围[0,n)；
long nextLong()生成long类型随机数
float nextFloat()生成float类型随机数，数值范围[0,1.0)；
double nextDouble()生成double类型随机数，数值范围[0,1.0)；
boolean nextBoolean()生成boolean类型随机数；
void setSeed(long seed)修改Random对象的种子值
  • Random类有两个构造方法，无参的构造方法创建对象后，每次都生成不同的随机数；有参的构造方法创建对象后，如果种子参数值一样，那么每次生成的随机数也相同；
  • Random类功能强大，能生成int,float,double,boolean各种类型的随机数；
  • nextInt生成不定范围的int随机数，而带参数的nextInt生成的随机数有范围；

4.2 小练习

使用JavaAPI相关随机数方法 ， 实现双色球模拟开奖:

  • 双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。
  • 红色球号码从1–33中选择；
  • 蓝色球号码从1–16中选择。
  • 注需要选择6个红色球号码，1个蓝色球号码。
package com.singerw.Task;

/**
 * @ClassName: TwoColorBall
 * @Description: TODO(使用JavaAPI相关随机数方法 ， 实现双色球模拟开奖)
 * @Author 张欣
 * @Date 2021-05-24 20:09
 */
public class TwoColorBall {
    /**
     * 双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。
     * 红色球号码从1--33中选择；
     * 蓝色球号码从1--16中选择。
     * 注需要选择6个红色球号码，1个蓝色球号码。
     *
     * @param args
     */
    public static void main(String[] args) {
        // 定义长度为7的数组
        int[] array = new int[7];

        // 生成红色球
        int n = 0;
        while (true) {
            // 设置标志是否有重复
            boolean flag = true;
            int red = (int) Math.floor(Math.random() * 33 + 1);
            // 判断生成的随机数是否存在相等的
            for (int j = 0; j < array.length; j++) {
                if (array[j] == red) {
                    flag = false;
                    break;
                }
            }
            // 如不不重复，就写进数组
            if (flag) {
                array[n] = red;
                n++;
            }
            // 数组长度为6退出
            if (n > 5) {
                break;
            }
        }

        // 生成蓝色球
        double blue = Math.round(Math.floor(Math.random() * 16 + 1));
        array[6] = (int) blue;

        // 遍历数组输出
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

六、UUID类

  • 全称（Universally Unique Identifier），是唯一的机器生成的标识符
  • UUID不是人工生成的，这样风险太高
  • UUID是16字节128位长的数字，通常以36字节的字符串表示，示例：16c42997-2941-4173-8f3d-b85909f3e664
package com.singerw.box;

import java.util.UUID;

public class TestUUID {
    public static void main(String[] args) {
        // UUID.randomUUID()方法
        UUID uuid = UUID.randomUUID();
        System.out.println(uuid);
    }
}

七、时间日期

  • Date :import java.util.Date;
  • Calendar : import java.util.Date;

​ JDK1.8版本中，对时间和日期相关的API进行了较大改动，将日期和时间分开用不同类型表示，每种类中都有相似的方法；主要的三个类有LocalDate、LocalTime、LocalDateTime；

6.1 Date

package com.singerw.box;

import java.util.Date;

public class TestData {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
    }
}

Mon May 24 15:49:59 CST 2021

6.2 Calendar

package com.singerw.box;

import java.util.Calendar;

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

java.util.GregorianCalendar[time=1621843928239,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=“Asia/Shanghai”,offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=4,WEEK_OF_YEAR=22,WEEK_OF_MONTH=5,DAY_OF_MONTH=24,DAY_OF_YEAR=144,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=12,SECOND=8,MILLISECOND=239,ZONE_OFFSET=28800000,DST_OFFSET=0]

6.3 小练习

1、用户在控制台输入一个年和月份，使用Date/Calendar实现打印这个月月历。

package com.singerw.Task;

import java.util.Calendar;
import java.util.Scanner;

/**
 * @ClassName: DateCalendarTask
 * @Description: 用户在控制台输入一个年和月份，使用Date/Calendar实现打印这个月月历
 * @Author 张欣
 * @Date 2021-05-24 16:00
 */
public class DateCalendarTask {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入要查询的年份：");
        int years = input.nextInt();
        System.out.print("请输入要查询的月份：");
        int month = input.nextInt();

        // 获取当月天数
        Calendar c = Calendar.getInstance();
        c.set(years, month, 1);
        // //回退一天
        c.add(Calendar.DATE, -1);
        //获得当月天数
        int dayCount = c.get(Calendar.DAY_OF_MONTH);

        //打印1号前的空格
        c.set(Calendar.DATE, 1);
        //获得1号星期几
        int weekDay = c.get(Calendar.DAY_OF_WEEK);
        String[] weeks = {"日", "一", "二", "三", "四", "五", "六"};
        for (int i = 0; i < weeks.length; i++) {
            System.out.print(weeks[i] + "\t");
        }
        System.out.println();
        for (int i = 1; i < weekDay; i++) {
            System.out.print("\t");
        }
        for (int i = 1; i <= dayCount; i++) {
            //输出一个日期，日期往后走一天。
            c.set(Calendar.DAY_OF_MONTH, i);
            System.out.print(i + "\t");
            //打印完周六换行
            if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY)
            {
                System.out.println();
            }
        }
    }
}

6.4 时间转换

  • SimpleDateFormat格式化时间
  • SimpleDateFormat中定义了对时间进行格式化的方法；该类继承了抽象父类DateFormat，某些方法在父类中定义，可以自定义一个模式字符串来构建SimpleDateFormat对象：

可以自定义一个模式字符串来构建SimpleDateFormat对象：

方法声明方法描述
SimpleDateFormat(String pattern)使用模式字符串创建对象；
SimpleDateFormat(String pattern, Locale locale)使用模式字符串和区域信息创建对象；

通常使用format方法进行格式化；

方法声明方法描述
String format(Date date)把date进行格式化；

使用SimpleDateFormat格式化时间代码演示：

package com.singerw.datedemo;

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

public class TestFormat {
    public static void main(String[] args) throws ParseException {
        // 时间格式：yyyy-MM-dd HH-mm-ss 年-月-日 时:分:秒
        SimpleDateFormat simple = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // String --> date
        String str = "2021-05-35 10:17:45";
        // 转换
        Date datestr = simple.parse(str);
        System.out.println(datestr);

        // date --> String
        Date now = new Date();
        System.out.println(now);
        // 参数转换，参数为Date类型，返回值为String
        String formatdate = simple.format(now);
        System.out.println(formatdate);
    }
}

6.5 LocalDate

JDK8中定义了java.time.LocalDate，用来表示日期，默认格式是yyyy-MM-dd；该类不包含时间信息；

常用的获得LocalDate对象的方式如下：

方法声明方法描述
static LocalDate now()使用当前日期生成LocalDate对象；
static LocalDate of(int year, int month, int dayOfMonth)使用年月日数值生成LocalDate对象；

LocalDate类中部分方法如下：

方法声明方法描述
int getYear()返回年字段值；
int getMonthValue()返回月字段值；
int getDayOfMonth()返回天字段值
static LocalDate parse(CharSequence text)将字符串转换成LocalDate对象；
package com.singerw.datedemo;

import java.time.LocalDate;

public class TestLocalDate {
    public static void main(String[] args) {
        //1用当前日期生成LocalDate
        LocalDate localDate1 = LocalDate.now();
        System.out.println(localDate1);

        //2使用指定数字生成LocalDate
        LocalDate localDate2 = LocalDate.of(2021, 05, 14);
        System.out.println(localDate2);
        //返回各字段值
        System.out.println("年：" + localDate2.getYear() + " 月：" + localDate2.getMonthValue() + " 日：" + localDate2.getDayOfMonth());

        // 3参数可以是一个字符串
        //将字符串转换
        LocalDate localDate3 = LocalDate.parse("2021-06-23");
        System.out.println(localDate3);
    }
}

6.6 LocalTime

LocalDate类只表示日期，JDK8中定义了新类LocalTime用来表示时间，用法与LocalDate类似；：

package com.singerw.datedemo;

import java.time.LocalTime;

public class TestLocalTime {
    public static void main(String[] args) {
        // 1用当前日期生成LocalTime
        LocalTime localTime1 = LocalTime.now();
        System.out.println(localTime1);

        //2使用指定数字生成LocalTime
        LocalTime localTime2 = LocalTime.of(23, 51, 23);
        System.out.println(localTime2);
        //返回各字段值
        System.out.println("时：" + localTime2.getHour() + " 分：" + localTime2.getMinute() + " 秒：" + localTime2.getSecond());


        // 3参数可以是一个字符串
        // 将字符串转换
        LocalTime localTime3 = LocalTime.parse("11:43:23");
        System.out.println(localTime3);
    }
}

6.7 LocalDateTime

JDK8中还定义了一个LocalDateTime类，同时包含日期与时间，用法与LocalDate及LocalTime类似；：

package com.singerw.datedemo;

import java.time.LocalDateTime;

public class TestLocalDateTime {
    public static void main(String[] args) {
        //1用当前日期生成LocalDateTime
        LocalDateTime localDateTime1 = LocalDateTime.now();
        System.out.println("datetime1:" + localDateTime1);

        //2使用指定数字生成LocalDateTime
        LocalDateTime localDateTime2 = LocalDateTime.of(2021, 05, 14, 15, 45, 45);
        System.out.println("datetime2:" + localDateTime2);
        //返回各字段值
        System.out.println("时：" + localDateTime2.getHour() + " 分：" + localDateTime2.getMinute() + " 秒：" + localDateTime2.getSecond());

        // 3参数可以是一个字符串
        //将字符串转换
        LocalDateTime localDateTime3 = LocalDateTime.parse("2009-12-12T12:34:09");
        System.out.println("datetime3:" + localDateTime3);
    }
}

6.8 时间格式转换

  • LocalDate、LocalTime、LocalDateTime类都可以使用DateTimeFormatter对象进行格式化；
  • LocalDate、LocalTime、LocalDateTime类都定义了parse方法，可以使用DateTimeFormatter对象把字符串按照指定的格式转换成时间日期类型对象；
package com.singerw.datedemo;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class TestDateTimeFormatter {

    public static void main(String[] args) {
        LocalTime time = LocalTime.now();
        System.out.println(time);

        LocalDate ldate = LocalDate.now();
        System.out.println(ldate);

        System.out.println("********LocalDate LocalTime LocalDateTime ==> String*******************");
        DateTimeFormatter format1 = DateTimeFormatter.ofPattern("yyyy/MM/dd");
        System.out.println(ldate.format(format1));
        
        DateTimeFormatter format2 = DateTimeFormatter.ofPattern("HH:mm:ss");
        System.out.println(time.format(format2));

        System.out.println("******** String ==> LocalDate LocalTime LocalDateTime *****************");

        String str2 = "15点25分";
        DateTimeFormatter time1Formater = DateTimeFormatter.ofPattern("HH点mm分");
        LocalTime time2 = LocalTime.parse(str2, time1Formater);
        System.out.println("time2:" + time2);

        String str3 = "2020年11月11日";
        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        LocalDate date2 = LocalDate.parse(str3, dateFormatter);
        System.out.println("date2:" + date2);
    }
}

八、System

package com.singerw.system;

import java.util.Scanner;

public class TestSystem {
    public static void main(String[] args) {
        // 输出
        System.err.println("abc");
        System.out.println("abc");
        // 输入
        Scanner input = new Scanner(System.in);
        
        // 常见的方法
        // 1 运行垃圾回收器
        System.gc();
        // 2 当前实际毫秒值(当前时间 举例1970-1-1的差值)
        System.out.println(System.currentTimeMillis());
        // 3 退出 终止虚拟机,通常用来结束程序
        System.exit(0);
        System.out.println("over");
    }
}

九、正则表达式

  • 正则表达式（regular expression）就是用来描述字符串逻辑规则的工具；

9.1 Java中的正则表达式基本语法

正则表达式由“元字符”组成，掌握了元字符的含义，就可以开始编写正则表达式；

1、常用元字符：

元字符含义
x字符 x
\\反斜线字符
\0n带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh带有十六进制值 0x 的字符 hh
\uhhhh带有十六进制值 0x 的字符 hhhh
\t新行（换行）符 (’\u000A’)
\r回车符 (’\u000D’)
\f换页符 (’\u000C’)
\a报警 (bell) 符 (’\u0007’)
元字符含义
\e转义符 (’\u001B’)
\cx对应于 x 的控制符
[abc]a、b 或 c（简单类）
[^abc]任何字符，除了 a、b 或 c（否定）
[a-zA-Z]a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]a 到 d 或 m 到 p，等同于：[a-dm-p]（并集）
[a-z&&[def]]d、e 或 f（交集）
[a-z&&[^bc]]a 到 z，除了 b 和 c，等同于c：[ad-z]（减去）
[a-z&&[^m-p]]a 到 z，而非 m 到 p，等同于：[a-lq-z]（减去）
.任何字符（与行结束符可能匹配也可能不匹配）
\d数字，等同于：[0-9]
\D非数字，等同于： [^0-9]
\s空白字符，等同于：[ \t\n\x0B\f\r]
元字符含义
\S非空白字符，等同于：[^\s]
\w单词字符，等同于：[a-zA-Z_0-9]
\W非单词字符，等同于：[^\w]
^行的开头
$行的结尾
\b单词边界
\B非单词边界
\A输入的开头
\G上一个匹配的结尾
\Z输入的结尾，仅用于最后的结束符（如果有的话）
\z输入的结尾
  • 正则表达式中往往需要对一些字符出现的次数进行规定，则需要量词；
  • 量词有不同的策略，Java中有三种策略，此处列出的是Greedy策略；

常用量词：

元字符含义
X?X，一次或一次也没有
X*X，零次或多次
X+X，一次或多次
X{n}X，恰好 n 次
X{n,}X，至少 n 次
X{n,m}X，至少 n 次，但是不超过 m 次
package com.singerw.reg;

import java.util.Scanner;
import java.util.regex.Pattern;

/**
 * 用户输入一个字符串，判断是否符合手机号码的规则
 * 用户输入一个字符串，判断是否符合身份证的规则
 * @Author 张欣
 * @Date 2021-05-26 10:39
 */
public class TestReg {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个手机号:");
        String iphoneNumber = input.next();
        System.out.println("请输入一个身份证号码：");
        String idcade = input.next();

        boolean matches1 = Pattern.matches("\\d{3}-\\d{8}|\\d{4}-\\{7,8}", iphoneNumber);
        boolean matches2 = Pattern.matches("^(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9]|X)$", idcade);

        System.out.println(iphoneNumber + matches1);
        System.out.println(idcade + matches2);
    }
}

十、Class 类

Class类的类表示正在运行的Java应用程序中的类和接口。

Isingerw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
下载Java API文档
weixin_44538361的博客
08-03 1970
下载Java api文档
javaAPI文档中文版（JDK11在线版）无需下载、直接打开
热门推荐
记录学习的历程
12-27 7万+
强烈推荐！巨好用！菜鸟教程javaAPI中文版：https://www.runoob.com/manual/jdk11api/index.html
java API 1.8
09-19
最新java API，1.8版本，包含java库中的的各种函数的解释与使用，是一款不可多得的工具。java api是一款使用Java编程的使用说明书，里面提供了大量的程序开发分类说明，并提供API函数开发的集体编程方式，可以帮助...
Java API文档.docx
06-25
Java API文档是Java开发者不可或缺的参考资料，它详细记录了Java编程语言的标准库，包括类、接口、方法和属性等核心元素。这些文档不仅提供技术规格，还包含使用示例，帮助程序员理解和应用Java的各类功能。 1. **...
JAVAAPI文档
09-13
Java API文档是Java开发者不可或缺的参考资料，它详细记录了Java Development Kit (JDK) 中所有类、接口、方法和常量的信息。这份文档是官方提供的，确保了信息的准确性和完整性，为程序员提供了关于如何使用Java...
javaAPI工具.zip
09-08
Java API工具是Java开发者日常工作中不可或缺的一部分，它包含了Java平台标准版（Java SE）的所有公共类、..."javaAPI查看工具"，如"jdk-9-汉化版.CHM"，为开发者提供了方便快捷的查询途径，是学习和工作的得力助手。
JAVA API官方文档 中文版
04-21
Java API（应用程序接口）是Java编程语言的核心组成部分，它提供了大量的类库，使得开发者能够构建出功能丰富的应用程序。这份“JAVA API官方文档 中文版”是对于Java开发者的宝贵资源，帮助他们理解和使用Java平台...
yolo-fastest.zip
07-28
yolo-fastest
mysql安装配置教程.pdf
最新发布
07-28
MySQL的安装配置教程可以细分为以下几个步骤，这里以Windows系统为例进行说明： 一、下载MySQL 1.访问MySQL官网： 1.前往MySQL的官方网站（https://www.mysql.com/）下载MySQL Community Server。 2.选择下载版本： 1.在官网的Downloads页面，选择“MySQL Community (GPL) Downloads”下的“MySQL Installer for Windows”。 2.跳过注册步骤，直接下载MySQL安装包。 二、安装MySQL 1.运行安装包： 1.找到下载好的MySQL安装包文件，双击运行。 2.选择安装类型： 1.在安装向导中，选择安装类型（通常建议选择“Custom”进行自定义安装）。 2.选择操作系统的位数（如64位），并勾选“Enable the Select Features...”等选项（如果提示缺少运行库，需要先安装相应的VC_redist）。 3.设置安装路径： 1.选择MySQL的安装路径和数据存储路径，建议将MySQL安装在非系统盘（如D盘）以避免潜在的问题。 4.设置密码：
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip
07-28
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip CCF大数据与计算智能大赛-非结构化商业文本信息中隐私信息识别方案 bert base + flat + crf + fgm + swa + pu learning策略 + clue数据集 = test1单模0.906 词向量：https://github.com/Embedding/Chinese-Word-Vectors SGNS(Mixed-large 综合) loss mask相关代码为pu learning策略的实现 主要模块版本 python 3.6.9 torch 1.1.0 transformers 3.0.2 pytorchcrf 1.2.0 torchcontrib 0.0.2 主要功能点 使用BERT base作为基础模型 采用flat结构进行命名实体识别 使用CRF层进行序列标注 采用对抗训练(FGM)和平滑权重平均(SWA)策略提高模型泛化能力 使用PU learning策略处理标注不全的数据 利用clue数据集进行训练
（verilog）基于MIPS指令集的单周期CPU设计
07-28
相关代码及Vivado项目工程文件
基于优化随机森林的对地攻击无人机自主作战效能评估_邵明军 - 副本.pdf
07-28
基于优化随机森林的对地攻击无人机自主作战效能评估_邵明军 - 副本
餐饮咖啡西餐厅饮品创业计划书运营策划书.doc
07-28
商业计划书，创业计划书，项目计划书，计划书模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
1_软错误失效对CANFD Transceiver芯片的影响分析.docx
07-28
1_软错误失效对CANFD Transceiver芯片的影响分析.docx
tour-project【程序员VIP专用】.zip
07-28
【项目简介】 HTML5+CSS实现雪花旅行社
复制文件子目录文件名称WIDOWS.BAT
07-28
复制文件到子目录下WIDOWS.BAT
Elasticsearch 1.4 Java API 教程
"Elasticsearch 1.4 Java API文档提供了关于如何使用Java与Elasticsearch 1.4版本进行交互的详细指南。这个API涵盖了从基础操作到高级特性的全面内容，包括 Maven 仓库信息、客户端使用、索引、获取、删除、批量操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Isingerw

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值