Java常用类

最新推荐文章于 2024-10-10 16:05:39 发布
最新推荐文章于 2024-10-10 16:05:39 发布
阅读量1k 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouwenxing666/article/details/130860526
版权
文章详细介绍了Java中的封装类，如Integer，以及String、StringBuilder和StringBuffer的使用，包括自动装箱/拆箱机制。此外，还讨论了Date类及其与时间日期相关的操作，以及DateFormat和Calendar类在格式化和解析日期时的作用。最后提到了Math和Random类以及枚举类型的使用。
摘要由CSDN通过智能技术生成

常用类

主要内容

  • 封装类
  • String类
  • StringBuffer和StringBuilder类
  • Date类和DateFormat类
  • Calendar类
  • Math类和Random类
  • 枚举

学习目标

知识点要求
引入封装类理解
封装类的使用掌握
自动装箱和自动拆箱掌握
阅读封装类源码理解
String的常用方法掌握
阅读String类源码理解
理解String的==和equals掌握
StringBuilder的使用掌握
理解StringBuilder的原理理解
Date类掌握
DateFormat类掌握
Calendar类了解
Math类了解
JDK8的日期类了解
Random类了解

一. 封装类

1. 封装类引入

1.1 什么是封装类

Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但我们在实际应用中经常需要将基本数据转化成对象，以便于操作。

为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为封装类(Wrapper Class)。

8种基本数据类型，分别对应一个封装类。封装类均位于java.lang包

基本数据类型封装类
byteByte
booleanBoolean
shortShort
charCharacter
intInteger
longLong
floatFloat
doubleDouble

八个类名中，除了Integer和Character类以外，其它六个类的类名和基本数据类型一致，只是类名的第一个字母大写而已

八个类中，除了Character和Boolean以外，其他的都是“数字型“，“数字型”都是java.lang.Number的子类。

public class TestWrapper1 {
  int num;
  Integer in ;
  public static void main(String[] args) {
    //封装类的功能
    System.out.println(Integer.SIZE); 
    System.out.println(Integer.MIN_VALUE);
    System.out.println(Integer.MAX_VALUE);     
    System.out.println(Integer.toBinaryString(123));//2进制输出 
    System.out.println(Integer.toOctalString(123));//8进制输出
    System.out.println(Integer.toHexString(123)); //16进制输出
   
    //其他特别重要的功能：可以实现字符串和基本数据类型之间的转换
    String str = "123"; //----123
    int num2 = Integer.parseInt(str);
    System.out.println(num2);
    String str2 = "123.45";
    double d = Double.parseDouble(str2);
    System.out.println(d);
  }
}

注意:

​ 1. 封装类的对象需要占用栈内存和堆内存，而基本数据类型的（局部）变量只占用栈内存；基本数据类型的变量占用空间少，更简单，更灵活，更高效。

​ 2. 作为成员变量，默认值不同。int 0；Integer null。

1.2 封装类的优点

  1. 某些方法的参数必须是对象，为了让基本数据类型的数据能作为参数，提供封装类。

  2. 封装类还可以提供更多的功能

  3. 其他特别重要的功能：比如可以实现字符串和基本数据类型之间的转换

2. 封装类的使用

2.1 自动装箱和自动拆箱

自动装箱和拆箱就是将基本数据类型和封装类之间进行自动的互相转换。JDK1.5后，Java引入了自动装箱(autoboxing)/拆箱(unboxing)。

自动装箱：基本类型的数据处于需要对象的环境中时，会自动转为“对象”, 没有必要显式调用valueOf()方法。

自动拆箱：每当需要一个值时，对象会自动转成基本数据类型，没必要显式调用intValue()、doubleValue()等转型方法。

如:

​ int i = 5; Integer j = i; 该过程就是自动装箱。

​ Integer i = 5; int j = i; 该过程就是自动拆箱。

我们可以用一句话总结自动装箱/拆箱：

​ 自动装箱过程是通过调用封装类valueOf()方法实现的，而自动拆箱过程是通过调用封装类 xxxValue()方法实现的（xxx代表对应的基本数据类型，如intValue()、doubleValue()等）。

public static void main(String[] args) {
  //1.自动装箱
  Integer i = 10;
  Integer i1 = Integer.valueOf(10);
  //2.自动拆箱
  Integer j = 10;
  int j1 = j;
  int j2 = j.intValue();
  //2.==  equals
  Integer in3 = new Integer(56);   Integer in4 = new Integer(56);
  System.out.println(in3==in4); //false，比较二者引用地址，那肯定不等
  System.out.println(in3.equals(in4));//true,比较二者值是否相等，相等
  Integer in5 = 25;       
  Integer in6 = 25;
  System.out.println(in5 ==in6);//true  在-128~127之间，直接获取指定值
  System.out.println(in5.equals(in6));//true
  Integer in7 = 256;        
  Integer in8 = 256;
  System.out.println(in7 ==in8);//false 不在-128~127之间，通过new Integer()创建对象
  System.out.println(in7.equals(in8));//true
}
2.2理解Integer源码

