常用类
1、包装类
1.1、概述：
Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。比如：将基本数据类型存储到Object[]数组或集合中的操作等等。 为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。
public class WrapperClassTest {
public static void main(String[] args) {
Integer i = new Integer(10);
Integer j = new Integer(50);
}
}
1.2、包装类的用途
1. 作为和基本数据类型对应的类型存在，方便涉及到对象的操作，如Object[]、集合等的操作。
2. 包含每种基本数据类型的相关属性如最大值、最小值等（可以通过对象中的属性和行为操作基本数据类型），以及相关的操作方法(这些操作方法的作用是在基本数据类型和字符串之间相互之间的转化!)。
1、可以用这些对象中的属性和行为操作基本数据类型，可以实现基本类型和字符串之间的转换。
使用：
public class Test {
/** 测试Integer的用法，其他包装类与Integer类似 */
void testInteger() {
// 基本类型转化成Integer对象
Integer int1 = new Integer(10);
Integer int2 = Integer.valueOf(20); // 官方推荐这种写法
// Integer对象转化成int
int a = int1.intValue();
// 字符串转化成Integer对象
Integer int3 = Integer.parseInt("334");
Integer int4 = new Integer("999");
// Integer对象转化成字符串
String str1 = int3.toString();
// 一些常见int类型相关的常量
System.out.println("int能表示的最大整数：" + Integer.MAX_VALUE);
}
public static void main(String[] args) {
Test test = new Test();
test.testInteger();
}
}
1.3、自动装箱和拆箱
int j = new Integer(100);
java装箱过程是调用包装类的valueOf方法实现的，而拆箱过程则是调用包装类的xxxValue方法实现的（xxx代表对应的基本类型）
1.4、包装类的缓存问题
整型（byte、short、int、long）、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理，其目的是提高效率。
public class TestBzl {
public static void main(String[] args) {
Integer i1=127;
Integer i2=127;
System.out.println(i1==i2);
Integer I3=134;
Integer I4=134;
System.out.println(I3==I4);
}
}2、String 类
2.1、String 类：
String 类对象代表不可变的Unicode字符序列，因此我们可以将String对象称为“不可 变对象”。
为什么它是不可变的字符序列呢？
我们发现字符串内容全部存储到value[]数组中，而变量value是final修饰的，也就是常量(即只能被赋值一次)。 这就是“不可变对象”的典型定义方式。
2.2、StringBuffer和StringBuilder
StringBuffer和StringBuilder非常类似，均代表可变的字符序列。 这两个类都是抽象类AbstractStringBuilder的子类，方法几乎一模一样。
abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
char value[];
//以下代码省略
}显然，内部也是一个字符数组，但这个字符数组没有用final修饰，随时可以修改。因此，StringBuilder和StringBuffer称之为“可变字符序列”。
2.2.1、StringBuffer和StringBuilder的区别
1. 重载的public StringBuilder append(…)方法
可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。
2. 方法 public StringBuilder delete(int start,int end)
可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。
3. 方法 public StringBuilder deleteCharAt(int index)
4. 重载的public StringBuilder insert(…)方法
可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。
5. 方法 public StringBuilder reverse()
public int indexOf(String str)
public int indexOf(String str,int fromIndex)
public String substring(int start)
public String substring(int start,int end)
public int length()
char charAt(int index)2.3、不可变和可变字符序列使用陷阱
String一经初始化后，就不会再改变其内容了。对String字符串的操作实际上是对其副本(原始拷贝)的操作，原来的字符串一点都没有改变。比如：
s = s+"b"; 实际上原来的"a"字符串对象已经丢弃了，现在又产生了另一个字符串s+"b"(也就是"ab")。 如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的时间和空间性能，甚至会造成服务器的崩溃。
相反，StringBuilder和StringBuffer类是对原字符串本身操作的，可以对字符串进行修改而不产生副本拷贝或者产生少量的副本。因此可以在循环中使用。
2.3.2、String和StringBuilder在频繁字符串修改时效率测试
public abstract class TestString {
public static void main(String[] args) {
String str="";
long num1=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
long time1=System.currentTimeMillis();//获取系统的当前时间
for (int i = 0; i < 6000; i++) {
str+=i;
}
long num2=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
long time2=System.currentTimeMillis();//获取系统的当前时间
System.out.println("String 占用内存："+(num1-num2));
System.out.println("String 占用时间："+(time2-time1));
//
StringBuilder builder=new StringBuilder();
long num3=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
long time3=System.currentTimeMillis();//获取系统的当前时间
for (int i = 0; i < 6000; i++) {
builder.append(i);
}
long num4=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
long time4=System.currentTimeMillis();//获取系统的当前时间
System.out.println("StringBuilder 占用内存："+(num3-num4));
System.out.println("StringBuilder 占用时间："+(time4-time3));
}
}结果：
3、时间类 （datetime）
我们用long类型的变量来表示时间，从基准时间往前几亿年，往后几亿年都能表示。如果想获得现在时刻的“时刻数值”，可以使用：
3.1、Date时间类(java.util.Date)
| 构造器 | 说明 |
| Date() | 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。 |
Date(long date) | 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。 |
| 返回值 | 方法（形参） | 说明 |
| boolean | after(Date when) | 测试此日期是否在指定日期之后。 |
| boolean | before(Date when) | 测试此日期是否在指定日期之前。 |
| Object | clone() | 返回此对象的副本。 |
| int | compareTo(Date anotherDate) | 比较两个日期的顺序。 |
| boolean | equals(Object obj) | 比较两个日期的相等性。 |
| long | getTime() | 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 |
| void | setTime(long time) | 设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。 |
3.2、DateFormat类和SimpleDateFormat类
将时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。
DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现。
public class TestTime {
public static void main(String[] args) {
Date date=new Date();
SimpleDateFormat s1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
// 将时间对象转换成字符串
String daytime = s1.format(date);
System.out.println(daytime);
}
}结果：
代码中的格式化字符的具体：
时间格式字符的使用：
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDateFormat2 {
public static void main(String[] args) {
SimpleDateFormat s1 = new SimpleDateFormat("D");
String daytime = s1.format(new Date());
System.out.println(daytime);
}
}
3.3、Calendar日历类
Calendar 类是一个抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。
GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。
注意：注意月份的表示，一月是0，二月是1，以此类推，12月是11。
public class TestCalendar {
public static void main(String[] args) {
GregorianCalendar calendar=new GregorianCalendar();
//获取日期
int year=calendar.get(Calendar.YEAR);//获取年份 或者用1
int month=calendar.get(Calendar.MONTH)+1;//月份是从0开始的 或者用2
int day = calendar.get(Calendar.DAY_OF_MONTH); // 获取当前天数 或者用5
int day2 = calendar.get(Calendar.DATE); // 获取当前天数 或者用5
int week=calendar.get(Calendar.DAY_OF_WEEK);//获取星期几 或者用7/4
printCalendar(calendar);
// 星期几 这里是：1-7.周日是1，周一是2，。。。周六是7
//设置日期
GregorianCalendar calendar2=new GregorianCalendar();
calendar2.set(Calendar.YEAR, 2000);
calendar2.set(Calendar.MONTH, 10);
calendar2.set(Calendar.DATE, 3);
calendar2.set(Calendar.HOUR_OF_DAY, 10);
calendar2.set(Calendar.MINUTE, 20);
calendar2.set(Calendar.SECOND, 23);
printCalendar(calendar2);
//日期计算
GregorianCalendar calendar3=new GregorianCalendar();
calendar3.add(Calendar.MONTH, -7); // 月份减7
calendar3.add(Calendar.DATE, 7); // 增加7天
printCalendar(calendar3);
// 日历对象和时间对象转化
//Calendar--->date
Date d=calendar3.getTime();
//date--->Calendar
GregorianCalendar calendar4 = new GregorianCalendar();
calendar4.setTime(new Date());
}
public static void printCalendar(Calendar calendar) {
String[] str= {"日","一","二","三","四","五","六"};
int year=calendar.get(Calendar.YEAR);
int month=calendar.get(Calendar.MONTH)+1;
int day=calendar.get(Calendar.DAY_OF_MONTH);
int date=calendar.get(Calendar.DAY_OF_WEEK);
int hour=calendar.get(Calendar.HOUR);
String week = str[date-1];
int minute=calendar.get(Calendar.MINUTE);
int second=calendar.get(Calendar.SECOND);
System.out.printf("%d年%d月%d日,星期%s %d:%d:%d\n", year, month,
day,week, hour, minute, second);
}
}public class TestCalendar2 {
public static void main(String[] args) {
System.out.println("请输入日期 (格式为：2010-3-3)：");
Scanner scanner=new Scanner(System.in);
String date=scanner.next();
// 将输入的字符串转化成日期类
System.out.println("您刚刚输入的日期是：" + date);
String[] str = date.split("-");
int year=Integer.valueOf(str[0]);
int month=Integer.valueOf(str[1])-1;
int day=Integer.valueOf(str[2]);
Calendar c = new GregorianCalendar(year,month,day);
int maxDate = c.getActualMaximum(Calendar.DATE);
System.out.println("一\t二\t三\t四\t五\t六\t日\n");
for (int i = 1; i <=maxDate; i++) {
if(day==i) {
System.out.print(i+"㊣\t");
}else {
System.out.print(i+"\t");
}
if(i%7==0) {
System.out.println("\n");
}
}
}
}4、Math 类
4.1、Math类的常用方法：
2. acos,asin,atan,cos,sin,tan 三角函数
4. pow(double a, double b) a的b次幂
5. max(double a, double b) 取大值
6. min(double a, double b) 取小值
10. long round(double a) double型的数据a转换为long型(四舍五入)
public class TestMath {
public static void main(String[] args) {
//取整相关操作
System.out.println(Math.ceil(3.2));
System.out.println(Math.floor(3.2));
System.out.println(Math.round(3.2));
System.out.println(Math.round(3.8));
//绝对值、开方、a的b次幂等操作
System.out.println(Math.abs(-45));
System.out.println(Math.sqrt(64));
System.out.println(Math.pow(5, 2));
System.out.println(Math.pow(2, 5));
//Math类中常用的常量
System.out.println(Math.PI);
System.out.println(Math.E);
//随机数
System.out.println(Math.random());// [0,1)
}
}4.2、Random类的常用方法
import java.util.Random;
public class TestRandom {
public static void main(String[] args) {
Random rand = new Random();
//随机生成[0,1)之间的double类型的数据
System.out.println(rand.nextDouble());
//随机生成int类型允许范围之内的整型数据
System.out.println(rand.nextInt());
//随机生成[0,1)之间的float类型的数据
System.out.println(rand.nextFloat());
//随机生成false或者true
System.out.println(rand.nextBoolean());
//随机生成[0,10)之间的int类型的数据
System.out.print(rand.nextInt(10));
//随机生成[20,30)之间的int类型的数据
System.out.print(20 + rand.nextInt(10));
//随机生成[20,30)之间的int类型的数据（此种方法计算较为复杂）
System.out.print(20 + (int) (rand.nextDouble() * 10));
}
}5、File类的基本用法
java.io.File类：代表文件和目录。 在开发中，创建文件、读取文件、生成文件、删除文件、修改文件的属性时经常会用到本类。
5.1、创建文件
public abstract class TestFile {
public static void main(String[] args) throws IOException {
//创建文件
System.out.println(System.getProperty("user.dir"));
File f = new File("a.txt"); //相对路径：默认放到user.dir目录下面
f.createNewFile();
//测试File类访问属性的基本用法
}
}5.2、通过File对象可以访问文件的属性：
//测试File类访问属性的基本用法
//时间格式化
SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
File f=new File("a.txt");
System.out.println("File是否存在："+f.exists());
System.out.println("File是否是目录："+f.isDirectory());
System.out.println("File是否是文件："+f.isFile());
System.out.println("File最后修改时间："
+ format.format(new Date(f.lastModified())));
System.out.println("File的大小："+f.length()+"KB");
System.out.println("File的文件名："+f.getName());
System.out.println("File的目录："+f.getPath());5.3、通过File对象创建空文件或目录
File file=new File("text.txt");
f.createNewFile();//创建文件
boolean flag=file.mkdir();//创建目录6、枚举
6.1、JDK1.5引入了枚举类型。枚举类型的定义包括枚举声明和枚举体。
6.2、创建枚举
enum Season { SPRING, SUMMER, AUTUMN, WINDER }所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类!而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final修饰的。可以直接通过枚举类型名使用它们。
2. 尽量不要使用枚举的高级特性，事实上高级特性都可以使用普通类来实现，没有必要引入枚举，增加程序的复杂性!
public class TestEnum {
public static void main(String[] args) {
System.out.println("以下是所有奶茶的价格：");
for (Tea t: Tea.values()) {
System.out.println(t+"："+"\t小杯 "+t.getPrice()+"元"
+"\t中杯 "+(int)(t.getPrice()*1.5)+"元"
+"\t大杯 "+(int)(t.getPrice()*2)+"元");
}
}
}
enum Tea{
普通奶茶(6),天空之城(12),双皮奶(8);
private int price;
Tea(int p){
price=p;
}
int getPrice(){
return price;
}
}结果图：
扫一扫
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
