尚硅谷Java入门视频教程第九章——Java常用类

于 2022-05-15 20:42:08 发布
阅读量408 收藏 1
点赞数
分类专栏： # Java基础 文章标签： java java-ee intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yw_1121/article/details/124654059
版权

尚硅谷Java入门视频教程第九章——Java常用类

第9章：Java常用类

9.1 字符串相关的类

9.1.1 String基本特性

  • String:字符串，使用一对""引起来表示。

    1. String声明为final的，不可被继承
    2. String实现了Serializable接口：表示字符串是支持序列化的。
      实现了Comparable接口：表示String可以比较大小
    3. String内部定义了final char[] value用于存储字符串数据
    4. String:代表不可变的字符序列。简称：不可变性。
      体现：
      1. 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
      2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
      3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
    5. 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
    6. 字符串常量池中是不会存储相同内容（使用String类的equals()比较，返回true）的字符串的。
    public void test1(){
    String s1 = "abc";//字面量的定义方式
    String s2 = "abc";
    s1 = "hello";

    System.out.println(s1 == s2);//比较s1和s2的地址值//false

    System.out.println(s1);//hello
    System.out.println(s2);//abc

    System.out.println("*****************");

    String s3 = "abc";
    s3 += "def";
    System.out.println(s3);//abcdef
    System.out.println(s2);//abc

    System.out.println("*****************");

    String s4 = "abc";
    String s5 = s4.replace('a', 'm');
    System.out.println(s4);//abc
    System.out.println(s5);//mbc
}

  • String的实例化方式：
    方式一：通过字面量定义的方式
    方式二：通过new + 构造器的方式

    public void test2(){
    //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
    String s1 = "javaEE";
    String s2 = "javaEE";
    //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
    String s3 = new String("javaEE");
    String s4 = new String("javaEE");

    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3);//false
    System.out.println(s1 == s4);//false
    System.out.println(s3 == s4);//false

    System.out.println("***********************");
    Person p1 = new Person("Tom",12);
    Person p2 = new Person("Tom",12);

    System.out.println(p1.name.equals(p2.name));//true
    System.out.println(p1.name == p2.name);//true

    p1.name = "Jerry";
    System.out.println(p2.name);//Tom
}

    内存解析：在这里插入图片描述
    在这里插入图片描述

  • 练习：字符串的拼接

    @Test
public void test3(){
    String s1 = "javaEE";
    String s2 = "hadoop";

    String s3 = "javaEEhadoop";
    String s4 = "javaEE" + "hadoop";
    String s5 = s1 + "hadoop";
    String s6 = "javaEE" + s2;
    String s7 = s1 + s2;

    System.out.println(s3 == s4);//true
    System.out.println(s3 == s5);//false
    System.out.println(s3 == s6);//false
    System.out.println(s3 == s7);//false
    System.out.println(s5 == s6);//false
    System.out.println(s5 == s7);//false
    System.out.println(s6 == s7);//false

    String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
    System.out.println(s3 == s8);//true
}


@Test
public void test4(){
    String s1 = "javaEEhadoop";
    String s2 = "javaEE";
    String s3 = s2 + "hadoop";
    System.out.println(s1 == s3);//false

    final String s4 = "javaEE";//s4:常量
    String s5 = s4 + "hadoop";
    System.out.println(s1 == s5);//true

}

    结论：

    1. 常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量。
    2. 只要其中有一个是变量，结果就在堆中。
    3. 如果拼接的结果调用intern()方法，返回值就在常量池中

  • JVM中字符串常量池存放位置说明：

    • jdk 1.6（jdk 6.0，java 6.0）：字符串常量池存储在方法区（永久区）
    • jdk 1.7：字符串常量池存储在堆空间
    • jdk 1.8：字符串常量池存储在方法区（元空间）
  • 面试题：
    1. String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？
      两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”
    2. 判断执行结果：
      public class StringTest {

    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        System.out.println("1:" + str);
        System.out.println(System.identityHashCode(str));
        str = "test ok";
        System.out.println("2:" + str);
        System.out.println(System.identityHashCode(str));
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        System.out.println("3:" + ex.str);
        System.out.println(System.identityHashCode(ex.str));
        ex.change(ex.str, ex.ch);
        System.out.println("4:" + ex.str);
        System.out.println(System.identityHashCode(ex.str));
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}
      执行结果：
      执行结果
      方法参数为值传递机制，因此在执行change()时，将str与ch的地址传入方法新创造的两个变量。
      在对str与ch[0]进行修改时，str是字符串，具有不可变性，因此修改时会将新创建的str变量的值进行修改，但不会影响原str变量的值，指向新的字符串，函数执行完毕后新创建的str出栈，对原str无影响。但ch为数组，不具有不可变性，因此修改时会直接影响原数组。

