一、包装类
1、什么是包装类
以前定义变量，经常使用基本数据类型。
对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器。
将基本数据类型对应进行了一个封装，产生了一个新的类，就是包装类。
如：int，byte…-----> 基本数据类型；包装类 ------>引用数据类型
| 基本数据类型 | 对应包装类 | 继承关系 |
|---|---|---|
| byte | Byte | —>Number—>Object |
| short | Short | —>Number—>Object |
| int | Integer | —>Number—>Object |
| long | Long | —>Number—>Object |
| float | Float | —>Number—>Object |
| double | Double | Object |
| char | Character | Object |
| boolean | Boolean | Object |
2、为什么要使用包装类
- java语言作为一个面向对象的语言，最擅长的操作各种各样的类；
- 集合不像数组，只能装引用数据类型的数据，数组可以声明基本、引用数据类型的数组；
- 如：定义一个类的时候，就使用基本数据类型，使用集合时就使用包装类。
3、Integer
1）从属的包
java.lang ： 直接使用，无需导包
2）类的继承关系
java.lang.object
|_java.lang.Number
|_java.lang.Integer
3）实现接口
Serializable, Comparable<Integer>
4）final修饰
这个类被final修饰，这个类不能有子类，不能被继承
public final class Integer
extends Number
implements Comparable <Integer>
5）属性
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
}
结果：
6）构造器没有空参构造器
-
int类型作为构造器的参数
public static void main(String[] args) { Integer i1 = new Integer(12); System.out.println(i1.toString()); // 12 }public Integer(int value) { this.value = value; } -
string类型作为构造器参数
public static void main(String[] args) { Integer i1 = new Integer("12"); System.out.println(i1); // 12 }public Integer(String s) throws NumberFormatException { this.value = parseInt(s, 10); }
7）包装类特有机制
- 自动装箱
public static void main(String[] args) { // int --> Integer Integer i = 12; System.out.println(i); // 12 } - 自动拆箱
public static void main(String[] args) { // Integer --> int Integer i2 = new Integer(12); int num = i2; System.out.println(num); // 12 } - 将基本数据类型和包装类进行快速的转换。
8）常用方法
- compareTo()
- equals()
- intValue()
- parseInt()
- toString()
二、日期类
1、java.util.Date
public static void main(String[] args) {
Date date = new Date();
System.out.println(date); // Sat Aug 07 16:54:12 CST 2021
System.out.println(date.toString()); // Sat Aug 07 16:54:12 CST 2021
}
- 获取当前时间戳：System.currentTimeMillis()
2、java.sql.Date
public static void main(String[] args) {
Date date = new Date(1628337210683L);
System.out.println(date); // 2021-08-07
}
联系：
java.sql.Date（子类） extends java.util.Date（父类）
3、相互转换
1）util —> sql
public static void main(String[] args) {
java.util.Date date2 = new Date(1628337210683L);
//方式1：向下转型
Date date3 = (Date) date2;
//方式2：构造器
Date date4 = new Date(date2.getTime());
}
2）sql —> util
public static void main(String[] args) {
Date date = new Date(1628337210683L);
System.out.println(date);
java.util.Date date1 = date;
System.out.println(date1); // 2021-08-07
}
3）String —> sql.Date
public static void main(String[] args) {
Date date = Date.valueOf("2021-8-1");
}
4）String —> util
public static void main(String[] args) {
// string ---> java.sql.Date
java.sql.Date date = java.sql.Date.valueOf("2021-8-8");
// java.sql.date ---> java.util.Date
java.util.Date date1 = date;
System.out.println(date1.toString());
}
4、SimpleDateFormat
public static void main(String[] args) {
// 日期转换
// SimpleDateFormat（子类） extends DateFormat（父类是一个抽象类）
SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
// String ---> Date
try {
Date d = df.parse("2021/8/1 12:12:12");
System.out.println(d); // Sun Aug 01 12:12:12 CST 2021
} catch (ParseException e) {
e.printStackTrace();
}
// Date ---> String
String format = df.format(new Date());
System.out.println(format); // 2021/08/07 20:36:05
}
注意：parse和format可以完成String和Date之间的转换
三、Calendar类
1、常用方法
public static void main(String[] args) {
// Calendar是一个抽象类，不能直接创建对象,可以使用其子类
// GregorianCalendar()子类 extends Calendar() 抽象类
Calendar cal = new GregorianCalendar();
Calendar ca2 = Calendar.getInstance();
// System.out.println(cal);
// System.out.println(ca2);
// 常用方法
// get方法
System.out.println(cal.get(Calendar.YEAR)); // 2021
System.out.println(cal.get(Calendar.MONTH)); // 7 ,0 - 11
System.out.println(cal.get(Calendar.DATE)); // 7 ,1 - 31
System.out.println(cal.get(Calendar.DAY_OF_WEEK)); // 7 ,周日为第一天
System.out.println(cal.getActualMaximum(Calendar.DATE));// 获取当月日期的最大天数
System.out.println(cal.getActualMinimum(Calendar.DATE));// 获取当月日期的最小天数
// set方法
cal.set(Calendar.YEAR, 1990);
cal.set(Calendar.MONTH, 0);
cal.set(Calendar.DATE,1);
// System.out.println(cal);
// String ---> Calendar
// String ---> java.sql.Date
java.sql.Date date = java.sql.Date.valueOf("2020-8-5");
// java.sql.Date ---> Calendar
cal.setTime(date);
System.out.println(cal);
}
2、练习
请输入你要查看的日期：2021-1-1
日 一 二 三 四 五 六
1* 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31
答案：
public static void main(String[] args) {
// String ---> Calendar
Scanner scanner = new Scanner(System.in);
System.out.print("请输入你要查看的日期：");
String strDate = scanner.next();
// String ---> Date
java.sql.Date date = java.sql.Date.valueOf(strDate);
// Date ---> Calendar
Calendar cal = Calendar.getInstance();
cal.setTime(date);
// 星期提示
System.out.println("日\t一\t二\t三\t四\t五\t六");
int count = 0;
// 获取本月最大天数
int maxDay = cal.getActualMaximum(Calendar.DATE);
//获取当前日期中的日
int nowDate = cal.get(Calendar.DATE);
// 将日期调为本月1号
cal.set(Calendar.DATE,1);
// 获取1号是本月的第几天
int number = cal.get(Calendar.DAY_OF_WEEK);
for (int i = 1; i < number; i++) {
count ++;
System.out.print(" " + "\t");
}
for (int i = 1; i <= maxDay; i++) {
if (i == nowDate){
System.out.print(i + "*" + "\t");
} else {
System.out.print(i + "\t");
}
count++;
if (count % 7 == 0){
System.out.println();
}
}
}
3、LocalDate / LocalTime / LocalDateTime
public static void main(String[] args) {
// 1、完成实例化
// 方法一：now()
LocalDate localDate = LocalDate.now();
System.out.println(localDate); // 2021-08-08
LocalTime localTime = LocalTime.now();
System.out.println(localTime); // 00:26:04.040
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDateTime); // 2021-08-08T00:26:04.040
// 方法二：of()
LocalDate localDate1 = LocalDate.of(2021, 8, 11);
System.out.println(localDate1); // 2021-08-11
LocalTime localTime1 = LocalTime.of(8, 50, 55);
System.out.println(localTime1); // 08:50:55
LocalDateTime localDateTime1 = LocalDateTime.of(2021, 12, 11, 8, 12, 33);
System.out.println(localDateTime1); // 2021-12-11T08:12:33
System.out.println("================================================");
// 常用方法
// get
System.out.println(localDateTime.getYear()); // 2021
System.out.println(localDateTime.getMonth()); // AUGUST
System.out.println(localDateTime.getMonthValue()); // 8
System.out.println(localDateTime.getDayOfMonth()); // 8
System.out.println(localDateTime.getDayOfWeek()); // SUNDAY
System.out.println(localDateTime.getHour()); // 0
System.out.println(localDateTime.getMinute()); // 39
System.out.println(localDateTime.getSecond()); // 7
// 不是set方法，是with
LocalDateTime localDateTime2 = localDateTime.withMonth(6);
// 不会修改原本的时间，修改的是一个新的类
System.out.println(localDateTime); // 2021-08-08T00:43:46.262
System.out.println(localDateTime2); // 2021-06-08T00:43:46.262
// 除此之外还有很多with方法
//加减操作
LocalDateTime localDateTime3 = localDateTime.plusMonths(2);
System.out.println(localDateTime); // 2021-08-08T00:47:12.247
System.out.println(localDateTime3); // 2021-10-08T00:47:12.247
LocalDateTime localDateTime4 = localDateTime.minusMonths(5);
System.out.println(localDateTime); // 2021-08-08T00:48:45.562
System.out.println(localDateTime4); // 2021-03-08T00:48:45.562
}
4、格式化类
- 格式化类：DateTimeForMatter
public static void main(String[] args) { // 格式化类： DateTimeForMatter // 方式一：预定义的标准格式 不常用 DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME; // isoLocalDateTime可以帮我们完成LocalDateTime和String之间的相互转换 // LocalDateTime --->String LocalDateTime now = LocalDateTime.now(); String format = isoLocalDateTime.format(now); System.out.println(format); // String ---> LocalDateTime TemporalAccessor parse = isoLocalDateTime.parse("2021-08-08T00:54:43.137"); System.out.println(parse); // 方式二：本地化相关的格式 不常用 // FormatStyle.LONG: 2021年8月8日 上午01时00分58秒 // FormatStyle.MEDIUM: 2021-8-8 1:02:39 // FormatStyle.SHORT: 21-8-8 上午1:03 DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT); // LocalDateTime --->String LocalDateTime now1 = LocalDateTime.now(); String format1 = df.format(now1); System.out.println(format1); // String ---> LocalDateTime TemporalAccessor parse1 = df.parse("21-8-8 上午1:03"); System.out.println(parse1); // 方式三：自定义格式。如：ofPattern("yyyy-MM-dd hh:mm:ss") 常用 DateTimeFormatter df2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"); // LocalDateTime --->String LocalDateTime now2 = LocalDateTime.now(); String format2 = df2.format(now2); System.out.println(format2); // 2021-08-08 01:10:28 // String ---> LocalDateTime TemporalAccessor parse2 = df2.parse("2021-08-08 01:10:28"); System.out.println(parse2); }
四、Math类
- 直接使用，无需导包。java.lang;
- final修饰类，不能被继承；
- 构造器私有化，不能创建按Math类对象；
- Math内部所有的属性，方法都被static修饰，故：类名.方法名，直接调用，无需创建对象；
public static void main(String[] args) { // 常用属性： System.out.println(Math.PI); // 常用方法： System.out.println(Math.random()); System.out.println(Math.abs(-99)); // 99 // 向上取整 System.out.println(Math.ceil(8.8)); // 9.0 // 向下取整 System.out.println(Math.floor(8.8)); // 8.0 // 四舍五入 System.out.println(Math.round(5.6)); // 6 System.out.println(Math.max(3, 6)); // 6 System.out.println(Math.min(1, 4)); // 1 } - Random类
注：Math.random()底层也是调Random类实现的public static void main(String[] args) { // 利用带参数的构造器创建对象，不常用 Random random = new Random(System.currentTimeMillis()); System.out.println(random.nextInt()); // 利用空参构造器创造对象，表面是在调用无参构造器，实际还是在调有参 Random random1 = new Random(); System.out.println(random1.nextInt(10)); // 0 - 10之间的随机数 System.out.println(random1.nextDouble()); // 0.0 - 1.0 之间的随机数 }
五、String类
- 直接使用，无需导包。java.lang;
- 字符串不可变
- String类不可被继承，不能有子类
- String底层是一个char类型的数组
1、常用方法
- 通过构造器创建对象
// 通过构造器创建对象 String str1 = new String(); String str2 = new String("abc"); String str3 = new String(new char[]{'a', 'b', 'c'}); - 字符串长度
// 字符串长度 System.out.println(str2.length()); // 3 - 字符串是否为空
// 字符串是否为空 System.out.println(str1.isEmpty()); // true System.out.println(str3.isEmpty()); // false - 得到字符串对应字符
// 得到字符串对应字符 System.out.println(str2.charAt(2)); // c - 字符串比对，equals()、compareTo()
System.out.println(str2 == str3); // false System.out.println(str2.equals(str3)); // true System.out.println(str2.compareTo(str3)); // 0,字符串相同 String str4 = new String("abcdef"); System.out.println(str2.compareTo(str4)); // -3,长度的差值 String str5 = new String("accdef"); System.out.println(str2.compareTo(str5)); // -1,返回的是不一样的那个位的ASCII码的差值 - 字符串截取
String str1 = "abcDEFGHgkl"; System.out.println(str1.substring(3)); System.out.println(str1.substring(3, 6)); // DEF,[3, 6) - 字符串拼接
System.out.println(str1.concat("aaaaa")); // abcDEFGHgklaaaaa - 字符串替换
String str2 = "abcDEaGHgal"; System.out.println(str2.replace('a', 'b')); // bbcDEbGHgbl - 按照置顶的字符串分裂为数组的形式
String str3 = "a-b-c-D-E-a-G"; String[] split = str3.split("-"); System.out.println(Arrays.toString(split)); // [a, b, c, D, E, a, G] - 转为大小写
String str4 = "abcDEaGHgal"; System.out.println(str4.toUpperCase()); // ABCDEAGHGAL System.out.println(str4.toLowerCase()); // abcdeaghgal - 去除前后空格 重要
String str5 = " a bc D "; System.out.println(str5.trim()); // a bc D - 转换为String类型
System.out.println(String.valueOf(true)); // "true"
2、String内存分析
1）无变量参与的字符串拼接
public static void main(String[] args) {
String s1 = "a" + "b" + "c";
String s2 = "ab" + "c";
String s3 = "a" + "bc";
String s4 = "abc";
String s5 = "abc" + "";
}
以上字符串，会进行编辑器优化，直接合并成为完整的字符串，然后再常量池中，常量池的一大特点就是第一次如果没有这个字符串，就放进去，如果有这个字符串，就直接从常量池中取。
如果是 String s6 = new String(“abc”)；，内存会在堆中开辟控件，其实底层value数组也是指向字符串常量池的“abc“
3）有变量参与的字符串拼接
String a = "abc";
String b = a + "def";
System.out.println(b);
a变量再编译的时候不知道a是”abc“字符串，所以不会进行编辑器优化，不会直接合并为”abcdef“
3、字符串分类
- 不可变字符串：String
- 可变字符串：StringBuilder、StringBuffer
1）StringBuilder与StringBuffer
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
public static void main(String args[]){
StringBuilder sb = new StringBuilder(10);
sb.append("hello..");
System.out.println(sb); // hello..
sb.append("!");
System.out.println(sb); // hello..!
sb.insert(7, "Java");
System.out.println(sb); // hello..Java!
sb.delete(5,7);
System.out.println(sb); // helloJava!
}
2）常用方法
- 主要方法
- 以及其他常用方法
StringBuilder：效率高，线程不安全
StringBuffer：效率低，线程安全
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
