JAVA常用API

目录

 

API概述

引用类型的一般使用步骤

1. 导包

2. 创建

3. 使用

键盘录入类Scanner

Random类的使用

String

String的特点

String的四种构造方法

String字符串常量池

String的判断方法

String的获取功能

String类的转换功能

String的去空格和分割功能

String正则表达式的方法

StringBuilder

StringBuilder概念和与String的区别

StringBuilder的构造和常用方法

String和StringBuilder的原理对比

StringBuider的构造方法

StringBuilder的常用方法

append方法

toString方法

DecimalFormat

BigDecimal和BigInteger

Arrays数组工具类

Math数学工具类

Object类

Object简介

方法简略介绍

toString方法

equals方法

equals源码解析

重写equals方法

requireNonNull方法

Date类

Date类介绍

常用方法

空参数构造方法

带long参构造函数

getTime成员方法

DateFormat类和SimpleDateFormat类

DateFormat类

作用

成员方法

SimpleDateFormat类

构造方法

成员方法代码演示

Calendar类

Calendar类的介绍和获取

Calendar类的常用方法

get方法

Set方法

add方法

getTime方法

System类

System类的介绍

System类的常用方法

currentTimeMillis方法

arraycopy方法

包装类

包装类的概念

装箱与拆箱

自动拆箱与自动装箱

基本类型和字符串之间的转换

---

API概述

(1)应用程序编程接口(Application Programming Interface)。其实就是程序员的一本字典

(2)就是JDK提供给我们的一些已经定义好的提高编程效率的java类的说明文档，在API中有Java所有类的介绍，这些类的底层代码是封装的，我们不需要关心如何实现，只要学会使用即可（只有JDK1.6有中文版的官方翻译，而JDK1.6以后就没中文版了，只有英文版）

引用类型的一般使用步骤

1. 导包

import 包路径.类名称;

如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。

只有java.lang包下的内容不需要导包，其他的包都需要import语句。

2. 创建

类名称 对象名 = new 类名称();

3. 使用

对象名.成员方法名()

键盘录入类Scanner

我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，把数据改进为键盘录入，提高程序的灵活性

键盘录入数据的步骤:

A:导包(位置放到class定义的上面)

         import java.util.Scanner;

B:创建对象

         Scanner sc = new Scanner(System.in); // System.in代表从键盘进行输入

C:接收数据

         int x = sc.nextInt(); //接收键盘输入的int类型数据

         String s=sc.next(); //接收键盘输入的String类型数据

String s=sc.nextLine(); //接收键盘输入的String类型数据

sc.nextDouble() //读取小数

sc.nextBoolean() //读取布尔值

         char c = sc.next().charAt(0) //接收char类型数据，接收字符串，取第一个字符

每次调用Scanner的方法只能接受一个数据，比如说想要两个int型键盘输入数据，就需要调用两次nextInt方法

注意:

不能从键盘上直接读取char类型的字符，如果想要读取char类型字符，要通过截取String的第一个字符的方式

 

next()和nextLine()两者都是获取String类型的数据，它们的区别：

next()获取的是空格前的数据

nextLine()获取的是回车前的数据

例如输入曹老板 很有钱，再敲回车，next()只能获取到曹老板，而nextLine()能获取到曹老板 很有钱

Random类的使用

我们想产生1~100(包含1和100)的随机数该怎么办呢? Java已经为我们提供好了产生随机数的类---Random

作用：

–     用于产生一个随机数

•       使用步骤(和Scanner类似)

–     导包

•       import java.util.Random;

–     创建对象

•       Random r = new Random();

–     获取随机数（两个构造函数，一个有参，一个无参）

获取一个随机的int数字（范围是int所有范围，有正负两种）：int number = r.nextInt()

获取一个随机的int数字（参数代表了范围，左闭右开区间）：int number = r.nextInt(10)

产生的数据在0到10之间，包括0，不 包括10，[0,10)，也就是0到9的整数

获取1-100之间的随机数：

int number = r.nextInt(100)+1;

String

在java.lang包下的字符串类