9.1.2 String常用方法

  • 基本方法：

    • int length()：返回字符串的长度： return value.length
    • char charAt(int index)： 返回某索引处的字符return value[index]
    • boolean isEmpty()：判断是否是空字符串：return value.length == 0
    • String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
    • String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
    • String trim()：返回字符串的副本，忽略前导空白和尾部空白
    • boolean equals(Object obj)：比较字符串的内容是否相同
    • boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
    • String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
    • int compareTo(String anotherString)：比较两个字符串的大小
    • String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
    • String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
    @Test
public void test2() {
    String s1 = "HelloWorld";
    String s2 = "helloworld";
    System.out.println(s1.equals(s2));//false
    System.out.println(s1.equalsIgnoreCase(s2));//true

    String s3 = "abc";
    String s4 = s3.concat("def");
    System.out.println(s4);//abcdef

    String s5 = "abc";
    String s6 = new String("abe");
    System.out.println(s5.compareTo(s6));//涉及到字符串排序//-2

    String s7 = "北京尚硅谷教育";
    String s8 = s7.substring(2);
    System.out.println(s7);//北京尚硅谷教育
    System.out.println(s8);//尚硅谷教育

    String s9 = s7.substring(2, 5);
    System.out.println(s9);//尚硅谷(左闭右开：[2.5))
}

@Test
public void test1() {
    String s1 = "HelloWorld";
    System.out.println(s1.length());//10
    System.out.println(s1.charAt(0));//H
    System.out.println(s1.charAt(9));//d
//        System.out.println(s1.charAt(10));
//        s1 = "";
    System.out.println(s1.isEmpty());

    String s2 = s1.toLowerCase();
    System.out.println(s1);//s1不可变的，仍然为原来的字符串//HelloWorld
    System.out.println(s2);//改成小写以后的字符串//helloworld

    String s3 = "   he  llo   world   ";
    String s4 = s3.trim();
    System.out.println("-----" + s3 + "-----");//-----   he  llo   world   -----
    System.out.println("-----" + s4 + "-----");//-----he  llo   world-----
}

  • 索引相关方法：

    • boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
    • boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
    • boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
    • boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
    • int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
    • int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
    • int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
    • int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
      注：indexOf和lastIndexOf方法如果未找到都是返回-1
    @Test
public void test3(){
    String str1 = "hellowworld";
    boolean b1 = str1.endsWith("rld");
    System.out.println(b1);//t

    boolean b2 = str1.startsWith("He");
    System.out.println(b2);//f

    boolean b3 = str1.startsWith("ll",2);
    System.out.println(b3);//t

    String str2 = "wor";
    System.out.println(str1.contains(str2));//t

    System.out.println(str1.indexOf("lo"));//3
    System.out.println(str1.indexOf("lol"));//-1
    System.out.println(str1.indexOf("lo",5));//-1

    String str3 = "hellorworld";

    System.out.println(str3.lastIndexOf("or"));//7
    System.out.println(str3.lastIndexOf("or",6));//4

    //什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
    //情况一：存在唯一的一个str。情况二：不存在str
}

  • 替换：

    • String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
    • String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
    • String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
    • String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

  • 匹配:
    boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

  • 切片：

    • String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
    • String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
    @Test