重点原码:

public final class Integer extends Number implements Comparable<Integer> {
  public static final int   MIN_VALUE = 0x80000000;
  public static final int   MAX_VALUE = 0x7fffffff;
  private final int value;
  public Integer(int value) {
    this.value = value;
  }
  public int intValue() {
    return value;
  }
  public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
      return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
  }
}

​ Integer类提供了一个静态内部类IntegerCache，对于定义一个静态数组cache，长度为256，赋值为-128—127。对于自动装箱时如果是-128—127范围内的数据，直接获取数组的指定值；对于这个范围之外的数据，通过new Integer()重新创建对象。这么做的目的是提高效率。

private static class IntegerCache {
  static final int low = -128;
  static final int high;
  static final Integer cache[];

  static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
      VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
      try {
        int i = parseInt(integerCacheHighPropValue);
        i = Math.max(i, 127);
        // Maximum array size is Integer.MAX_VALUE
        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
      } catch( NumberFormatException nfe) {
        // If the property cannot be parsed into an int, ignore it.
      }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
      cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
  }
  private IntegerCache() {}
}

注意:

​ 1. JDK1.5以后，增加了自动装箱与拆箱功能，如：Integer i = 100; int j = new Integer(100);

​ 2. 自动装箱调用的是valueOf()方法，而不是new Integer()方法。

​ 3. 自动拆箱调用的xxxValue()方法。

​ 4. 封装类在自动装箱时为了提高效率，对于-128~127之间的值会进行缓存处理。超过范围后，对象之间不能再使用==进行数值的比较，而是使用equals方法。

二. 字符串相关类

String类、StringBuilder类、StringBuffer类是三个字符串相关类。String类代表不可变的字符序列，StringBuilder类和StringBuffer类代表可变字符序列。关于这三个类详细的用法，在笔试面试以及实际开发中经常用到，我们必须掌握好它们。

String与StringBuffer可以理解为常量和变量

String对象调用改变自身的方法，本身内容不会发送改变，重新赋值其实是两个对象。

StringBuffer对象调用改变自身的方法，自身内容会改变

1. String类的使用

String类的使用1

public class StringLearning {

    public static void main(String[] args) {
        //1.创建String对象
        String str1 = "雅马哈Ll16";
        String str2 = new String("雅马哈Ll16");

        System.out.println(str1 == str2);   //引用不等
        System.out.println(str1.equals(str2));  //值相等

        //2.操作String对象
        //2.1常用方法
        System.out.println(str1.length());  //输出str1的长度，一个中文字的长度也算1
        System.out.println(str2.length());  //输出str1的长度，一个中文字的长度也算1

        System.out.println(str1.toString()); //输出str1
        System.out.println(str2.toString());

        System.out.println(str1.startsWith("tj"));//判断str1是不是以tj开头
        System.out.println(str2.startsWith("tj"));
        System.out.println(str1.endsWith("16"));//判断str1是不是以16结尾
        System.out.println(str2.endsWith("16"));

        System.out.println(str1.toUpperCase()); //str1中的小写字母转成大写字母
        System.out.println(str2.toUpperCase());

        System.out.println(str1.toLowerCase()); //str1中的大写字母转成小写字母
        System.out.println(str2.toLowerCase());

        System.out.println(str1); //经历了上次转大小写，str1的值并没有改变
        System.out.println(str2);

        //2.2根据索引得到子串
        System.out.println(str1.charAt(1)); //输出下标位置为1的字符。下标从0开始
        System.out.println(str2.charAt(1)); //输出下标位置为1的字符。下标从0开始

        System.out.println(str1.substring(1,4));//输出下标[1,4)字符，马哈L
        System.out.println(str1.substring(4));//输出下标[4,最后]

        //2.3根据子串得到索引
        System.out.println(str1.indexOf("哈"));//输出"哈"的下标，2
        System.out.println(str1.indexOf("马哈L"));//从第一个字符开始查找，返回找到的第一个匹配的子串的索引
        System.out.println(str1.indexOf("马哈鬼"));//若不存在，则返回-1

        System.out.println(str1.lastIndexOf("16"));// 返回"16"在此字符串中最后一次出现处的索引
        System.out.println(str1.lastIndexOf("16",6));// 返回"16"在此字符串中最后一次出现处的索引，从指定的索引下标6开始反向搜索。

        //2.4其他
        byte[] b1 = str1.getBytes(); //将字符串转成byte数组
        System.out.println(b1.length);//3*3 + 4*1 = 13，汉字占3byte，字母数字均占1byte
        System.out.println(Arrays.toString(b1));

        String str3 = new String(b1,9,3);  //将byte数组转为字符串。第二个参数offset抵消了前面三个汉字 3*3=9，长度3
        System.out.println(str1);
        System.out.println(str3); //Ll1

        boolean flag = str1.contains("马哈"); //判断str1中是否包含"马哈"
        System.out.println(flag);

        str1 = str1.concat("航天五院").concat("天津基地").concat("高新7路");//在原str1加上“航天五院天津基地高新7路”
        System.out.println(str1);

        str1 = str1.replace("航天五院","中国空间技术研究院"); //把str1中“航天五院”更换成“中国空间技术研究院”
        System.out.println(str1);

        String str4 = "  tj bh  ";
        System.out.println(str4.length());
        System.out.println(str4.trim());//返回字符串的副本，忽略前导空白(空格)和尾部空白(空格)。
        
        String str5 = "abcdf";
        String str6 = "abcde";
        System.out.println(str5.compareTo(str6));//返回正数1，表示str5 > str6,数值1表示f比e大1；同理若返回负数表示str2 > str1
    }
}

