Java常用类
基本数据类型的包装类
Java是面向对象的语言，但并不是“完全面向对象”的，如基本数据类型就不是对象。Java中的基本数据类型没有方法和属性，而包装类就是为了让这些拥有方法和属性，实现对象化交互。如：将数据类型存储到Object[]数组或集合中的操作等等。 为了解决不足，java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的统称为包装类（Wrapper Class）。
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| boolean | Boolean |
| short | Short |
| char | Character |
| int | Integer |
| long | Long |
| folat | Folat |
| double | Double |
数值型包装类都继承至Number，而字符型和布尔型继承至Object。
基本数据和包装类之间的转换
装箱：基本数据类型转换为包装类；拆箱：包装类转换为基本数据类型。包装类对象的初始值为null（是一个对象）。
public class WrapperDemo1 {
public static void main(String[] args){
//1.自动装箱
int t1=1;
Integer t2=t1;
//2.手动装箱
Integer t3=new Integer(t1);
System.out.println("int类型t1="+t1);
System.out.println("自动装箱，Integer类型对象t2="+t2);
System.out.println("手动装箱，Integer类型t3="+t3);
//1.自动拆箱
int t4=t2;
//2.手动拆箱
//通过intValue()方法返回int值，还可以利用其他方法装换为其他类型
int t5=t2.intValue();
System.out.println("自动拆箱,int型t4="+t4);
System.out.println("手动拆箱,int型t5="+t5);
}
}
基本数据类型和包装类的转换
Integer.toString(): 将整型转换为字符串。Integer.parseInt(): 将字符串转换为int类型。valueOf(): 把字符串转换为包装类然后通过自动拆箱。
public class WrapperDemo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//基本数据类型转换为字符串
int t1=12;
String t2=Integer.toString(t1);
System.out.println("int转换为String："+t2);
//字符串转换为基本数据类型
//通过paerInt方法
int t3=Integer.parseInt(t2);
//通过valeOf,先把字符串转换为包装类然后通过自动拆箱
int t4=Integer.valueOf(t2);
System.out.println("t3:"+t3);
System.out.println("t4:"+t4);
}
}
Java为了提高拆装箱效率，在执行过程中提供了一个缓存区（对象池）【类似于常量数组】，如果传入的参数是，-128<参数<127会直接去缓存查找数据，如果有久直接产生，如果没有就隐式调用new方法产生。
包装类的比较
public boolean equals(Object anObject): 如果给定对象与字符串相等，则返回 true；否则返回 false。
public interface Comparator: 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。包装类实现了此接口。
public int compareTo( NumberSubClass referenceName ): 该方法用于将 Number及其子类的对象与方法的参数进行比较，两个不同类型的数据不能用此方法来比较。 参数referenceName可以是一个 Byte, Double, Integer, Float, Long 或 Short 类型的参数。
| a.compareTo(b) | 返回值 | 排序 |
|---|---|---|
| a < b | 负整数 | 升序 |
| a = b | 0 | 不变 |
| a > b | 正整数 | 降序 |
public class WrapperDemo3 {
public static void main(String[] args) {
//简写
Integer i2 = 20;
Integer i3 = 10;
System.out.println(i2.equals(i3));
System.out.println(i2.compareTo(i3));
/*打印：
false
1 */
}
}
java.lang.String 类
String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。String类对象创建后不能修改，赋值后将会生成新的对像来存放新的内容，原先的对象依旧在内存中，但是s不在指向它，那么这个对象就会成为垃圾内存，在某一个特定的时刻有Java虚拟机回收。
String字符串变量的创建：
- 声明：String 变量名;
- 声明并初始化：String 变量名="初始值";
String str;
String str = "字符串";
String常用方法：
int length(): 返回值为 int 类型。得到一个字符串的字符个数（中、英、空格、转义字符皆为一个字符，计入长度）
String a="矜君99 \t\n";
int l = a.length();
System.out.println(l);
//打印：7
char charAt(int index): 返回值为 char 类型。从字符串中取出指定位置的字符
String str="矜君99";
char c = str.charAt(2);
System.out.println("指定字符为：" + c); //打印：指定字符为：9
char toCharArray(): 返回值为 char 数组类型。将字符串变成一个字符数组
String str="矜君99";
char c[] = str.toCharArray();
for (int i = 0; i < c.length; i++){
System.out.print(c[i]);
}//打印：矜君99
int indexOf(String str): 返回指定子字符串第一次出现的字符串内的索引。int indexOf(String str, int fromIndex): 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
public static void main(String[] args) {
String a="等什么君唱了什么新歌";
int i1 = a.indexOf("什");
int i2 = a.indexOf("么",3);
System.out.print(i1+" "+i2);
}//打印：1 7
String substring(int beginIndex,int endIndex): 返回一个字符串，该字符串是此字符串的子字符串。
public static void main(String[] args) {
String a = "等什么君唱了什么新歌";
String b = a.substring(1,3);
System.out.print(b);
}//打印：什么
boolean startsWith(String): 测试此字符串是否以指定的前缀开始，返回一个布尔值。boolean endsWith(String): 测试此字符串是否以指定的后缀结束，返回一个布尔值。
public static void main(String[] args) {
String a = "等什么君唱了什么新歌";
boolean b1 = a.startsWith("等");
boolean b2 = a.endsWith("歌");
System.out.print(b1+" "+b2);
}//打印：true true
java.util.Scanner 类
简单的文本扫描器,可以使用正则表达式解析原始类型和字符串,可以通过该类获取用户输入。
Scanner 类构造方法
Scanner(File source): 使用文件类对象构造扫描器。Scanner(InputStream source): 使用输入流对象构造扫描器。Scanner(Path source): 使用指定路径文件构造扫描器。
Scanner 类常用方法
void close(): 关闭扫描器。boolean hasNextXxx(): Xxx可以是Double,Byte,Int等，判断下一个输入项是否是Xxx。boolean hasNext(): 判断是否有下一个输入项。String nextLine(): 获取下一行字符串,包含回车。Xxx nextXxx(): 获取下一个输入,不包含回车。
import java.util.Scanner;
public class Demo1 {
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
//通过标准输入流构造Scanner
System.out.println("Please input an integer!");
if(sc.hasNextInt())//如果如果是Int数打印该数字
System.out.println("The number is "+sc.nextInt());
else//如果不是打印错误信息
System.out.println("Input error!");
}
}
java.lang.Math 类
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
public static int abs(int a): 求绝对值 。public static double ceil(double a): 向上取整 。public static double floor(double a): 向下取整 。public static int max(int a,int b): 返回二者较大值。public static double pow(double a,double b): 返回a的b次方。public static double random(): 生成0~1之间的随机小数 。public static int round(float a): 四舍五入为整数 。public static double sqrt(double a): 开方运算。
public class MathDemo {
public static void main(String[] args) {
System.out.println(Math.abs(-12.7));
System.out.println(Math.ceil(12.7));
System.out.println(Math.rint(12.4));
System.out.println(Math.random());
System.out.println("sin30 = " + Math.sin(Math.PI / 6));
// 计算30°的正弦值，参数是用弧度表示的角，即π的六分之一
System.out.println("cos30 = " + Math.cos(Math.PI / 6));
// 计算30°的余弦值，这些计算三角函数的方法，其参数和返回值的类型都为double
System.out.println("tan30 = " + Math.tan(Math.PI / 6));
// 计算30°的正切值
}
}/*打印：
$ javac MathDemo.java
$ java MathDemo
12.7
13.0
12.0
0.8011998172263968
sin30 = 0.49999999999999994
cos30 = 0.8660254037844387
tan30 = 0.5773502691896257 */
java.util.Random类
用于产生随机数,可以设置种子。
构造方法
public Random(): 以当前时间为种子。public Random(long seed): 指定种子。
常用方法
public int nextInt(): 返回一个int数。public int nextDouble(): 返回一个Double数。public int nextInt(int n): 返回一个数t,0<=t
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
Random random = new Random();
//随机生成一个整数 int范围
System.out.println(random.nextInt());
//生成 [0,n] 范围的整数 设n=100
System.out.println(random.nextInt(100 + 1));
//生成 [0,n) 范围的整数 设n=100
System.out.println(random.nextInt(100));
//生成 [m,n] 范围的整数 设n=100 m=40
System.out.println((random.nextInt(100 - 40 + 1) + 40));
//随机生成一个整数 long范围
System.out.print(random.nextLong());
//生成[0,1.0)范围的float型小数
System.out.println(random.nextFloat());
//生成[0,1.0)范围的double型小数
System.out.println(random.nextDouble());
}
}/*打印：
677177918
28
14
88
-42585247394659156490.79453605
0.1549074727290829 */
java.lang.System类
System 类提供了以下功能：
- 标准输入，标准输出和错误输出流；
- 访问外部定义的属性和环境变量；
- 加载文件和库的方法；
- 以及用于快速复制数组的实用方法。
System 类不能被实例化，只可以使用其静态方法。
常用方法
public static void arraycopy(Object src,int srcPos, Object dest,int desPos,int length): 从指定的源数组中复制一个数组，从源数组指定的位置开始，到目标数组指定的位置 。public static long currentTimeMillis(): 返回以毫秒为单位的当前时间(从1970年到现在的毫秒数)。public static void exit(int status): 终止当前正在运行的Java虚拟机，status为 0时退出。public static void gc(): 运行垃圾收集器。public static Properties getProperties(): 取得当前系统的全部属性。public static String getProperty(String key): 获取指定键的系统属性。
import java.util.Arrays;
public class SystemDemo {
public static void main(String[] args) {
int[] a = {7, 8, 9, 10, 11};
int[] b = {1, 2, 3, 4, 5, 6};
//从数组a的第二个元素开始，复制到b数组的第三个位置 复制的元素长度为3
System.arraycopy(a, 1, b, 2, 3);
//输出结果
System.out.println(Arrays.toString(b));
System.out.println("当前时间：" + System.currentTimeMillis());
System.out.println("java版本信息：" + System.getProperty("java.version"));
//运行垃圾收集器
System.gc();
//退出
System.exit(0);
}
}/* 打印：
[1, 2, 8, 9, 10, 6]
当前时间：1544670501472 */
java.util.Arrays类
Arrays 类包含用于操作数组的各种方法（例如排序和搜索）。还包含一个静态工厂，允许将数组转为 List。
常用方法
List asList(T... a): 返回由指定数组构造的 List 。void sort(Object[] a): 对数组进行排序void fill(Object[] a, Object val): 为数组的所有元素都赋上相同的值boolean equals(Object[] a, Object[] a2): 检查两个数组是否相等int binarySearch(Object[] a, Object key): 对排序后的数组使用二分法查找数据
import java.util.Arrays;
import java.util.Random;
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = new int[10];
//将数组元素都设为9
Arrays.fill(arr, 9);
System.out.println("fill:" + Arrays.toString(arr));
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
//使用100以内的随机数赋值数组
arr[i] = random.nextInt(101);
}
//重新赋值后的数组
System.out.println("重新赋值：" + Arrays.toString(arr));
//将索引为5的元素设为50
arr[5] = 50;
//排序
Arrays.sort(arr);
//排序后的数组
System.out.println("sort排序后：" + Arrays.toString(arr));
//查找50的位置
int i = Arrays.binarySearch(arr, 50);
System.out.println("值为50的元素索引："+i);
//复制一份新数组
int[] newArr = Arrays.copyOf(arr, arr.length);
//比较
System.out.println("equals:"+Arrays.equals(arr, newArr));
}
}/* 打印：
fill:[9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
重新赋值：[2, 19, 48, 40, 95, 72, 69, 18, 12, 51]
sort排序后：[2, 12, 18, 19, 40, 48, 50, 51, 69, 95]
值为50的元素索引：6
equals:true */
java.util.Date类
Date 类表示日期和时间，里面封装了操作日期和时间的方法。Date 类经常用来获取系统当前时间。
构造方法
Date(): 构造一个 Date 对象并对其进行初始化以反映当前时间Date(long date): 构造一个 Date 对象，并根据相对于 GMT 1970 年 1 月 1 日 00:00:00 的毫秒数对其进行初始化
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
String strDate, strTime;
Date objDate = new Date();
System.out.println("今天的日期是：" + objDate);
long time = objDate.getTime();
System.out.println("自1970年1月1日起以毫秒为单位的时间（GMT）：" + time);
strDate = objDate.toString();
//提取 GMT 时间
strTime = strDate.substring(11, (strDate.length() - 4));
//按小时、分钟和秒提取时间
strTime = "时间：" + strTime.substring(0, 8);
System.out.println(strTime);
//格式化时间
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(formatter.format(objDate));
}
}/*
打印：
今天的日期是：Wed Dec 12 14:43:15 CST 2018
自1970年1月1日起以毫秒为单位的时间（GMT）：1544596995669
时间：14:43:15
2018-12-12 14:43:15
*/
Date 类的很多方法自 JDK 1.1 开始就已经过时了。
java.util.Calendar类
在早期的 JDK 版本中，Date 类附有两大功能：
- 允许用年、月、日、时、分、秒来解释日期。
- 允许对表示日期的字符串进行格式化和句法分析。
在 JDK1.1 中提供了 Calendar 类来完成第一种功能，DateFormat类来完成第二项功能。DateFormat 是 java.text 包中的一个类。与 Date 类有所不同的是，DateFormat 类可以接受用各种语言和不同习惯表示的日期字符串。
Calendar 类是一个抽象类，它完成 Date 类与普通日期表示法之间的转换，而我们更多的是使用 Calendar 类的子类 GregorianCalendar 类。它实现了世界上普遍使用的公历系统。当然我们也可以继承 Calendar 类，然后自己定义实现日历方法。
GregorianCalendar 类的构造方法
| 构造方法 | 说明 |
|---|---|
| GregorianCalendar() | 创建的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间 |
| GregorianCalendar(TimeZone zone) | 创建的对象中的相关值被设置成指定时区 zone，缺省地点的当前时间 |
| GregorianCalendar(Locale aLocale) | 创建的对象中的相关值被设置成缺省时区，指定地点 aLocale 的当前时间 |
| GregorianCalendar(TimeZone zone,Locale aLocale) | year - 创建的对象中的相关值被设置成指定时区，指定地点的当前时间 |
(突然发现用表格写方法更加方便，前面的以后有空再改成表格)
TimeZone 是 java.util包中的一个类，其中封装了有关时区的信息。每一个时区对应一组 ID。类 TimeZone 提供了一些方法完成时区与对应 ID 两者之间的转换。
例如：
//太平洋时区的 ID 为 PST
TimeZone tz0 = TimeZone.getTimeZone("PST")
//getDefault()可以获取主机所处时区的对象
TimeZone tz1 = TimeZone.getDefault()
Locale 只是一种机制，它用来标识一个特定的地理、政治或文化区域获取一个 Locale 对象的构造方法：
//调用Locale类的构造方法
Locale l0 = new Locale(String language)
Locale l1 = new Locale(String language, String country)
Locale l2 = new Locale(String languge, String country, String variant)
//调用Locale类中定义的常量
Locale l1 = Locale.CHINA
实例：
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class CalendarDemo {
public static void main(String[] args) {
System.out.println("完整显示日期时间：");
// 字符串转换日期格式
DateFormat fdate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = fdate.format(new Date());
System.out.println(str);
// 创建 Calendar 对象
Calendar calendar = Calendar.getInstance();
// 初始化 Calendar 对象，但并不必要，除非需要重置时间
calendar.setTime(new Date());
// 显示年份
System.out.println("年： " + calendar.get(Calendar.YEAR));
// 显示月份 (从0开始, 实际显示要加一)
System.out.println("月： " + calendar.get(Calendar.MONTH));
// 当前分钟数
System.out.println("分钟： " + calendar.get(Calendar.MINUTE));
// 今年的第 N 天
System.out.println("今年的第 " + calendar.get(Calendar.DAY_OF_YEAR) + "天");
// 本月第 N 天
System.out.println("本月的第 " + calendar.get(Calendar.DAY_OF_MONTH) + "天");
// 3小时以后
calendar.add(Calendar.HOUR_OF_DAY, 3);
System.out.println("三小时以后的时间： " + calendar.getTime());
// 格式化显示
str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
System.out.println(str);
// 重置 Calendar 显示当前时间
calendar.setTime(new Date());
str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
System.out.println(str);
// 创建一个 Calendar 用于比较时间
Calendar calendarNew = Calendar.getInstance();
// 设定为 5 小时以前，后者大，显示 -1
calendarNew.add(Calendar.HOUR, -5);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
// 设定7小时以后，前者大，显示 1
calendarNew.add(Calendar.HOUR, +7);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
// 退回 2 小时，时间相同，显示0
calendarNew.add(Calendar.HOUR, -2);
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
// calendarNew创建时间点
System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendarNew.getTime()));
// calendar创建时间点
System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime()));
System.out.println("时间比较：" + calendarNew.compareTo(calendar));
}
}/*
打印：
完整显示日期时间：
2020-06-07 12:01:42
年： 2020
月： 5
分钟： 1
今年的第 159天
本月的第 7天
三小时以后的时间： Sun Jun 07 15:01:42 UTC 2020
2020-06-07 15:01:42:819
2020-06-07 12:01:42:823
时间比较：-1
时间比较：1
时间比较：0
2020-06-07 12:01:42:823
2020-06-07 12:01:42:823
时间比较：0
*/
注意：这里会涉及到 calendarNew 与 calendar 的创建时间点，calendarNew 经过增加和减少时间后恢复到原来的时间点，也就是最终比较的是谁先创建好，时间点靠后的大一些，而 calendarNew 创建的时间点只有可能是大于等于 calendar 的，需要根据实际的创建时间点进行比较。