public void test4(){
    String str1 = "北京尚硅谷教育北京";
    String str2 = str1.replace('北', '东');

    System.out.println(str1);//北京尚硅谷教育北京
    System.out.println(str2);//东京尚硅谷教育东京


    String str3 = str1.replace("北京", "上海");
    System.out.println(str3);//上海尚硅谷教育上海

    System.out.println("*************************");
    String str = "12hello34world5java7891mysql456";
    //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
    String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
    System.out.println(string);//hello,world,java,mysql

    System.out.println("*************************");
    str = "12345";
    //判断str字符串中是否全部有数字组成，即有1-n个数字组成
    boolean matches = str.matches("\\d+");
    System.out.println(matches);//t
    String tel = "0571-4534289";
    //判断这是否是一个杭州的固定电话
    boolean result = tel.matches("0571-\\d{7,8}");//t
    System.out.println(result);


    System.out.println("*************************");
    str = "hello|world|java";
    String[] strs = str.split("\\|");
    for (int i = 0; i < strs.length; i++) {
        System.out.println(strs[i]);//hello//world//java
    }
    System.out.println();
    str2 = "hello.world.java";
    String[] strs2 = str2.split("\\.");
    for (int i = 0; i < strs2.length; i++) {
        System.out.println(strs2[i]);//hello//world//java
    }

}

9.1.3 String类与其他结构之间的转换

  • String与基本数据类型、包装类之间的转换

    • String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
    • 基本数据类型、包装类 --> String：调用String重载的valueOf(xxx)
    public void test1(){
    String str1 = "123";
//        int num = (int)str1;//错误的
    int num = Integer.parseInt(str1);

    String str2 = String.valueOf(num);//"123"
    String str3 = num + "";

    System.out.println(str1 == str3);//f
}

  • String 与 char[]之间的转换

    • String --> char[]：调用String的toCharArray()
    • char[] --> String：调用String的构造器
    @Test
public void test2(){
    String str1 = "abc123";  //题目： a21cb3

    char[] charArray = str1.toCharArray();
    for (int i = 0; i < charArray.length; i++) {
        System.out.println(charArray[i]);
    }

    char[] arr = new char[]{'h','e','l','l','o'};
    String str2 = new String(arr);
    System.out.println(str2);
}

  • String 与 byte[]之间的转换

    • 编码：String --> byte[]:调用String的getBytes()
    • 解码：byte[] --> String:调用String的构造器
    • 编码与解码：
      编码：字符串 -->字节 (看得懂 —>看不懂的二进制数据)
      解码：编码的逆过程，字节 --> 字符串 （看不懂的二进制数据 —> 看得懂）
      说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
    import org.junit.Test;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

@Test
public void test3() throws UnsupportedEncodingException {
    String str1 = "abc123中国";
    byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
    System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]//一个汉字对应三位utf-8

    byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
    System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]//一个汉字对应两位utf-8

    System.out.println("******************");

    String str2 = new String(bytes);//使用默认的字符集，进行解码。
    System.out.println(str2);//abc123中国

    String str3 = new String(gbks);
    System.out.println(str3);//abc123�й�//出现乱码。原因：编码集和解码集不一致！

    String str4 = new String(gbks, "gbk");
    System.out.println(str4);//abc123中国//没有出现乱码。原因：编码集和解码集一致！
}

9.1.4 String常见算法题目

  1. 模拟一个trim方法，去除字符串两端的空格。

  2. 将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为”abfedcg”

  3. 获取一个字符串在另一个字符串中出现的次数。
    比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

  4. 获取两个字符串中最大相同子串。比如：str1 = “abcwerthelloyuiodef”; str2 = “cvhellobnm”
    提示：将短的那个串进行长度依次递减的子串与较长的串比较。

  5. 对字符串中字符进行自然顺序排序。
    提示：
    1）字符串变成字符数组。
    2）对数组排序，选择，冒泡，Arrays.sort();
    3）将排序后的数组变成字符串

