11. Java常用类

Posted Jeknight

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了11. Java常用类相关的知识,希望对你有一定的参考价值。

1. Scanner类

1.1 基本语法

java.util.Scanner 是 Java5 的新特征,我们可以通过 Scanner 类来获取用户的输入。

Scanner s = new Scanner(System.in);

1.2 next方法

import java.util.Scanner; 

public class ScannerDemo {  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in); 
    // 从键盘接收数据  

    //next方式接收字符串
        System.out.println("next方式接收:");
        // 判断是否还有输入
        if(scan.hasNext()){   
          String str1 = scan.next();
          System.out.println("输入的数据为:"+str1);  
        }  

    }  
}

输出结果:

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收:
rimi com
输入的数据为:rimi

可以看到 com 字符串并未输出

1.3 nextLine方法

import java.util.Scanner; 

public class ScannerDemo {  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in); 
    // 从键盘接收数据  

    //nextLine方式接收字符串
        System.out.println("nextLine方式接收:");
        // 判断是否还有输入
        if(scan.hasNextLine()){   
          String str2 = scan.nextLine();
          System.out.println("输入的数据为:"+str2);  
        }  

    }  
}

执行以上程序输出结果为:

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收:
rimi com
输入的数据为:rimi com

可以看到 com 字符串输出。

1.4 next与nextLine()的区别

next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白,next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next() 不能得到带有空格的字符串。

nextLine():

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

1.5 使用Scanner输入多种数据类型

如果要输入 int 或 float 类型的数据,在 Scanner 类中也有支持,但是在输入之前最好先使用 hasNextXxx() 方法进行验证,再使用 nextXxx() 来读取

import java.util.Scanner;  

public class ScannerDemo {  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in);  
    // 从键盘接收数据  
        int i = 0 ;  
        float f = 0.0f ;  
        System.out.print("输入整数:");  
        if(scan.hasNextInt()){                 
      // 判断输入的是否是整数  
            i = scan.nextInt() ;                
      // 接收整数  
            System.out.println("整数数据:" + i) ;  
        }else{                                 
      // 输入错误的信息  
            System.out.println("输入的不是整数!") ;  
        }  
        System.out.print("输入小数:");  
        if(scan.hasNextFloat()){              
      // 判断输入的是否是小数  
            f = scan.nextFloat() ;             
      // 接收小数  
            System.out.println("小数数据:" + f) ;  
        }else{                                
      // 输入错误的信息  
            System.out.println("输入的不是小数!") ;  
        }  
    }  
}

输出结果:

$ javac ScannerDemo.java
$ java ScannerDemo
输入整数:12
整数数据:12
输入小数:1.2
小数数据:1.2

1.6 练习

1. 请输入需要累加的整数,直到输入 0 结束累加。

2. Number和Math类

2.1 什么是包装类

一般地,当需要使用数字的时候,我们通常使用内置数据类型,如:byte、int、long、double 等

int a = 5000;
float b = 13.65f;
byte c = 0x4a;

然而,在实际开发过程中,我们经常会遇到需要使用对象,而不是内置数据类型的情形。为了解决这个问题,Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。

这种由编译器特别支持的包装称为装箱,所以当内置数据类型被当作对象使用的时候,编译器会把内置类型装箱为包装类。相似的,编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

public class Test{

   public static void main(String args[]){
      Integer x = 5;
      x =  x + 10;
      System.out.println(x); 
   }
}

当 x 被赋为整型值时,由于x是一个对象,所以编译器要对x进行装箱。然后,为了使x能进行加运算,所以要对x进行拆箱。

关于拆箱封箱