String类的使用2

public class TestString2 {
  public static void main(String[] args) {
    String str1 = "bjsxt";
    String str2 = "bjsxt";
    System.out.println(str1 == str2); //!!!true !!!!!!
    System.out.println(str1.equals(str2));//true

    String str3 = new String("bjsxt");
    String str4 = new String("bjsxt");
    System.out.println(str3 == str4); //false
    System.out.println(str3.equals(str4));//true

    String str5 = "";
    String str6 = null;
    System.out.println(str5.isEmpty());//true
    //System.out.println(str6.isEmpty());//NullPointerException
  }
}

toString()方法介绍

对象.toString() : 以字符串输出对象中的内容

toString()方法是 Object 类中的方法，toString() 方法源代码如下：

//(1)getClass().getName() 返回类的全类名(包名+类名)
//(2)Integer.toHexString(hashCode())将对象的hashCode值转成16进制字符串
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

Object类中的toString方法输出的结果是：

包名.类名+@+16进制的哈希值

改写toString()方法
由于 Object 类中的 toString() 方法并不好用，因此很多其他类中都重写了此方法。（子类对父类提供的方法不满意，所以重写以符合自己的需求）

由于toString改写的太多，已经有了固定的格式，直接generate的toString方法源代码：

该改写的toString方法目的是输出对象的属性值。
当直接输出一个对象时，toString方法会被默认的调用。
public String toString() { //重写后，默认一般是把对象的属性值输出
return “Monster{” +
“name='” + name + ‘’’ +
“, job='” + job + ‘’’ +
“, sal=” + sal +
‘}’;}
下面是例子：

package object;

public class ToString {
	public static void main(String[] args) {
    Monster monster = new Monster("小妖怪", "巡山", 1000);
    System.out.println(monster.toString());
    System.out.println(monster);
	}
}

class Monster{
    private String name;
    private String job;
    private double sal;
    public Monster(String name, String job, double sal) {
    this.name = name;
    this.job = job;
    this.sal = sal;
}
 
//重写toString方法，输出对象的属性
@Override
public String toString() {   //重写后，默认一般是把对象的属性值输出
    return "Monster{" +
            "name='" + name + '\'' +
            ", job='" + job + '\'' +
            ", sal=" + sal +
            '}';
	}
}

输入结果如下：

Monster{name=‘小妖怪’, job=‘巡山’, sal=1000.0}

Monster{name=‘小妖怪’, job=‘巡山’, sal=1000.0}

小结：toString() 方法的作用，就像是介绍一下对象（像 monster 的属性都被说了一遍），一般子类对父类提供的 toString 都不满意，都要进行重写。

方法摘要