9.1.5 String相关的类：StringBuffer与StringBuilder类

  • String、StringBuffer、StringBuilder三者的异同？

    • 相同点：
      底层使用char[]存储（jdk1.9之后改为byte[]）
    • 不同点：
      String：不可变的字符序列
      StringBuffer：可变的字符序列；线程安全的(方法均为synchronized的)，效率低
      StringBuilder：可变的字符序列；jdk5.0新增的，线程不安全的，效率高

  • 源码分析与内存解析：

    • String:

      String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

    • StringBuffer/StringBuilder

      StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
System.out.println(sb1.length());//0
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
      • 问题1. System.out.println(sb2.length());//3
      • 问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
        默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

    • 指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

    @Test
public void test1(){
    StringBuffer sb1 = new StringBuffer("abc");
    sb1.setCharAt(0,'m');
    System.out.println(sb1);//mbc

    StringBuffer sb2 = new StringBuffer();
    System.out.println(sb2.length());//0
}

  • String与StringBuffer、StringBuilder类之间的转换：
    String -> StringBuffer、StringBuilder：调用StringBuffer、StringBuilder的构造器
    StringBuffer、StringBuilder -> String：调用String的构造器；StringBuffer、StringBuilder的toString()

  • StringBuffer的常用方法：

    • StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接

    • StringBuffer delete(int start,int end)：删除指定位置的内容

    • StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str

    • StringBuffer insert(int offset, xxx)：在指定位置插入xxx

    • StringBuffer reverse() ：把当前字符序列逆转

    • public int indexOf(String str)

    • public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串//不改变原StringBuffer

    • public int length()

    • public char charAt(int n )

    • public void setCharAt(int n ,char ch):修改指定索引位置的字符

    • 总结：
      增：append(xxx)
      删：delete(int start,int end)
      改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
      查：charAt(int n )
      插：insert(int offset, xxx)
      长度：length();
      遍历：for() + charAt() / toString()

    @Test
public void test2(){
    StringBuffer s1 = new StringBuffer("abc");
    s1.append(1);
    s1.append('1');
    System.out.println(s1);//abc11
//        s1.delete(2,4);//左闭右开//ab1
//        s1.replace(2,4,"hello");//abhello1
//        s1.insert(2,false);//abfalsec11//length:10
//        s1.reverse();//11cba
    String s2 = s1.substring(1, 3);
    System.out.println(s1);//abc11
    System.out.println(s1.length());//5
    System.out.println(s2);//bc
}

  • 对比String、StringBuffer、StringBuilder三者的效率：
    从高到低排列：StringBuilder > StringBuffer > String

    @Test
public void test3(){
   //初始设置
   long startTime = 0L;
   long endTime = 0L;
   String text = "";
   StringBuffer buffer = new StringBuffer("");
   StringBuilder builder = new StringBuilder("");
   //开始对比
   startTime = System.currentTimeMillis();
   for (int i = 0; i < 20000; i++) {
       buffer.append(String.valueOf(i));
   }
   endTime = System.currentTimeMillis();
   System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

   startTime = System.currentTimeMillis();
   for (int i = 0; i < 20000; i++) {
       builder.append(String.valueOf(i));
   }
   endTime = System.currentTimeMillis();
   System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

   startTime = System.currentTimeMillis();
   for (int i = 0; i < 20000; i++) {
       text = text + i;
   }
   endTime = System.currentTimeMillis();
   System.out.println("String的执行时间：" + (endTime - startTime));
}

    执行结果：
    在这里插入图片描述

9.2 JDK8之前日期时间API

9.2.1 System类中获取时间戳的currentTimeMillis()

//1.System类中的currentTimeMillis()
@Test
public void test1(){
	long time = System.currentTimeMillis();
	//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
	//称为时间戳
	System.out.println(time);//1652098356726
}

9.2.2 Java中两个Date类:java.util.Date和子类java.sql.Date