/**
* 
* java中的自动装箱与拆箱
* 简单一点说,装箱就是自动将基本数据类型转换为包装器类型;拆箱就是自动将包装器类型转换为基本数据类型。
*/
public class NumberDemo {
    public static void main(String[] args) {
        /*
        Integer i1 = 128;  // 装箱,相当于 Integer.valueOf(128);
        int t = i1; //相当于 i1.intValue() 拆箱
        System.out.println(t);
        */

        /*
        对于–128到127(默认是127)之间的值,被装箱后,会被放在内存里进行重用
        但是如果超出了这个值,系统会重新new 一个对象
        */
        Integer i1 = 200;
        Integer i2 = 200;

        /*
        注意 == 与 equals的区别
        == 它比较的是对象的地址
        equlas 比较的是对象的内容
        */
        if(i1==i2) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

2.2 Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法,如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式,通过 Math 类可以在主函数中直接调用。

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值:" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值:" + Math.cos(0));  
        System.out.println("60度的正切值:" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值: " + Math.atan(1));  
        System.out.println("π/2的角度值:" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}

结果如下:

90 度的正弦值:1.0
0度的余弦值:1.0
60度的正切值:1.7320508075688767
1的反正切值: 0.7853981633974483
π/2的角度值:90.0
3.141592653589793

2.3 number和Math类的方法

1   xxxValue()
将 Number 对象转换为xxx数据类型的值并返回。
2   compareTo()
将number对象与参数比较。
3   equals()
判断number对象是否与参数相等。
4   valueOf()
返回一个 Number 对象指定的内置数据类型
5   toString()
以字符串形式返回值。
6   parseInt()
将字符串解析为int类型。
7   abs()
返回参数的绝对值。
8   ceil()
对整形变量向左取整,返回类型为double型。
9   floor()
对整型变量向右取整。返回类型为double类型。
10  rint()
返回与参数最接近的整数。返回类型为double。
11  round()
返回一个最接近的int、long型值。
12  min()
返回两个参数中的最小值。
13  max()
返回两个参数中的最大值。
14  exp()
返回自然数底数e的参数次方。
15  log()
返回参数的自然数底数的对数值。
16  pow()
返回第一个参数的第二个参数次方。
17  sqrt()
求参数的算术平方根。
18  sin()
求指定double类型参数的正弦值。
19  cos()
求指定double类型参数的余弦值。
20  tan()
求指定double类型参数的正切值。
21  asin()
求指定double类型参数的反正弦值。
22  acos()
求指定double类型参数的反余弦值。
23  atan()
求指定double类型参数的反正切值。
24  atan2()
将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
25  toDegrees()
将参数转化为角度。
26  toRadians()
将角度转换为弧度。
27  random()
返回一个随机数。

举例

    /** 
     * abs求绝对值 
     */  
    System.out.println(Math.abs(-10.4));    //10.4  
    System.out.println(Math.abs(10.1));     //10.1  

    /** 
     * ceil天花板的意思,就是返回大的值,注意一些特殊值 
     */  
    System.out.println(Math.ceil(-10.1));   //-10.0  
    System.out.println(Math.ceil(10.7));    //11.0  
    System.out.println(Math.ceil(-0.7));    //-0.0  
    System.out.println(Math.ceil(0.0));     //0.0  
    System.out.println(Math.ceil(-0.0));    //-0.0  

    /** 
     * floor地板的意思,就是返回小的值 
     */  
    System.out.println(Math.floor(-10.1));  //-11.0  
    System.out.println(Math.floor(10.7));   //10.0  
    System.out.println(Math.floor(-0.7));   //-1.0  
    System.out.println(Math.floor(0.0));    //0.0  
    System.out.println(Math.floor(-0.0));   //-0.0  

    /** 
     * max 两个中返回大的值,min和它相反,就不举例了 
     */  
    System.out.println(Math.max(-10.1, -10));   //-10.0  
    System.out.println(Math.max(10.7, 10));     //10.7  
    System.out.println(Math.max(0.0, -0.0));    //0.0  

    /** 
     * random 取得一个大于或者等于0.0小于不等于1.0的随机数 
     */  
    System.out.println(Math.random());  //0.08417657924317234  
    System.out.println(Math.random());  //0.43527904004403717  

    /** 
     * rint 四舍五入,返回double值 
     * 注意.5的时候会取偶数 
     */  
    System.out.println(Math.rint(10.1));    //10.0  
    System.out.println(Math.rint(10.7));    //11.0  
    System.out.println(Math.rint(11.5));    //12.0  
    System.out.println(Math.rint(10.5));    //10.0  
    System.out.println(Math.rint(10.51));   //11.0  
    System.out.println(Math.rint(-10.5));   //-10.0  
    System.out.println(Math.rint(-11.5));   //-12.0  
    System.out.println(Math.rint(-10.51));  //-11.0  
    System.out.println(Math.rint(-10.6));   //-11.0  
    System.out.println(Math.rint(-10.2));   //-10.0  

    /** 
     * round 四舍五入,float时返回int值,double时返回long值 
     */  
    System.out.println(Math.round(10.1));   //10  
    System.out.println(Math.round(10.7));   //11  
    System.out.println(Math.round(10.5));   //11  
    System.out.println(Math.round(10.51));  //11  
    System.out.println(Math.round(-10.5));  //-10  
    System.out.println(Math.round(-10.51)); //-11  
    System.out.println(Math.round(-10.6));  //-11  
    System.out.println(Math.round(-10.2));  //-10  

3. Character类

3.1 Character类的用法

Character 类用于对单个字符进行操作。

Character 类在对象中包装一个基本类型 char 的值

// 单个字符
char ch = \'a\';

// Unicode 字符表示形式
char uniChar = \'\\u039A\'; 

// 字符数组
char[] charArray ={ \'a\', \'b\', \'c\', \'d\', \'e\' };

// 包装类 Character
Character ch = new Character(\'a\');

在某些情况下,Java编译器会自动创建一个Character对象。

例如,将一个char类型的参数传递给需要一个Character类型参数的方法时,那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱,反过来称为拆箱。

public static void main(String[] args) {
    // 原始字符 \'a\' 装箱到 Character 对象 character 中
    Character character = \'a\';
    // 原始字符 \'x\' 用 test 方法装箱
    // 返回拆箱的值到 ch
    char ch = test(\'x\');
}
public static char test(Character c) {
    return c;
}

3.2 转义序列

前面有反斜杠(\\)的字符代表转义字符,它对编译器来说是有特殊含义的。

\\t  在文中该处插入一个tab键
\\b  在文中该处插入一个后退键
\\n  在文中该处换行
\\r  在文中该处插入回车
\\f  在文中该处插入换页符
\\\'  在文中该处插入单引号
\\"  在文中该处插入双引号
\\\\  在文中该处插入反斜杠

3.3 Character类的方法

1   isLetter()  是否是一个字母
2   isDigit()   是否是一个数字字符
3   isWhitespace()  是否是一个空格
4   isUpperCase()   是否是大写字母
5   isLowerCase()   是否是小写字母
6   toUpperCase()   指定字母的大写形式
7   toLowerCase()   指定字母的小写形式
8   toString()  返回字符的字符串形式,字符串的长度仅为1

4. String类

字符串广泛应用 在Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串。

4.1 创建字符串

创建字符串最简单的方式如下:

String greeting = "睿峰科技";

在代码中遇到字符串常量时,这里的值是 "睿峰科技"",编译器会使用该值创建一个 String 对象。 和其它对象一样,可以使用关键字和构造方法来创建 String 对象。 String 类有 11 种构造方法,这些方法提供不同的参数来初始化字符串,比如提供一个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] nameArray = { \'r\', \'i\', \'m\', \'i\'};
      String nameString = new String(nameArray);  
      System.out.println(nameString);
   }
}

注意:String 类是不可改变的,所以你一旦创建了 String 对象,那它的值就无法改变了。

如果需要对字符串做很多修改,那么应该选择使用 StringBuffer & StringBuilder 类。

String 类是不可改变的解析,例如:

String s = "Google";
System.out.println("s = " + s);

s = "Rimi";
System.out.println("s = " + s);

结果为:

Google
Rimi

从结果上看是改变了,但为什么门说String对象是不可变的呢?

原因在于实例中的 s 只是一个 String 对象的引用,并不是对象本身,当执行 s = "Rimi"; 创建了一个新的对象 "Rimi",而原来的 "Google" 还存在于内存中。

4.2 字符串长度

用于获取有关对象的信息的方法称为访问器方法。

String 类的一个访问器方法是 length() 方法,它返回字符串对象包含的字符数。

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.rimiedu.com";
        int len = site.length();
        System.out.println( "睿峰教育网址长度 : " + len );
   }
}

4.3 连接字符串

String 类提供了连接两个字符串的方法:

string1.concat(string2);

更常用的是使用\'+\'操作符来连接字符串,如:

"Hello," + " rimi" + "!"

4.4 常用String类方法

1.字符串比较

compareTo
compareToIgnoreCase(//忽略大小写)

2.查找字符串最后一次出现的位置

lastIndexOf

3.截取字符串出现

substring

4.字符串替换

replace
replaceFirst
replaceAll

5.字符串反转

StringBuffer

6.字符串查找

indexOf

7.字符串分割

split

8.字符串小写转大写

toUpperCase

9.测试两个字符串区域是否相等

//参数说明:自己的起始位置,比较的 String, 比较的 String 的起始位置,比较长度。
regionMatches(11, second_str, 12, 9);
regionMatches(true, 11, second_str, 12, 9); //第一个参数 true 表示忽略大小写区别

10.字符串性能比较测试

System.currentTimeMillis(); //利用获取时间戳进行比较
//第一种创建形式
String s1 = "hello";
//第二种创建形式
String s2 = new String("hello");

11.字符串优化

1. 直接使用字符串
     String str  = "123";
     String str1 = "123";
2. 使用 new 关键字
     String str2 = new String("123");

字符串优化处理

12.连接字符串

字符串连接 - 使用 + 操作符

字符串连接 - 使用 StringBuffer/StringBuilder

StringBuffer
代码示例:
   StringBuilder sb = new StringBuilder ( "" );   
        for ( int i= 0 ;i< 10 ;i++){   
               sb.append(String.valueOf(i)); 
               System.out.println(sb+",");
               }  

5. StringBuffer/StringBuilder类

当对字符串进行修改的时候,需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是,StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出,它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的(不能同步访问)。

由于 StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下,则必须使用 StringBuffer 类。

public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("睿峰官网:");
    sBuffer.append("www");
    sBuffer.append(".rimi");
    sBuffer.append(".com");
    System.out.println(sBuffer);  
  }
}

