String常量池:
JVM在使用字符串类型时,为了提高内存使用效率,当使用字面量(常量)给变量赋值时,在方法区内提供了用于存储字面量对象的一个常量池.
原理:
当使用字面量赋值时,先去方法区内的常量池中查询是否有相同字面量的对象.如果有则返回常量池中对象的地址,若没有则在常量池中创建此字面量的对象再返回.
可以看看下面的实例:
public class Tests {
public static void main(String[] args) {
//使用构造器创建两个helloworld字符串对象
String s1 = new String("helloworld");
String s2 = new String("helloworld");
//查看s1与s2是不是同一个对象
System.out.println("s1与s2:"+(s1==s2));
System.out.println("s1与s2内容对比:"+s1.equals(s2));
String s3 = "helloworld";
String s4 = "helloworld";
System.out.println("s2与s3:"+(s2==s3));//false;说明s2与s3不是同一个对象
System.out.println("s3与s4:"+(s3==s4));//true;是同一个对象
String s5 = "hello";
String s6 = "world";
/*编译器在编译期间会进行一些简单的运算
*
*将两个字面量"hello"与"world"拼接成了
* "helloworld"
* */
String s7 = "hello"+"world";
System.out.println("s4与s7:"+(s4==s7));
String s8 = s5+"world";
System.out.println("s4与s8:"+(s4==s8));
String s9 = s5+s6;
System.out.println("s4与s9:"+(s4==s9));
System.out.println("s8与s9:"+(s8==s9));
}
}
运行结果:
s1与s2:false
s1与s2内容对比:true
s2与s3:false
s3与s4:true
s4与s7:true
s4与s8:false
s4与s9:false
s8与s9:false
包装类的常量池：
首先看看包装类与基本数据类型的对应关系:
基本数据类型
包装类
byte
Byte
short
Short
int
Integer
long
Long
float
Float
double
Double
char
Character
boolean
Boolean
除int和char有所不同之外,其余的都是首字母变大写.
Boolean与Character直接继承自Object类,其余的则继承自Numbers类,而Numbers则继承自Object类.
当将基本数据类型进行自动装箱时，装箱后的对象的字面值，如果是在-128~127之间，会先检查常量池中是否有相同字面值的对象，如果有，则将常量池的对象的地址给引用变量,若没有则创建一个.
下面给出Integer包装类的各种情况
示例代码:
public class Tests {
public static void main(String[] args) {
/*首先定义一个基本数据类型的数据*/
int i=1;
/*包装类的常量池实验*/
Integer i1=1;
Integer i2=1;
Integer i3=new Integer(i);
Integer i4=new Integer(1);
System.out.println("i1与i2是不是同一个对象:"+(i1==i2));
System.out.println("i1与i2的equals方法:"+(i1.equals(i2)));
System.out.println("i2与i3是不是同一个对象:"+(i2==i3));
System.out.println("i2与i3的equals方法:"+(i2.equals(i3)));
System.out.println("i2与i4是不是同一个对象:"+(i2==i4));
System.out.println("i2与i4的equals方法:"+(i2.equals(i4)));
System.out.println("i3与i4是不是同一个对象:"+(i3==i4));
System.out.println("i3与i4的equals方法:"+(i3.equals(i4)));
/*小于-128大于127范围的情况,应该与i1与i2的情况进行对比:*/
Integer i5=128;
Integer i6=128;
System.out.println("i5与i6是不是同一个对象:"+(i5==i6));
System.out.println("i5与i6的equals方法:"+(i5.equals(i6)));
}
}
运行结果:
i1与i2是不是同一个对象:true
i1与i2的equals方法:true
i2与i3是不是同一个对象:false
i2与i3的equals方法:true
i2与i4是不是同一个对象:false
i2与i4的equals方法:true
i3与i4是不是同一个对象:false
i3与i4的equals方法:true
i5与i6是不是同一个对象:false
i5与i6的equals方法:true
总结：
八种包装类都是final修饰
一经创建，对象内容不可变
Character和Boolean的父类是Object其他六种的父类是Number类型,是抽象类.
Date
java.util.Date
封装了日期与时间的信息.之后里面的很多功能都弃用，渐渐的使用Calender类型来替代
构造器
Date()：
创建一个封装当前系统时间的Date对象
Date(long time)：
创建一个距离纪元time毫秒的Date对象
常用方法
long getTime();
返回距离纪元的毫秒数
void setTime(long time);
修改时间对象的毫秒数
示例代码:
import java.util.Date;
public class TestDate {
public static void main(String[] args) {
/*创建一个Date对象*/
Date time = new Date();
System.out.println(time);
/*调用有参构造器，创建一个距离纪元 10亿毫秒的时间对象*/
Date time1 = new Date(1520000000000L);
System.out.println(time1);
System.out.println(time.getTime());
System.out.println(time1.getTime());
time.setTime(time.getTime()-3600000*24);
System.out.println(time.getTime());
System.out.println(time);
}
}
运行结果:
Sun Aug 19 10:44:05 CST
Fri Mar 02 22:13:20 CST
1534646645478
1520000000000
1534560245478
Sat Aug 18 10:44:05 CST
SimpleDateFormat
作用
此类型可以对Date进行格式化,将字符串转成Date类型。
常用构造器
SimpleDateFormat(String format):
创建一个指定格式的SimpleDateFromat对象。
常用方法：
String format(Date date)
作用是将参数date按照构造器里的格式进行格式化成字符串
Date parse(String str)
作用是将指定字符串str转变成Date类型
常用格式:
yy/yyyy: 年
MM:月
dd:日
HH:时(24制)
hh:时(12制)
mm:分
ss:秒
a:上下午
E:星期
示例代码:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Tests {
public static void main(String[] args) {
/*转换成Date类型 Date parse(String str)*/
String birth="1996/08/28";
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy/MM/dd");
Date d= null;
/*需要用try...catch...进行处理.*/
try {
d = sdf1.parse(birth);
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(d);
/*格式化方法 String format(Date d)*/
Date now = new Date();
SimpleDateFormat sdf =
new SimpleDateFormat("MM-dd-yyyy HH:mm:ss E a");
String info = sdf.format(now);
System.out.println("时间："+info);
}
}
运行结果:
Wed Aug 28 00:00:00 CST 1996
时间：08-19- 11:22:11 星期日 上午
Calendar
1.是日历类型,此类型封装了有关日历的所有信息,主要用于计算时间分量(日期和时间的一部分有效值).
2.是一个抽象类,提供了一个方法叫getInstance(),来获取一个通用的子类型对象.一般都是GregorianCalendar(格里高利历法,阳 历),获取的时间是执行到此行代码的系统时间值.
3.时间分量常量
static int YEAR/MONTH/DATE;
关于MONTH:日历里的月份是0-11.
static int DAY_OF_WEEK/MONTH/YEAR;
关于DAY_OF_WEEK:默认一周第一天为周日,计数为1-7.
.........
常用方法
提供了get(int field),通过指定时间分量常量来获取相应的时间分量的值.
提供了set(int field,int value),进行设置时间分量值..提供了add(int field,int value),用于增加对当前日历信息通过时间分量计算value后的日历信息.若value为负值,则表示向前推算.
int getActualMaximum(int field):获取当前时间分量所在的最大值.如指定Calendar.MONTH,表示月的最大值(11).Calendar.DATE,表示当前日历对象所在月份的最大值(8月,31).
示例代码:
import java.util.Calendar;
public class Tests {
public static void main(String[] args) {
/*时间分量*/
/*首先获取当前时间*/
Calendar c=Calendar.getInstance();
/*输出当前时间*/
System.out.println(c.getTime());
/*分别输出时间分量的值*/
System.out.println("当前时间的YEAR的值:"+c.get(Calendar.YEAR));
System.out.println("当前时间的MONTH的值:"+c.get(Calendar.MONTH));
System.out.println("当前时间的星期的值:"+c.get(Calendar.DAY_OF_WEEK));
/*可以看到星期的计数从1开始,第一天是星期日*/
/*月的计数0开始,第一个月是一月.*/
System.out.println("当前时间的HOUR的值:"+c.get(Calendar.HOUR_OF_DAY));
/*设置时间分量*/
c.set(Calendar.YEAR,);
c.set(Calendar.MONTH,1);
c.set(Calendar.DAY_OF_MONTH,19);
System.out.println("设置后的时间为:"+c.getTime());
/*对传入的参数进行加减,传入正数为加,传入负数为减*/
c.add(Calendar.MONTH,2);
c.add(Calendar.DAY_OF_MONTH,-2);
System.out.println("加减后的时间为:"+c.getTime());
/*获取当前时间分量的最大值*/
/*注意当前时间为刚刚设置的四月*/
System.out.println("当前月的最大值为:"+c.getActualMaximum(Calendar.DAY_OF_MONTH));
}
}
运行结果:
Sun Aug 19 11:55:14 CST
当前时间的YEAR的值:
当前时间的MONTH的值:7
当前时间的星期的值:1
当前时间的HOUR的值:11
设置后的时间为:Tue Feb 19 11:55:14 CST
加减后的时间为:Wed Apr 17 11:55:14 CST
当前月的最大值为:30