java.util.Date类
           |---java.sql.Date类

  1. 两个构造器的使用
    构造器一：Date()：创建一个对应当前时间的Date对象
    构造器二：创建指定毫秒数的Date对象

  2. 两个方法的使用
    toString():显示当前的年、月、日、时、分、秒
    getTime():获取当前Date对象对应的毫秒数。（时间戳）

  3. java.sql.Date对应着数据库中的日期类型的变量
    如何实例化
    如何将java.util.Date对象转换为java.sql.Date对象

    public void test2(){
    //构造器一：Date()：创建一个对应当前时间的Date对象
    Date date1 = new Date();
    System.out.println(date1.toString());//Mon May 09 20:02:17 CST 2022

    System.out.println(date1.getTime());//1652097737367

    //构造器二：创建指定毫秒数的Date对象
    Date date2 = new Date(155030620410L);
    System.out.println(date2.toString());//Sat Nov 30 16:03:40 CST 1974

    //创建java.sql.Date对象
    java.sql.Date date3 = new java.sql.Date(35235325345L);
    System.out.println(date3);//1971-02-13

    //如何将java.util.Date对象转换为java.sql.Date对象
    //情况一：
//        Date date4 = new java.sql.Date(2343243242323L);
//        java.sql.Date date5 = (java.sql.Date) date4;
    //情况二：
    Date date6 = new Date();
    java.sql.Date date7 = new java.sql.Date(date6.getTime());

}

9.2.3 SimpleDateFormat类

  • SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析
    1. 两个操作：
      1.1 格式化：日期 —>字符串
      1.2 解析：格式化的逆过程，字符串 —> 日期
    2. SimpleDateFormat的实例化
      @Test
public void testSimpleDateFormat() throws ParseException {
    //实例化SimpleDateFormat:使用默认的构造器
    SimpleDateFormat sdf = new SimpleDateFormat();

    //格式化：日期 --->字符串
    Date date = new Date();
    System.out.println(date);

    String format = sdf.format(date);
    System.out.println(format);

    //解析：格式化的逆过程，字符串 ---> 日期
    String str = "19-12-18 上午11:43";
    Date date1 = sdf.parse(str);
    System.out.println(date1);

    //*************按照指定的方式格式化和解析：调用带参的构造器*****************
//        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    //格式化
    String format1 = sdf1.format(date);
    System.out.println(format1);//2019-02-18 11:48:27
    //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),
    //否则，抛异常
    Date date2 = sdf1.parse("2020-02-18 11:48:27");
    System.out.println(date2);
}
    3. 练习

      1. 字符串"2020-09-08"转换为java.sql.Date

        @Test
public void testExer() throws ParseException {
    String birth = "2020-09-08";

    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
    Date date = sdf1.parse(birth);
//        System.out.println(date);

    java.sql.Date birthDate = new java.sql.Date(date.getTime());
    System.out.println(birthDate);
}

      2. “三天打渔两天晒网” 1990-01-01 xxxx-xx-xx 打渔？晒网？
        举例：2020-09-08 ？

        总天数 % 5 == 1,2,3 : 打渔
        总天数 % 5 == 4,0 : 晒网

        总天数的计算？
        方式一：( date2.getTime() - date1.getTime()) / (1000 * 60 * 60 * 24) + 1
        方式二：1990-01-01 --> 2019-12-31 + 2020-01-01 -->2020-09-08

9.2.4 Calendar类

  • Calendar日历类(抽象类）的使用
    @Test
public void testCalendar(){
    //1.实例化
    //方式一：创建其子类（GregorianCalendar）的对象
    //方式二：调用其静态方法getInstance()
    Calendar calendar = Calendar.getInstance();
//        System.out.println(calendar.getClass());

    //2.常用方法
    //get()
    int days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);
    System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

    //set()
    //calendar可变性
    calendar.set(Calendar.DAY_OF_MONTH,22);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);

    //add()
    calendar.add(Calendar.DAY_OF_MONTH,-3);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);

    //getTime():日历类---> Date
    Date date = calendar.getTime();
    System.out.println(date);

    //setTime():Date ---> 日历类
    Date date1 = new Date();
    calendar.setTime(date1);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);
}

9.3 JDK8中新日期时间API

java8中新的日期时间API涉及的包：
在这里插入图片描述

9.3.1 LocalDate、LocalTime、LocalDateTime类的使用