StringBuffer方法:

1   public StringBuffer append(String s)    将指定的字符串追加到此字符序列。
2   public StringBuffer reverse()    将此字符序列用其反转形式取代。
3   public delete(int start, int end)   移除此序列的子字符串中的字符。
4   public insert(int offset, int i)    将 int 参数的字符串表示形式插入此序列中。
5   replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

Java 中 StringBuffer 和 String 是有一定的区别的

首先,String 是被 final 修饰的,他的长度是不可变的,就算调用 String 的 concat 方法,那也是把字符串拼接起来并重新创建一个对象,把拼接后的 String 的值赋给新创建的对象,

而 StringBuffer 的长度是可变的,调用StringBuffer 的 append 方法,来改变 StringBuffer 的长度,并且,相比较于 StringBuffer,String 一旦发生长度变化,是非常耗费内存的!


5. 数组类

java.util.Arrays 类能方便地操作数组,它提供的所有方法都是静态的。

具有以下功能:

  • 给数组赋值:通过 fill 方法。
  • 对数组排序:通过 sort 方法,按升序。
  • 比较数组:通过 equals 方法比较数组中元素值是否相等。
  • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

常用方法:

1   public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
2   public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
3   public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
4   public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

6. 时间日期

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。

第一个构造函数使用当前日期和时间来初始化对象。