charcharAt(int index) 返回指定索引处的 char 值。
intcompareTo(String anotherString) 按字典顺序比较两个字符串。并返回二者差值，若为正数，则前者大于后者，反之同理
Stringconcat(String str) 将指定字符串连接到此字符串的结尾。
booleancontains(CharSequence s) 当字符串包含指定的 char 值序列时，返回 true。
booleanendsWith(String suffix) 测试此字符串是否以指定的后缀结束。
booleanequals(Object anObject) 将此字符串与指定的对象比较。
booleanequalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
inthashCode() 返回此字符串的哈希码。
intindexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
int[indexOf](#indexOf(int, int))(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
intindexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
int[indexOf](#indexOf(java.lang.String, int))(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
booleanisEmpty() 当且仅当 length() 为 0 时返回 true。
intlastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
int[lastIndexOf](#lastIndexOf(int, int))(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定索引处开始进行反向搜索。
intlastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
int[lastIndexOf](#lastIndexOf(java.lang.String, int))(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
intlength() 返回此字符串的长度。
String[replace](#replace(char, char))(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String[replace](#replace(java.lang.CharSequence, java.lang.CharSequence))(CharSequence target, CharSequence replacement) 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String[replaceAll](#replaceAll(java.lang.String, java.lang.String))(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String[]split(String regex) 根据给定正则表达式的匹配拆分此字符串。
booleanstartsWith(String prefix) 测试此字符串是否以指定的前缀开始。
boolean[startsWith](#startsWith(java.lang.String, int))(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
Stringsubstring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
String[substring](#substring(int, int))(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
StringtoLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
StringtoString() 返回此对象本身（它已经是一个字符串！）。
StringtoUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
Stringtrim() 返回字符串的副本，忽略前导空白和尾部空白。

2. 理解String类源码

String类是一个final类，意味着该类不能再有子类。

String类底层是一个字节数组value。各种方法的操作其实都是对该数组的操作。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
  private final byte[] value;
  public String() {
    this.value = "".value;
    this.coder = "".coder;
  }
  public String(String original) {
    this.value = original.value;
    this.coder = original.coder;
    this.hash = original.hash;
  }
  public int length() {
    return value.length >> coder();
  }
  public boolean isEmpty() {
    return value.length == 0;
  }
  public char charAt(int index) {
    if (isLatin1()) {
      return StringLatin1.charAt(value, index);
    } else {
      return StringUTF16.charAt(value, index);
    }
  }
  public String toString() {
    return this;
  }
}

String类的equals()方法其实就是比较底层的字符数组的各个元素是否相同，只要发现一个字符不相同，就返回false。如果所有字符都相同，返回true。但是如果两个变量指向了同一个字符数组，直接返回true。

public boolean equals(Object anObject) {
  if (this == anObject) {
    return true;
  }
  if (anObject instanceof String) {
    String aString = (String)anObject;
    if (coder() == aString.coder()) {
      return isLatin1() ? StringLatin1.equals(value, aString.value)
        : StringUTF16.equals(value, aString.value);
    }
  }
  return false;
}

String类的concat()是创建一个新的字符数组，存放原来字符数组和新加入的字符数组内容，然后以该新数组创建一个新的字符串。

public String concat(String str) {
  if (str.isEmpty()) {
    return this;
  }
  if (coder() == str.coder()) {
    byte[] val = this.value;
    byte[] oval = str.value;
    int len = val.length + oval.length;
    byte[] buf = Arrays.copyOf(val, len);
    System.arraycopy(oval, 0, buf, val.length, oval.length);
    return new String(buf, coder);
  }
  int len = length();
  int olen = str.length();
  byte[] buf = StringUTF16.newBytesFor(len + olen);
  getBytes(buf, 0, UTF16);
  str.getBytes(buf, len, UTF16);
  return new String(buf, UTF16);
}

3. StringBuffer，StringBuilder类的使用

StringBuffer和StringBuilder非常类似，均代表可变的字符序列。这两个类都是抽象类AbstractStringBuilder的子类，方法与String几乎一模一样。

两个类的主要区别：

​ 1. StringBuffer JDK1.0提供的类，线程安全，做线程同步检查，效率较低。

​ 2. StringBuilder JDK1.5提供的类，线程不安全，不做线程同步检查，因此效率较高。 建议采用该类。

public class TestStringBuilder {
  public static void main(String[] args) {
    //String----StringBuilder
    //StringBuilder builder = new StringBuilder("123");
    StringBuffer builder = new StringBuffer("123");
    builder.append("321");//在末尾追加子串
    builder.append("abc");
    builder.append("xyz");
    String str =builder.toString();
    System.out.println(str);
  }
}

注意:

​ 实际开发中StringBuilder的使用场合：字符串的拼接

StringBufferappend(boolean b) 将 boolean 参数的字符串表示形式追加到序列。
intcapacity() 返回当前容量。
charcharAt(int index) 返回此序列中指定索引处的 char 值。
StringBuffer[delete](#delete(int, int))(int start, int end) 移除此序列的子字符串中的字符。
StringBufferdeleteCharAt(int index) 移除此序列指定位置上的 char。
voidensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
intindexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
int[indexOf](#indexOf(java.lang.String, int))(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
StringBuffer[insert](#insert(int, boolean))(int offset, boolean b) 将 boolean 参数的字符串表示形式插入此序列中。
intlastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
int[lastIndexOf](#lastIndexOf(java.lang.String, int))(String str, int fromIndex) 返回最后一次出现的指定子字符串在此字符串中的索引。
intlength() 返回长度（字符数）。
StringBuffer[replace](#replace(int, int, java.lang.String))(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。
StringBufferreverse() 将此字符序列用其反转形式取代。
Stringsubstring(int start) 返回一个新的 String，它包含此字符序列当前所包含字符的子序列。
String[substring](#substring(int, int))(int start, int end) 返回一个新的 String，它包含此序列当前所包含字符的子序列。
StringtoString() 返回此序列中数据的字符串表示形式。

注意:

  1. String：不可变字符序列。

  2. StringBuffer：可变字符序列，并且线程安全，但是效率低。

  3. StringBuilder：可变字符序列，线程不安全，但是效率高(推荐使用)。

三. 日期类

“时间如流水，一去不复返”，时间是一个一维的东西。所以，我们需要一把刻度尺来表达和度量时间。在计算机世界，我们把1970 年 1 月 1 日 00:00:00定为基准时间，每个度量单位是毫秒(1秒的千分之一)

如图所示:

我们用long类型的变量来表示时间，从基准时间往前几亿年，往后几亿年都能表示。如果想获得现在时刻的“时刻数值”，可以使用：

long now = System.currentTimeMillis();

这个“时刻数值”是所有时间类的核心值，年月日都是根据这个“数值”计算出来的。

我们工作学习涉及的时间相关类有如下这些：

1. Date类

在标准Java类库中包含一个Date类。它的对象表示一个特定的瞬间，精确到毫秒。在网上商城下单时，在对报销单进行审核时，都需要获取当前的时间，通过Date类就可以完成。

1.1 Date类的使用
public static void main(String[] args) {
  //获取当前的时间
  Date now = new Date();
  //输出当前的时间
  System.out.println(now.toString());
  System.out.println(now.toLocaleString());
  System.out.println(now.getYear()); // 1900+122=2022
  System.out.println(now.getMonth());//  0---11
  System.out.println(now.getDate());//日
  //星期几 星期日是0，一周是从星期日开始
  System.out.println(now.getDay());
  System.out.println(now.getHours());
  System.out.println(now.getMinutes());
  System.out.println(now.getSeconds());
  
  //其他的方法
  long l = now.getTime();
  // 1970年1月1日 00:00:00 GMT以来的毫秒数。
  System.out.println(l);
  System.out.println(System.currentTimeMillis());

  //java.sql.Date
  java.sql.Date date = new java.sql.Date(System.currentTimeMillis());
  System.out.println(date);
  java.sql.Date date1 = java.sql.Date.valueOf("2022-1-1");
  System.out.println(date1);

  //java.sql.Date 转化为 java.util.Date
  java.sql.Date date2 = new java.sql.Date(System.currentTimeMillis());
  Date date3 = new Date(date2.getTime());
  //java.util.Date 转化为 java.sql.Date
  java.sql.Date date4 = new java.sql.Date(date3.getTime());
}

查看API文档大家可以看到其实Date类中的很多方法都已经过时了。JDK1.1之前的Date包含了：日期操作、字符串转化成时间对象等操作。JDK1.1之后，日期操作一般使用Calendar类，而字符串的转化使用DateFormat类。

1.2 理解Date类的源码
public class Date
    implements java.io.Serializable, Cloneable, Comparable<Date>{
  //表示相应时间对应的毫秒数
  private transient long fastTime;
  public Date() {
    this(System.currentTimeMillis());
  }
  public Date(long date) {
    fastTime = date;
  }
  public long getTime() {
    return getTimeImpl();
  }

  private final long getTimeImpl() {
    if (cdate != null && !cdate.isNormalized()) {
      normalize();
    }
    return fastTime;
  }
}

2. DateFormat类

DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现。主要作用就是把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。

需求1：网页注册，需要输入日期，在网页上输入的所有内容，xiaoming,23, 1999-12-23,1999/12/23，但是传送到后台接收到都是字符串 “xiaoming”, “23”, “1999-12-23”,“1999/12/23”，需要把字符串----->日期

需求2：注册成功后，在网页上显示日期，可以不同格式来显示"1999-12-23", “1999/12/23”，“1999年12月23日”，需要把日期----->字符串。

2.1 DateFormat类的使用
public class DateFormatLearning {
    
    public static void main(String[] args) {
        String str1 = "1999-12-23 09:23:45";
        Date date = null;

        try {
            //把String类型转成Date类型
            date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(str1);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        System.out.println(date.toString());
        System.out.println(date.toLocaleString());
        System.out.println(new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒").format(date));
    }
}

3. 日期和时间的表示

字母日期或时间元素表示示例
GEra 标志符TextAD
y年Year1996; 96
M年中的月份MonthJuly; Jul; 07
w年中的周数Number27
W月份中的周数Number2
D年中的天数Number189
d月份中的天数Number10
F月份中的星期Number2
E星期中的天数TextTuesday; Tue
aAm/pm 标记TextPM
H一天中的小时数（0-23）Number0
k一天中的小时数（1-24）Number24
Kam/pm 中的小时数（0-11）Number0
ham/pm 中的小时数（1-12）Number12
m小时中的分钟数Number30
s分钟中的秒数Number55
S毫秒数Number978
z时区General time zonePacific Standard Time; PST; GMT-08:00
Z时区RFC 822 time zone-0800

4. Calendar类

Calendar 类是一个抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。

public static void main(String[] args) {
  //创建Calendar对象
  Calendar cal = new GregorianCalendar();
  //输出日期中的各个部分
  System.out.println(cal.get(Calendar.YEAR));
  System.out.println(cal.get(Calendar.MONTH));
  System.out.println(cal.get(Calendar.DATE));
  System.out.println(cal.get(Calendar.HOUR));
  System.out.println(cal.get(Calendar.MINUTE));
  System.out.println(cal.get(Calendar.SECOND));
  System.out.println(cal.get(Calendar.DAY_OF_WEEK));//一周中的第几天
  //一个月中最大的天数
  System.out.println(cal.getActualMaximum(Calendar.DATE));
  //修改日期中各个部分
  cal.set(Calendar.YEAR,2000);
  cal.set(Calendar.MONTH,1);
  cal.set(Calendar.DATE,1); 
  //Date--Calendar之间的转换
  //Date ---->Calendar
  Date now = new Date();
  cal.setTime(now);
  //Calendar---->Date
  Date now2 = cal.getTime();
}
3.4.1 使用Calendar类实现万年历的功能
public static void main(String[] args) throws ParseException {
  Scanner sc = new Scanner(System.in);
  //1.提示语句
  System.out.println("请输入日期, 格式为 2020-10-10");
  
   //2.接收用户输入的日期(字符串)
  String next = sc.next();
  
  //3.将字符串日期转换为Date类型  SimpleDateFormat
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  Date date = sdf.parse(next); //Date类型
  // System.out.println(date);
  
  //4.操作日期 -> 日历类Calendar
  GregorianCalendar calendar = new GregorianCalendar();
  //将date类型的日期设置到calendar中
  calendar.setTime(date);
  
  //5.展示用户输入的月份和日期
  int month = calendar.get(Calendar.MONTH) + 1;
  int day = calendar.get(Calendar.DATE);
  System.out.println(month + "月 " + day + "日");
  
  //6.计算出用户输入的月份一共有多少天
  int maxDay = calendar.getActualMaximum(Calendar.DATE);
  
  //7.存储用户输入的日(目的: 将用户输入的日红色标注)
  int oldDay = calendar.get(Calendar.DATE);
  
  //8.将日历对象中的日期设置为1号(目的: 方便 换行等操作)
  calendar.set(Calendar.DATE, 1);
  
  //9.展示星期
  System.out.println("日\t一\t二\t三\t四\t五\t六");
  
  //10.获取1号为一周的第几天
  int i1 = calendar.get(Calendar.DAY_OF_WEEK);
  for (int i = 1; i < i1; i++) {
    System.out.print("\t");
  }
  
  //11.遍历展示所有的日
  for (int i = 0; i < maxDay; i++) {
    if (oldDay == calendar.get(Calendar.DATE)) {
      System.out.print(calendar.get(Calendar.DATE) + "!\t");
    } else {
      System.out.print(calendar.get(Calendar.DATE) + "\t");
    }
    //判断当前的日期是否为周六, 如果为周六换行
    if (calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
      System.out.println();
    }
    //日 +1
    calendar.add(Calendar.DATE, 1);
  }
}

四. 其他常用类

1. Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。如果需要更加强大的数学运算能力，计算高等数学中的相关内容，可以使用apache commons下面的Math类库。

public static void main(String[] args) {
  System.out.println(Math.PI);
  System.out.println(Math.round(3.14));//四舍五入去掉小数点
  System.out.println(Math.ceil(3.14));//向上取整，变成4.0
  System.out.println(Math.floor(3.14));//向下取整，变成3.0

  System.out.println(Math.sqrt(64));//开平方 得8.0
  System.out.println(Math.pow(2,5));//幂 2^5 = 32

  System.out.println(Math.abs(-5));//绝对值
  System.out.println(Math.max(30,40));//最大值
  System.out.println(Math.min(30,40));//最小值

  System.out.println(Math.random());//[0.0,1.0)
}

2. Random类

Math类中虽然为我们提供了产生随机数的方法Math.random()，但是通常我们需要的随机数范围并不是[0, 1)之间的double类型的数据，这就需要对其进行一些复杂的运算。如果使用Math.random()计算过于复杂的话，我们可以使用例外一种方式得到随机数，即Random类，这个类是专门用来生成随机数的，并且Math.random()底层调用的就是Random的nextDouble()方法。

使用Random生成[10,40)之间的随机正数

public static void main(String[] args) {
  //Random rand = new Random(10000);
  Random rand = new Random();
  System.out.println(rand.nextInt());
  System.out.println(rand.nextInt(10)); 
  System.out.println(rand.nextDouble());
  System.out.println(rand.nextFloat());
  for (int i = 0; i < 10; i++) {
    System.out.print(rand.nextInt(10)+"  ");
  }
}

构造方法摘要

Random()创建一个新的随机数生成器。
Random(long seed)使用单个 long 种子创建一个新的随机数生成器。

3. 枚举

JDK1.5引入枚举类型。枚举类型的定义包括枚举声明和枚举体。枚举体就是放置一些常量。

定义枚举要使用enum关键字。对于性别、季节、星期几等内容，如果定义为字符串类型，是很难限制其取值的。采用枚举可以轻松解决该问题。

3.1 性别
  1. 定义和使用性别枚举类
public enum Gender {
    男,女
}
  1. 自定义类型
public class Person {
    String name;
    //String sex;
    Gender sex; //枚举类型
    int age;
}
  1. 测试
public static void main(String[] args) {
    Person person = new Person();
    person.sex = Gender.男;
    System.out.println(person.getSex());
}
3.2 季节
  1. 定义枚举类型
public enum Season {
    春,夏,秋,冬
}
  1. 使用枚举类型
public static void main(String[] args) {
    Season season = Season.夏;
    switch(season){
        case 春 :
            System.out.println("春暖花开  踏青  春游");
            break;
        case 夏 :
            System.out.println("夏日炎炎  吃雪糕 游泳");
            break;
        case 秋 :
            System.out.println("秋高气爽  收庄稼  赏月");
            break;
        case 冬 :
            System.out.println("冬雪皑皑  泡温泉  打雪仗");
            break;
    }
}
3.3 总结

所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类！而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final修饰的。可以直接通过枚举类型名使用它们。

注意: 需要定义一组常量时，推荐使用枚举类型；

Educoder- 《JAVA从小白到大牛》（第二章）2-6 Java面向对象 - 常用类
weixin_45674170的博客
11-04 4499
提示：本文章为个人学习记录，仅供参考学习，禁止转载，支持交流与讨论。 文章目录第1关：Object类相关知识什么是Object类1.关于`toString()`方法**2.关于`equals()`方法**Java对象克隆编程要求测试说明参考答案第2关：JAVA基础类型包装类-练习参考答案第3关：String&StringBuilder&StringBuffer类-练习参考答案第4关：Random类相关知识Random类Random对象的生成Random类中的常用方法编程要求测试说明参考答案
实验5 JAVA常用类.doc
05-02
实验5的Java常用类主要涵盖了Java编程中的一些核心概念和常用工具类的使用。以下是这些知识点的详细说明： 1. **String、StringBuffer(StringBuilder)**： - **String** 类在Java中是不可变的，这意味着一旦创建了...
Java常用类介绍
热门推荐
Jenhy的专栏
03-24 1万+
7.1 Java类库的结构 类库就是Java API(Application Programming Interface，应用程序接口)，是系统提供的已实现的标准类的集合。在程序设计中，合理和充分利用类库提供的类和接口，不仅可以完成字符串处理、绘图、网络应用、数学计算等多方面的工作，而
【Java】类与对象
最新发布
Zmmm_11的博客
10-10 971
类是java程序的基本要素，一个java应用程序就是由若干类构成的。类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。在java中定义类时，需要用到class关键字，具体格式如下：class 类名{类体的内容//变量声明//变量声明//变量声明float area;//变量声明float compterArea(){ //定义方法void setHeight(float h){ //定义方法。
JAVA中的类
z972065491的博客
09-16 1万+
java基础
Java面向对象基础--常用基础类
买米当卡的博客
11-26 3695
Java常用基础类 一、包装类 1、包装类的定义; 基本数据类型如int、float、double、boolean、char 等。基本数据类型是不具备对象的特性的，比如基本类型不能调用方法、功能简单。为了让基本数据类型也具备对象的特性，Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。 2、对应关系 二、Integer整数类 部分代码如下： public class Test1 { public static void main(String[] a
JAVA常用类
qq_37933128的博客
10-13 371
JAVA常用包 1.java.lang包 该包是java语言中的核心包，该包中的内容由java虚拟机自动导入。 如：String类，System类等 2.java.util包 该包是java语言中的工具包，里面包含了大量的工具类和集合类等。 如：Scanner类，Random类等 3.java.io包 该包是java语言中的输入输出包，里面包含了大量的读写文件类等。 如：FileOutputStream类，FileInputStream类等 4.java.net包 该包是java语言中的网络包，里面包含了大
JAVA常用类总结
12-22
JAVA常用类,java封装类,String类和StringBuffer类......
Java常用类总结
03-16
总的来说，熟练掌握这些Java常用类对于提升编程效率和编写高质量代码至关重要。它们涵盖了数据存储、输入输出、并发控制、日期时间处理等多个方面，是Java程序员的基础技能。了解并精通这些类的使用，能帮助开发者更...
JAVA常用类与内部类
12-22
什么是内部类？ 在类中定义的类，称之为内部类。 Java中有几种内部类？ 1、成员内部类：定义在类中的类，...Object类是所有类的父类（超类，根类，基类），Java中所有类都是Object类的子类 Object类中所定义的方法是所
Java的常用类
weixin_40055163的博客
02-23 3236
1 基本数据类型的包装类 我们前面学习的八种基本数据类型并不是对象，为了将基本类型数据和对象之间实现互 相转化，JDK 为每一个基本数据类型提供了相应的包装类。 1.1 包装类基本知识 Java 是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据 类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。 比如：将基本数据类型存储到 Object[ ]数组或集合中的操作等等。 为了解决这个不足，Java 在设计类时为每个基本数据类型设计了一个对应的类进行代 表，这样八
Java-常用类
weixin_52453515的博客
11-15 485
以前定义变量，经常使用基本数据类型，对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，将基本数据类型对应进行了一个封装，产生了一个新的类——》包装类。Integer类在对象中包装了一个基本类型int的值。4.Math内部的所有的属性，方法都被static修饰：类名.直接调用，无需创建对象。练习：请输入你想查看的日期：（提示：请按照例如2019-3-7的格式）（1）Java语言 面向对象的语言，最擅长的是操作各种各样的类。以后学习装数据的——》集合，有一个特点，只能装引用数据类型的数据。
java中的类
一个小白
08-06 8953
4.1.类是什么？   1.类–类型–数据类型—复合数据类型—自定义复合数据类型   为什么有复合数据类型？   基本数据类型就8种，在开发中远远不够，所以我们就需要一个可以根据自己的需求随时能制作出一个自己需要的数据类型。   2.类–具有共同性质的一组事物的群体。 人类。   在java中用来描述具有共同性质的一组事物的自定义的复合数据类型—类。   复合数据类型的本质—【根据自己的
Java 类
笔记
02-28 589
在这个示例中，我们定义了一个名为Student的类，它从Person类继承了name、age和address属性，以及walk和talk方法。在这个示例中，我们定义了一个名为Person的类，它具有三个私有属性（name、age和address），两个公共方法（walk和talk），以及一个公共构造函数。Java类是Java编程语言的核心概念之一，用于描述对象的属性和方法。它定义了一个对象的属性和方法，以及它们之间的关系。Java类是Java编程语言中的基本概念之一，用于描述对象的属性和方法。
Java面向对象 - 常用类
ros275229的博客
04-09 450
Java面向对象---常用类
Java中的类
求职之路
11-20 325
1、成员变量和局部变量 （1）成员变量：在类定义中，用来描述对象将要有什么。（可以被本类的方法所使用，也可以被其他和本类相关的类所使用）（作用域：整个类） （2）局部变量：在类的方法中定义，在方法中临时保存数据。（只能在当前的方法中被使用。）（作用域：定义他的方法内部） （3）初始值不同。成员变量初始值是0。局部变量没有初始值。 （4）两类变量同名时，优先局部变量。 2、构造方法 （1）使用new...
java常用类
博客
05-26 319
开发工具与关键技术：MyEclipse 10、java语言、 作者：邓李庆 撰写时间： 2019年5月28日 下面小编给大家讲java的常用类：System类；system类代表当前java程序的运行平台，程序不能创建system类的对象，system类提供了一些类变量和类方法，允许直接通过system类来调用这些类变量和类方法。 例：判断键盘输入见代码图1： 图1 获取系统的所有环境变量见图2...
Java常用类详解：封装类与String类对比
“Java常用类总结涵盖了Java语言中常见的类和方法，包括基本类型的封装类、String类和StringBuffer类的使用，以及这些类的一些核心方法。” 在Java编程中，了解和熟练使用常用类是非常重要的。以下是对标题和描述中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值