说明：

  1. LocalDateTime相较于LocalDate、LocalTime，使用频率要高

  2. 类似于Calendar

    @Test
public void test1(){
    //now():获取当前的日期、时间、日期+时间
    LocalDate localDate = LocalDate.now();
    LocalTime localTime = LocalTime.now();
    LocalDateTime localDateTime = LocalDateTime.now();

    System.out.println(localDate);
    System.out.println(localTime);
    System.out.println(localDateTime);

    //of():设置指定的年、月、日、时、分、秒。没有偏移量
    LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
    System.out.println(localDateTime1);


    //getXxx()：获取相关的属性
    System.out.println(localDateTime.getDayOfMonth());
    System.out.println(localDateTime.getDayOfWeek());
    System.out.println(localDateTime.getMonth());
    System.out.println(localDateTime.getMonthValue());
    System.out.println(localDateTime.getMinute());

    //体现不可变性
    //withXxx():设置相关的属性
    LocalDate localDate1 = localDate.withDayOfMonth(22);
    System.out.println(localDate);
    System.out.println(localDate1);


    LocalDateTime localDateTime2 = localDateTime.withHour(4);
    System.out.println(localDateTime);
    System.out.println(localDateTime2);

    //不可变性
    LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
    System.out.println(localDateTime);
    System.out.println(localDateTime3);

    LocalDateTime localDateTime4 = localDateTime.minusDays(6);
    System.out.println(localDateTime);
    System.out.println(localDateTime4);
}

9.3.2 瞬时：Instant类的使用

  • 类似于 java.util.Date类
    @Test
public void test2(){
    //now():获取本初子午线对应的标准时间
    Instant instant = Instant.now();
    System.out.println(instant);//2019-02-18T07:29:41.719Z

    //添加时间的偏移量
    OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
    System.out.println(offsetDateTime);//2019-02-18T15:32:50.611+08:00

    //toEpochMilli():获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数  ---> Date类的getTime()
    long milli = instant.toEpochMilli();
    System.out.println(milli);

    //ofEpochMilli():通过给定的毫秒数，获取Instant实例  -->Date(long millis)
    Instant instant1 = Instant.ofEpochMilli(1550475314878L);
    System.out.println(instant1);
}

9.3.3 DateTimeFormatter类

  • DateTimeFormatter:格式化或解析日期、时间
    类似于SimpleDateFormat
    @Test
public void test3(){
//        方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
    DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    //格式化:日期-->字符串
    LocalDateTime localDateTime = LocalDateTime.now();
    String str1 = formatter.format(localDateTime);
    System.out.println(localDateTime);
    System.out.println(str1);//2019-02-18T15:42:18.797

    //解析：字符串 -->日期
    TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
    System.out.println(parse);

//        方式二：
//        本地化相关的格式。如：ofLocalizedDateTime()
//        FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
    DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
    //格式化
    String str2 = formatter1.format(localDateTime);
    System.out.println(str2);//2019年2月18日 下午03时47分16秒


//      本地化相关的格式。如：ofLocalizedDate()
//      FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
    DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
    //格式化
    String str3 = formatter2.format(LocalDate.now());
    System.out.println(str3);//2019-2-18


//       重点： 方式三：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
    DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
    //格式化
    String str4 = formatter3.format(LocalDateTime.now());
    System.out.println(str4);//2019-02-18 03:52:09

    //解析
    TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
    System.out.println(accessor);
}