Date( )

第二个构造函数接收一个参数,该参数是从1970年1月1日起的毫秒数。

Date(long millisec)

6.1 常用Date方法

1   boolean after(Date date)
若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2   boolean before(Date date)
若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3   Object clone( )
返回此对象的副本。
4   int compareTo(Date date)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5   int compareTo(Object obj)
若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6   boolean equals(Object date)
当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7   long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8   int hashCode( )
 返回此对象的哈希码值。
9   void setTime(long time)
用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10  String toString( )
转换Date对象为String表示形式,并返回该字符串。

6.2 获取当前时间

Java中获取当前日期和时间很简单,使用 Date 对象的 toString() 方法来打印当前日期和时间

import java.util.Date;

public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();

       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }
}

6.3 日期比较

Java使用以下三种方法来比较两个日期:

  • 使用 getTime() 方法获取两个日期(自1970年1月1日经历的毫秒数值),然后比较这两个值。
  • 使用方法 before(),after() 和 equals()。例如,一个月的12号比18号早,则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
  • 使用 compareTo() 方法,它是由 Comparable 接口定义的,Date 类实现了这个接口。

6.4 使用 SimpleDateFormat 格式化日期

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行

import java.util.*;
import java.text.*;

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

      Date dNow = new Date( );
      SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd \'at\' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

