目录
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> T requireNonNull(T obj):查看指定引用对象不是null。
源码:
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}
如果传递对象是null,则抛出空指针异常,如果不是null,则返回源对象
还有重载的方法:public static <T> 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);