9.3.4 其它API

  • ZoneId：该类中包含了所有的时区信息，一个时区的ID，如 Europe/Paris
  • ZonedDateTime：一个在ISO-8601日历系统时区的日期时间，如 2007-12-03T10:15:30+01:00 Europe/Paris。
    其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如：Asia/Shanghai等
  • Clock：使用时区提供对当前即时、日期和时间的访问的时钟。
  • 持续时间：Duration，用于计算两个“时间”间隔
  • 日期间隔：Period，用于计算两个“日期”间隔
  • TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。
  • TemporalAdjusters : 该类通过静态方法
    (firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用TemporalAdjuster 的实现。

9.4 Java比较器：Comparable接口与Comparator接口

  • 说明：Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的。
    但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
    如何实现？使用两个接口中的任何一个：Comparable 或 Comparator

  • Comparable接口的使用举例： 自然排序

    1. 像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。
    2. 像String、包装类重写compareTo()方法以后，进行了从小到大的排列
    3. 重写compareTo(obj)的规则：
      如果当前对象this大于形参对象obj，则返回正整数，
      如果当前对象this小于形参对象obj，则返回负整数，
      如果当前对象this等于形参对象obj，则返回零。
    4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。
      在compareTo(obj)方法中指明如何排序
    @Test
    public void test1(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        //
        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

    }

    @Test
    public void test2(){
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",43);

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));
    }

    package com.atguigu.java;

/**
 * 商品类
 * @author shkstart
 * @create 2019 下午 4:52
 */
public class Goods implements  Comparable{

    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

    //指明商品比较大小的方式:按照价格从低到高排序,再按照产品名称从高到低排序
    @Override
    public int compareTo(Object o) {
//        System.out.println("**************");
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            //方式一：
            if(this.price > goods.price){
                return 1;
            }else if(this.price < goods.price){
                return -1;
            }else{
//                return 0;
               return -this.name.compareTo(goods.name);
            }
            //方式二：
//           return Double.compare(this.price,goods.price);
        }
//        return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }
}

  • Comparator接口的使用：定制排序

    1. 背景：
      当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序
    2. 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
      如果方法返回正整数，则表示o1大于o2；
      如果返回0，表示相等；
      返回负整数，表示o1小于o2。
     @Test
    public void test3(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr,new Comparator(){

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof  String){
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
//                return 0;
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void test4(){
        Goods[] arr = new Goods[6];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("huaweiMouse",224);
        arr[5] = new Goods("microsoftMouse",43);

        Arrays.sort(arr, new Comparator() {
            //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Goods && o2 instanceof Goods){
                    Goods g1 = (Goods)o1;
                    Goods g2 = (Goods)o2;
                    if(g1.getName().equals(g2.getName())){
                        return -Double.compare(g1.getPrice(),g2.getPrice());
                    }else{
                        return g1.getName().compareTo(g2.getName());
                    }
                }
                throw new RuntimeException("输入的数据类型不一致");
            }
        });

        System.out.println(Arrays.toString(arr));
    }

  • Comparable接口与Comparator的使用的对比：

    • Comparable接口的方式一旦指定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
    • Comparator接口属于临时性的比较。

9.5 System类

  • System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
  • 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
  • 成员变量
    System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
  • 成员方法
    • native long currentTimeMillis()： 该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
    • void exit(int status)： 该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
    • void gc()： 该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
    • String getProperty(String key)： 该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：
      在这里插入图片描述

9.6 Math类

  • java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。
  • 常用功能
    • abs 绝对值
    • acos,asin,atan,cos,sin,tan 三角函数
    • sqrt 平方根
    • pow(double a,doble b) a的b次幂
    • log 自然对数
    • exp e为底指数
    • max(double a,double b)
    • min(double a,double b)
    • random() 返回0.0到1.0的随机数
    • long round(double a) double型数据a转换为long型（四舍五入）
    • toDegrees(double angrad) 弧度—>角度
    • toRadians(double angdeg) 角度—>弧度

9.7 BigInteger与BigDecimal类

  • BigInteger类

    • Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的，最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
    • java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。
      另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。
    • 构造器
      BigInteger(String val)：根据字符串构建BigInteger对象
    • 常用方法
      • public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。
      • BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
      • BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
      • BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
      • BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。
      • BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger。
      • BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。
      • BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

  • BigDecimal类

    • 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
    • BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
    • 构造器
      • public BigDecimal(double val)
      • public BigDecimal(String val)
    • 常用方法
      • public BigDecimal add(BigDecimal augend)
      • public BigDecimal subtract(BigDecimal subtrahend)
      • public BigDecimal multiply(BigDecimal multiplicand)
      • public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
荔枝小丸子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值