这一行代码确立了转换的格式,其中 yyyy 是完整的公元年,MM 是月份,dd 是日期,HH:mm:ss 是时、分、秒。

注意:有的格式大写,有的格式小写,例如 MM 是月份,mm 是分;HH 是 24 小时制,而 hh 是 12 小时制。

6.5 日期和时间的格式化编码

时间模式字符串用来指定时间格式。在此模式中,所有的 ASCII 字母被保留为模式字母,定义如下:

G   纪元标记    AD
y   四位年份    2001
M   月份  July or 07
d   一个月的日期  10
h    A.M./P.M. (1~12)格式小时   12
H   一天中的小时 (0~23)   22
m   分钟数 30
s   秒数  55
S   毫秒数 234
E   星期几 Tuesday
D   一年中的日子  360
F   一个月中第几周的周几  2 (second Wed. in July)
w   一年中第几周  40
W   一个月中第几周 1
a   A.M./P.M. 标记    PM
k   一天中的小时(1~24)    24
K    A.M./P.M. (0~11)格式小时   10
z   时区  Eastern Standard Time
\'   文字定界符   Delimiter
"   单引号 `

6.6 测量时间

System.currentTimeMillis(); //获取当前时间戳

import java.util.*;

public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\\n");
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\\n");
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

6.7 Calendar类

我们现在已经能够格式化并创建一个日期对象了,但是我们如何才能设置和获取日期数据的特定部分呢,比如说小时,日,或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。

Calendar类的功能要比Date类强大很多,而且在实现方式上也比Date类要复杂一些。

Calendar类是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用getInstance方法创建即可。

6.7.1 创建Calendar类对象

  1. 创建一个代表系统当前日期的Calendar对象

    Calendar c = Calendar.getInstance();//默认是当前日期

  2. 创建一个指定日期的Calendar对象

    使用Calendar类代表特定的时间,需要首先创建一个Calendar的对象,然后再设定该对象中的年月日参数来完成。

    //创建一个代表2009年6月12日的Calendar对象
    Calendar c1 = Calendar.getInstance();
    c1.set(2009, 6 - 1, 12);
    

6.7.2 Calendar类对象字段

Calendar类中用一下这些常量表示不同的意义,jdk内的很多类其实都是采用的这种思想

Calendar.YEAR   年份
Calendar.MONTH  月份
Calendar.DATE   日期
Calendar.DAY_OF_MONTH   日期,和上面的字段意义完全相同
Calendar.HOUR   12小时制的小时
Calendar.HOUR_OF_DAY    24小时制的小时
Calendar.MINUTE 分钟
Calendar.SECOND 秒
Calendar.DAY_OF_WEEK    星期几

6.7.3 Calendar类对象的获取

Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几(注意(这个与Date类是不同的):1代表星期日、2代表星期1、3代表星期二,以此类推)
int day = c1.get(Calendar.DAY_OF_WEEK);

 

以上是关于11. Java常用类的主要内容,如果未能解决你的问题,请参考以下文章

elasticsearch代码片段,及工具类SearchEsUtil.java

Android Navigation java.language.IllegalStateException 片段类未设置

solr分布式索引实战分片配置读取:工具类configUtil.java,读取配置代码片段,配置实例

java 代码片段

java代码在片段活动中不起作用

如何通过单击片段内的线性布局从片段类开始新活动?下面是我的代码,但这不起作用