String的特点

1. 字符串的内容永不可变。【重点】

2. 正是因为字符串不可改变，所以字符串是可以共享使用的。

String的四种构造方法

三种构造方法：

public String()：创建一个空白字符串，不含有任何内容。

public String(char[] array)：根据字符数组的内容，来创建对应的字符串。

public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。

一种直接创建：

String str = "Hello"; // 右边直接用双引号

String字符串常量池

字符串常量池：

程序当中直接使用双引号声明出来的String对象会直接存储在常量池中

如果不是用双引号声明的String对象，可以使用String提供的intern方法。intern 方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中，存在，则直接返回常量池对象的引用地址

在JDK6.0及之前版本（JDK7.0版本之前），字符串常量池是放在Perm Gen区(也就是方法区)中, 这个区的大小是固定的在运行时不能改变，其次是这个区不会被gc，所以如果我们intern了太多的字符串到string pool中，这个区的内存很容易就满了并且没有回收策略直接导致内存泄漏，故经常会导致OOM（OutOfMemory）的error，直接使jvm崩溃掉，在jdk6里面，唯一能做的优化就是调大permgen的空间

在JDK7.0版本，字符串常量池被移到了堆中了，最大的好处就是减少了OOM的风险，并且没有被引用的字符串会被gc掉，从而避免了内存泄漏的风险

 

假如说有以下一段程序：

String str1 = "abc";

String str2 = "abc";

 

char[] charArray = {'a', 'b', 'c'};

String str3 = new String(charArray);

 

System.out.println(str1 == str2); // true

System.out.println(str1 == str3); // false

System.out.println(str2 == str3); // false

对于基本类型来说，==是进行数值的比较。

对于引用类型来说，==是进行【地址值】的比较。

 

String s1 = "abc";

String s2 = "abc";

System.out.println(s1==s2);

结果是 true；

 

采用字面值的方式创建一个字符串时，JVM首先会去字符串常量池中查找是否存在"abc"这个对象，如果不存在，则在字符串常量池中创建"abc"这个对象，然后将池中"abc"这个对象的引用地址返回给"abc"对象的引用s1，这样s1会指向字符串常量池中"abc"这个字符串对象；如果存在，则不创建任何对象，直接将池中"abc"这个对象的地址返回，赋给引用s2。因为s1、s2都是指向同一个字符串池中的"abc"对象，所以结果为true。

 

String s3 = new String("xyz");

String s4 = new String("xyz");

System.out.println(s3==s4);

 

结果是 false

 

采用new关键字新建一个字符串对象时，JVM首先在字符串池中查找有没有"xyz"这个字符串对象，如果有，则不在池中再去创建"xyz"这个对象了，直接在堆中创建一个"xyz"字符串对象，然后将堆中的这个"xyz"对象的地址返回赋给引用s3，这样，s3就指向了堆中创建的这个"xyz"字符串对象；如果没有，则首先在字符串池中创建一个"xyz"字符串对象，然后再在堆中创建一个"xyz"字符串对象，然后将堆中这个"xyz"字符串对象的地址返回赋给s3引用，这样，s3指向了堆中创建的这个"xyz"字符串对象。s4则指向了堆中创建的另一个"xyz"字符串对象。s3 、s4是两个指向不同对象的引用，结果当然是false。

其实这种方式就是定义String字符串对象的两种方式结合，括号里面是直接赋值的方式，所以它的地址值是常量池中的地址值，而new的方式是堆中的地址值，所以我们说它创建了两个对象，常量池中一个，堆内存中一个

另外javac编译器会把字符串常量的连接进行优化

String s3 = "he" + "llo";      

//在把.java源文件翻译为.class字节码文件时, javac编译器会把"he"+"llo"优化为"hello", 等JVM运行时, 看到的就是s3="hello"

String的判断方法

boolean equals(Object obj):比较字符串的内容是否相同

         Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。

如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。多态的体现

（如果比较双方一个常量一个变量，推荐把常量字符串写在前面，这样不容易报空指针异常，如果把变量字符串写在前面，变量如果为null，则会报空指针）

boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略英文字母大小写

boolean startsWith(String str):判断字符串对象是否以指定的str开头

boolean endsWith(String str):判断字符串对象是否以指定的str结尾

public int compareTo(String anotherString) 当前字符串与参数anotherString字符串比较大小

举例理解compareTo方法：

String类实现了Comparable接口，重写了接口的抽象方法compareTo

另外类似的有compareToIgnoreCase忽略大小写的比较方法

两个字符串有包含关系的时候，返回的是他们的长度差，其他情况是返回的是他们的assii码值的差

String s1 = "abcd";

String s2 = "abce";

String s3 = "Abc";

String s4 = "abcdefg";

System.out.println(s1.compareTo(s2)); //-1

System.out.println(s1.compareTo(s3));//32

System.out.println(s4.compareTo(s1));//3

System.out.println(s4.compareTo(s2));//-1

String的获取功能

int length():获取字符串的长度，其实也就是字符个数，可用于遍历

String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串

char charAt(int index):获取指定索引处的字符

int indexOf(String str):获取str在字符串对象中第一次出现的索引，如果没有，则返回-1

String substring(int start):从start开始截取字符串，一直到字符串末尾

String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end

String类的转换功能

char[] toCharArray():把字符串转换为字符数组返回

byte[] getBytes()：获得当前字符串底层的字节数组

String toLowerCase():把字符串转换为小写字符串

String toUpperCase():把字符串转换为大写字符串

String replace(CharSequence oldString, CharSequence newString)：

将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。

String的去空格和分割功能

去除字符串两端空格，如果字符串中间有字符它是不会去除的    

         String trim()

按照指定符号分割字符串，返回一个String数组，参数是一个正则表达式，

注意：

如果用“.”作为分隔的话,必须是如下写法,String.split("\\."),这样才能正确的分隔开,不能用String.split(".");    

如果用“|”作为分隔的话,必须是如下写法,String.split("\\|"),这样才能正确的分隔开,不能用String.split("|");

其他的就正常的字符串进行分割即可，不用像上面那样转义

       String[] split(String regex)

String正则表达式的方法

matches( regex) 判断字符串是否匹配指定的正则表达式

replaceAll( regex, replacement ) 把字符串中符合regex正则表达式的子串使用replacement替换

split(regex) 把当前字符串使用符合regex正则表达式的子串进行拆分

正则表达式就是一个模式串, 验证字符串是否匹配指定的模式，就是看字符串是否符合这个正则表达式规定的规则

 [abc]       匹配a或者b或者c中的一个

 .           表示任意一个字符

 \d          数字

 \w          单词字符[a-zA-A0-9_]

 X{n}        正好n次

 X{n,m}      至少n次, 最多m次

StringBuilder

StringBuilder概念和与String的区别

StringBuilder:是一个可变的字符串。字符串缓冲区类。 

String和StringBuilder的区别：

         String的内容是固定的,所以每次做拼接都会产生新的String对象，比较浪费内存

         StringBuilder的内容是可变的，拼接字符串始终用的是同一个StringBuilder容器

StringBuilder的构造和常用方法

A:构造方法:

     StringBuilder()

  B:成员方法:

     public int capacity():返回当前容量 (理论值)

     public int length():返回长度(已经存储的字符个数)

public StringBuilder append(任意类型):添加数据，并返回自身对象

public StringBuilder reverse():反转功能

String和StringBuilder的原理对比

StringBuider的构造方法

java.lang.StringBuilder类:字符串缓冲区,可以提高字符串的效率

构造方法:

   StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。

   StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

StringBuilder的常用方法

append方法

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。

因为是返回对象自身，所以添加数据后的对象和之前的对象用==比较地址返回结果是true，另外像这种返回对象自身的对象可以采用链式编程，继续调用方法，如下代码所示

//创建StringBuilder对象

StringBuilder bu = new StringBuilder();

//使用append方法往StringBuilder中添加数据

//append方法返回的是this,调用方法的对象bu,this==bu

//StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2

//System.out.println(bu);//"abc"

//System.out.println(bu2);//"abc"

//System.out.println(bu==bu2);//比较的是地址 true

 

/*

         链式编程:方法返回值是一个对象,可以继续调用方法

 */

bu.append("abc").append(1).append(true).append(8.8).append('中');

System.out.println(bu);//abc1true8.8中

toString方法

StringBuilder和String可以相互转换:

         String->StringBuilder:可以使用StringBuilder的构造方法

                   StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

         StringBuilder->String:可以使用StringBuilder中的toString方法

                   public String toString()：将当前StringBuilder对象转换为String对象。

DecimalFormat

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字

通常我们在做数字保留两位小数的操作就需要用到这个类了

通常规定的格式化格式会有四个字符表示，分别是#，0，逗号，和小数点.

唯一我们难区分的就是#和0的用法：现在介绍下

0：

比实际数字的位数多，不足的地方用0补上。

new DecimalFormat(“00.00”).format(3.14) //结果：03.14

new DecimalFormat(“0.000”).format(3.14) //结果： 3.140

new DecimalFormat(“00.000”).format(3.14) //结果：03.140

比实际数字的位数少：整数部分不改动，小数部分，四舍五入

new DecimalFormat(“0.000”).format(13.146) //结果：13.146

new DecimalFormat(“00.00”).format(13.146) //结果：13.15

new DecimalFormat(“0.00”).format(13.146) //结果：13.15

#：

比实际数字的位数多，不变。

new DecimalFormat(“##.##”).format(3.14) //结果：3.14

new DecimalFormat(“#.###”).format(3.14) //结果： 3.14

new DecimalFormat(“##.###”).format(3.14) //结果：3.14

比实际数字的位数少：整数部分不改动，小数部分，四舍五入

new DecimalFormat(“#.###”).format(13.146) //结果：13.146

new DecimalFormat(“##.##”).format(13.146) //结果：13.15

new DecimalFormat(“#.##”).format(13.146) //结果：13.15

总结：如果#或者0定义的格式是比实际数字少时，他们的规则一致：整数部分不改动，小数部分，四舍五入，如果比实际位数多，则有区别，0会根据格式规则补充0，而#不变

BigDecimal和BigInteger

当对数字精度要求比较高时使用，BigInteger是对比Long范围还大的数字操作，而BigDecimal是比double还要精确的数字操作

主要有加减乘除方法：add()相加,  subtract()相减,  multiply()相乘, divide()相除

例子:

BigInteger i1 = new BigInteger("79846513898465139846513289653");

BigInteger i2 = new BigInteger("46513986539856298465398465132");

//add()相加,  subtract()相减,  multiply()相乘, divide()相除

BigInteger i3 = i1.add(i2);

System.out.println( i3 );

System.out.println( i1.subtract(i2));

System.out.println( i1.multiply(i2));

System.out.println( i1.divide(i2));

 

//小数有可能会出现除不断的情况

BigDecimal d1 = new BigDecimal("79846597846513984653978465.985");

BigDecimal d2 = new BigDecimal("465132645132978465.985");

//小数相除,如果除不断就会产生java.lang.ArithmeticException算术异常

//小数相除时,经常指定小数的位数（这里保留10位小数）, 及尾数的处理方式

System.out.println( d1.divide(d2, 10, RoundingMode.FLOOR));

//RoundingMode是一种枚举类型, 枚举可以看作是一组常量的组合

//枚举也是一种引用数据类型, 可以定义变量, 赋值时只能赋值枚举类型中定义的常量值

RoundingMode  mode = RoundingMode. ROUND_HALF_UP;// 表示的就是4舍5入

Arrays数组工具类

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

 

public static String toString(数组)：

将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]），方便我们查看数组内容，而不用一个个遍历才能看到，如果数组直接输出我们只能看到一个数组的哈希地址

public static void sort(数组)：

按照默认升序（从小到大）对数组的元素进行排序。

public static 数组类型 copyOf(源数组,新数组的长度)

调用Arrays.copyOf(源数组, 新数组的长度) 可以实现数组复制,返回新的数组

binarySearch(数组,要查找的值)—二分查找法

如果返回负数则表示此数在数组中不存在，如果存在则返回下表索引值

 

代码示例：

int [] data = {56,23,78,34,12,87,98};

//1) 调用Arrays.toString()可以整个数组转为字符串表现形式输出

String str = Arrays.toString(data)

System.out.println(str);

//[56, 23, 78, 34, 12, 87, 98]

 

//2) 调用Arrays.sort()可以对数组元素排序

Arrays.sort(data);

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

//[12, 23, 34, 56, 78, 87, 98]

 

//3) 调用Arrays.copyOf(源数组, 新数组的长度) 可以实现数组复制,返回新的数组

//如果新数组长度比原数组长度还大, 则表示数组扩容

int [] bigger = Arrays.copyOf(data, data.length * 2);

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

//如果新数组长度比原数组长度还小, 则表示数组缩减

int [] smaller = Arrays.copyOf(data, data.length / 2 );

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

 

//4)二分查找,前提数组由小到大排序

System.out.println( Arrays.binarySearch(data, 12));     //0

System.out.println( Arrays.binarySearch(data, 50));     //-4, 负数表示不存在

 

备注：

1. 如果是数值，sort默认按照升序从小到大

2. 如果是字符串，sort默认按照首个字母的字母表位置升序

3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）

Math数学工具类

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

 

public static double abs(double num)：获取绝对值。有多种重载，参数有多种数据类型。

public static double ceil(double num)：向上取整。

public static double floor(double num)：向下取整。

public static long round(double num)：四舍五入。

public static int max(int a, int b)：求两个数中小的数

public static int min(int a, int b):求两个数中大的数

 

Math.PI代表近似的圆周率常量（double）

Object类

Object简介

java.lang.Object

类 Object 是类层次结构的根(父)类

每个类(Person,Student...)都使用Object作为超(父)类。都可以调用Object类中已经定义的方法

方法简略介绍

toString方法

String toString() 返回该对象的字符串表示

Person person = new Person("张三",18)

System.out.println(person)

直接打印对象的名字,其实就是调用对象的toString方法，对象如果没有重写toString方法，则是调用继承自Object的toString方法，方法内容如下：

return getClass().getName() + "@" + Integer.toHexString(hashCode());

类的完整类名+ "@" +哈希码的十六进制形式

直接打印对象地址值 

person = person.toString();

打印结果：

com.itheima.demo01.Object.Person@5f150435（@前面是类的完整类名，@后面是对象地址值）

直接打印对象的地址值没有意义,需要重写Object类中的toString方法

 

看一个类是否重写了toString方法,直接打印这个类的对象即可,如果没有重写toString方法那么打印的是对象的地址值

equals方法

equals源码解析

equals源码：

public boolean equals(Object obj) {

     return (this == obj);

} -

this是谁?哪个对象调用的equals方法,方法中的this就是哪个对象;

假如p1调用的equals方法所以this就是p1

obj是谁?传递过来的参数p2

this==obj -->p1==p2

 

Object类的equals方法,默认比较的是两个对象的地址值

跟==比较引用类型的效果是一样的

重写equals方法

自己手写的equals方法

@Override

public boolean equals(Object obj) {

         //增加一个判断,传递的参数obj如果是this本身,直接返回true,提高程序的效率

         if(obj==this){

                   return true;

         }

         //增加一个判断,传递的参数obj如果是null,直接返回false,提高程序的效率

         if(obj==null){

                   return false;

         }

         //增加一个判断,防止类型转换异常ClassCastException

         if(obj instanceof Person){

                   //使用向下转型,把obj转换为Person类型

                   Person p = (Person)obj;

                   //比较两个对象的属性,一个对象是this(p1),一个对象是p(obj->p2)

                   boolean b = this.name.equals(p.name) && this.age==p.age;

                   return b;

         }

         //传入参数obj不是Person类型直接返回false

         return false;

}

 

使用IDEA自动生成的equals方法

@Override

public boolean equals(Object o) {

         if (this == o) return true;

         if (o == null || getClass() != o.getClass()) return false;

         Person person = (Person) o;

         return age == person.age &&

                            Objects.equals(name, person.name);

}

对上面代码加以解析：

//getClass() != o.getClass()

使用反射技术,判断o是否是此方法所在类的类型（这里类是Person） 等效于 obj instanceof Person

 

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是空指针安全的

在比较两个对象的时候，Object的equals方法容易出现空指针异常，而Objects的equals方法优化了这个问题

Objects类的equals方法:对两个对象进行比较,防止空指针异常，源码如下：

public static boolean equals(Object a, Object b) {

      return (a == b) || (a != null && a.equals(b));

}

requireNonNull方法

Obects类中的静态方法

public static T requireNonNull(T obj):查看指定引用对象不是null。

源码:

         public static T requireNonNull(T obj) {

                   if (obj == null)

                            throw new NullPointerException();

                   return obj;

         }

如果传递对象是null，则抛出空指针异常，如果不是null，则返回源对象

还有重载的方法：public static T requireNonNull(T obj,String message)

这个message是空指针异常抛出的时候所返回到控制台的信息

应用场景：下次再遇到要判断对象是否为空，空的时候报空指针异常的时候就可以使用这个方法

Date类

Date类介绍

java.util.Date:表示日期和时间的类

类 Date 表示特定的瞬间，精确到毫秒。

毫秒:千分之一秒 1000毫秒=1秒

毫秒值的作用:可以对时间和日期进行计算

把毫秒转换为日期:

1 天 = 24 × 60 × 60 = 86400 秒  = 86400 x 1000 = 86400000毫秒

时间原点(0毫秒)定义:1970 年 1 月 1 日 00:00:00(英国格林威治)，因为中国属于东八区，所以时间原点为1970 年 1 月 1 日 08:00:00

System.currentTimeMillis()：获取当前系统时间到1970 年 1 月 1 日 00:00:00经历了多少毫秒

常用方法

空参数构造方法

Date() 获取当前系统的日期和时间

使用：Date date = new Date()

直接打印：System.out.println(date); //Sun Aug 08 12:23:03 CST 2088

计算的时间原点是1970 年 1 月 1 日 08:00:00

说明Date重写了toString方法，因为打印出来的不是个地址值

带long参构造函数

Date(long date) :传递毫秒值,把毫秒值转换为Date日期

Date date = new Date(0L);

System.out.println(date);// Thu Jan 01 08:00:00 CST 1970

getTime成员方法

long getTime() 把日期转换为毫秒值(相当于System.currentTimeMillis()方法)

返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数

Date date = new Date();

long time = date.getTime();

System.out.println(time);  //3742777636267

DateFormat类和SimpleDateFormat类

DateFormat类

java.text.DateFormat:是日期/时间格式化子类的抽象类

DateFormat类是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的子类SimpleDateFormat类

作用

格式化（也就是日期 -> 文本）、解析（文本-> 日期）

成员方法

String format(Date date)  按照指定的模式,把Date日期,格式化为符合模式的字符串

Date parse(String source)  把符合模式的字符串,解析为Date日期

SimpleDateFormat类

构造方法

SimpleDateFormat(String pattern)

参数: String pattern:传递指定的模式

模式：

常用模式："yyyy-MM-dd HH:mm:ss"

注意:

模式中的字母不能更改,连接模式的符号可以改变

"yyyy年MM月dd日 HH时mm分ss秒"

成员方法代码演示

使用DateFormat类中的方法format,把日期格式化为文本

使用步骤:

   1.创建SimpleDateFormat对象,构造方法中传递指定的模式

   2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期

格式化为符合模式的字符串(文本)

 

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");

Date date = new Date();

String d = sdf.format(date);

System.out.println(date);//Sun Aug 08 15:51:54 CST 2088

System.out.println(d);//2088年08月08日 15时51分54秒

 

使用DateFormat类中的方法parse,把文本解析为日期

使用步骤:

   1.创建SimpleDateFormat对象,构造方法中传递指定的模式

   2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期

注意:

    public Date parse(String source) throws ParseException

    parse方法声明了一个异常叫ParseException

    如果字符串和构造方法的模式不一样,那么程序就会抛出此异常

调用一个抛出了异常的方法,就必须的处理这个异常,要么throws继续抛出这个异常,要么try catch自己处理

比如下面的字符串是"2088年08月08日 15时51分54秒"，而构造方法的模式是"yyyy年MM月dd日 HH时mm分ss秒"，如果年月日时分秒没有对应起来就会抛出ParseException异常

private static void demo02() throws ParseException {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");

Date date = sdf.parse("2088年08月08日 15时51分54秒");

System.out.println(date); //Sun Aug 08 15:51:54 CST 2088

}

Calendar类

Calendar类的介绍和获取

java.util.Calendar类:日历类

    Calendar类是一个抽象类,里边提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR )

    Calendar类无法直接创建对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象

static Calendar getInstance() 使用默认时区和语言环境获得一个日历。

使用方式：Calendar c = Calendar.getInstance();

Calendar类的常用方法

Calendar类的四个常用成员方法:

        public int get(int field)：返回给定日历字段的值。

        public void set(int field, int value)：将给定的日历字段设置为给定值。

        public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段

添加或减去指定的时间量。

        public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移

量）的Date对象。

    成员方法的参数:

        int field:日历类的字段,可以使用Calendar类的静态成员变量获取

            public static final int YEAR = 1;         年

            public static final int MONTH = 2;   月

            public static final int DATE = 5;         月中的某一天

            public static final int DAY_OF_MONTH = 5;月中的某一天

            public static final int HOUR = 10;            时

            public static final int MINUTE = 12;        分

            public static final int SECOND = 13;     秒

get方法

public int get(int field)：返回给定日历字段的值。

        参数:传递指定的日历字段(YEAR,MONTH等)

        返回值:日历字段代表的具体的值

private static void demo01() {

         //使用getInstance方法获取Calendar对象

         Calendar c = Calendar.getInstance();

         int year = c.get(Calendar.YEAR);

         System.out.println(year);

         int month = c.get(Calendar.MONTH);

         System.out.println(month);  //西方的月份0-11 东方:1-12

         //int date = c.get(Calendar.DAY_OF_MONTH);

         int date = c.get(Calendar.DATE);// DAY_OF_MONTH和DATE效果一样，都是求这个月的第几天

         System.out.println(date);

}

Set方法

public void set(int field, int value)：将给定的日历字段设置为给定值。

参数:

         int field:传递指定的日历字段(YEAR,MONTH...)

         int value:给指定字段设置的值

private static void demo02() {

         //使用getInstance方法获取Calendar对象

         Calendar c = Calendar.getInstance();

         //设置年为9999

         c.set(Calendar.YEAR,9999);

         //设置月为9月

         c.set(Calendar.MONTH,9);

         //设置日9日

         c.set(Calendar.DATE,9);

         //同时设置年月日,可以使用set的重载方法

         c.set(8888,8,8);

         int year = c.get(Calendar.YEAR);

         System.out.println(year);

         int month = c.get(Calendar.MONTH);

         System.out.println(month);//西方的月份0-11 东方:1-12

         int date = c.get(Calendar.DATE);

         System.out.println(date);

}

add方法

public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。

把指定的字段增加/减少指定的值

参数:

         int field:传递指定的日历字段(YEAR,MONTH...)

         int amount:增加/减少指定的值

                   正数:增加

                   负数:减少

private static void demo03() {

         //使用getInstance方法获取Calendar对象

         Calendar c = Calendar.getInstance();

         //把年增加2年

         c.add(Calendar.YEAR,2);

         //把月份减少3个月

         c.add(Calendar.MONTH,-3);

         int year = c.get(Calendar.YEAR);

         System.out.println(year);

         int month = c.get(Calendar.MONTH);

         System.out.println(month);//西方的月份0-11 东方:1-12

         //int date = c.get(Calendar.DAY_OF_MONTH);

         int date = c.get(Calendar.DATE);

         System.out.println(date);

}

getTime方法

public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

         把日历对象,转换为日期对象

private static void demo04() {

         //使用getInstance方法获取Calendar对象

         Calendar c = Calendar.getInstance();



         Date date = c.getTime();

         System.out.println(date);

}

System类

System类的介绍

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

         public static long currentTimeMillis()：返回以毫秒为单位的当前时间。

         public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

System类的常用方法

currentTimeMillis方法

public static long currentTimeMillis()：返回以毫秒为单位的当前时间。

用来程序的效率

例子：验证for循环打印数字1-9999所需要使用的时间（毫秒）

private static void demo01() {

         //程序执行前,获取一次毫秒值

         long s = System.currentTimeMillis();

         //执行for循环

         for (int i = 1; i <=9999 ; i++) {

                   System.out.println(i);

         }

         //程序执行后,获取一次毫秒值

         long e = System.currentTimeMillis();

         System.out.println("程序共耗时:"+(e-s)+"毫秒");//程序共耗时:106毫秒

}

arraycopy方法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

参数:

         src - 源数组。

         srcPos - 源数组中的起始位置(起始索引)。

         dest - 目标数组。

         destPos - 目标数据中的起始位置。

         length - 要复制的数组元素的数量。

练习:

         将src数组中前3个元素，复制到dest数组的前3个位置上

                   复制元素前：

                   src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]

                   复制元素后：

                   src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

private static void demo02() {

         //定义源数组

         int[] src = {1,2,3,4,5};

         //定义目标数组

         int[] dest = {6,7,8,9,10};

         System.out.println("复制前:"+ Arrays.toString(dest));

         //使用System类中的arraycopy把源数组的前3个元素复制到目标数组的前3个位置上

         System.arraycopy(src,0,dest,0,3);

         System.out.println("复制后:"+ Arrays.toString(dest));

}

包装类

包装类的概念

基本数据类型使用起来非常方便，但是弊端在于没有对应的方法来操作这些基本类型的数据，我们可以使用一个类，把基本类型的数据包装起来，在类中定义一些方法，这个类就叫包装类，我们可以使用类中的方法来操作这些基本类型的数据

装箱与拆箱

装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)

构造方法:

         Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。

         Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

            传递的字符串,必须是基本类型的字符串,否则会抛出异常 "100" 正确  "a" 抛异常

静态方法:

         static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。

         static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。

 

拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)

成员方法:

         int intValue() 以 int 类型返回该 Integer 的值。

自动拆箱与自动装箱

自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换

JDK1.5之后出现的新特性

/*

         自动装箱:直接把int类型的整数赋值包装类

         Integer in = 1; 就相当于 Integer in = new Integer(1);

 */

Integer in = 1;

/*

         自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算

         in+2;就相当于 in.intVale() + 2 = 3

         in = in.intVale() + 2 = 3 又是一个自动装箱

 */

in = in+2;

基本类型和字符串之间的转换

基本类型与字符串类型之间的相互转换

基本类型->字符串(String)

         1.基本类型的值+""  最简单的方法(工作中常用)

         2.包装类的静态方法toString(参数),不是Object类的toString()

                   static String toString(int i) 返回一个表示指定整数的 String 对象。

         3.String类的静态方法valueOf(参数)

                   static String valueOf(int i) 返回 int 参数的字符串表示形式。

字符串(String)->基本类型

         使用包装类的静态方法parseXXX("字符串");

                   Integer类: static int parseInt(String s)

                   Double类: static double parseDouble(String s)

 

代码示例：

//基本类型->字符串(String)

int i1 = 100;

String s1 = i1+"";

System.out.println(s1+200);//100200



String s2 = Integer.toString(100);

System.out.println(s2+200);//100200



String s3 = String.valueOf(100);

System.out.println(s3+200);//100200



//字符串(String)->基本类型

int i = Integer.parseInt(s1);

System.out.println(i-10);



int a = Integer.parseInt("a");//NumberFormatException

System.out.println(a);