12.15 Java基础13
- 昨日知识点回顾
//Object ->java.lang包中
Object obj = new Object();
obj.equals(obj);// this == obj 比较对象是否相等 （在子类中重写hashCode和equals的方法）
obj.hashCode();//哈希码--唯一性
obj.toString();//返回值一个包名+类名+@+hex(hascode)，不是单纯地将对象转化为字符串
//Math ->java.lang包中.
//Math 静态的方法 类名.方法名
//Random ->java.util包中
Random r = new Random();
int number = r.nextInt(10);
System.out.println(number);
//BigDecimal BigInteger -> java.math包中
//BigDecimal ->高精度->（商业）钱 ->最终结果怎么保留小数 result.setScale(2, RoundingMode.CEILING)保留2位小数
//BigInteger =>超出了long类型
BigDecimal b = new BigDecimal(12.343434343);
System.out.println(b.setScale(3,RoundingMode.FLOOR));
//UUID ->java.lang.object包中
System.out.println(UUID.randomUUID());//生成通用唯一识别码
- 昨日作业讲解
这题A和C其实都是正确的。不过如果改成抽象类中一定含有1个或多个抽象方法，那就是错的，因为抽象类中也可以没有抽象方法。
其他几题考查的点除了包装类的装箱，就是静态代码块、普通代码块和构造方法的运行先后。
class HelloA {
// 3-父类构造
public HelloA() {
System.out.println("HelloA - 父类 无参数构造");
}
// 2-父类普通代码段
{
System.out.println("I'm A class - 父类 普通代码段");
}
// 1-父类静态代码段
static {
System.out.println("static A -- 父类");
}
}
public class HelloB extends HelloA {
// 3构造
public HelloB() {
System.out.println("HelloB");
}
// 2普通
{
System.out.println("I'm B class");
}
// 1静态
static {
System.out.println("static B - 子类");
}
public static void main(String[] args) {
new HelloB();
}
}
public class Example {
//静态变量是属于 类.
static int i = 1, j = 2;
//静态代码段
static {
display(i);
i = i + j;
}
//静态方法
static void display(int n) {
System.out.println(n);
}
//入口
public static void main(String[] args) {
display(i);
}
}
归根结底，还是考查代码运行优先级：静态代码块>普通代码块>构造方法。
- JAVA日期与时间相关API
- Date类
java.util.Date类中很多构造方法和方法已经过时（Deprecated），不推荐使用，只学习两个没过时的构造方法；
|
方法声明 |
方法描述 |
|
Date() |
使用当前时间构建Date对象； |
|
Date(long date) |
使用一个long值构建Date对象，参数是距离1970.1.1.00:00:00以来的毫秒数 |
Date date1 = new Date();//无参
Date date2 = new Date(10*24*60*60*1000);//有参
|
方法声明 |
方法描述 |
|
public long getTime() |
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 |
|
public boolean after(Date when) |
测试此日期是否在指定日期之后 |
|
public boolean before(Date when) |
测试此日期是否在指定日期之前。 |
|
public int compareTo(Date anotherDate) |
比较两个日期的顺序。 如果参数日期等于此日期0; 如果这个日期在Date参数之前返回负数的值 ; 如果这个日期在Date参数之后返回正数的值。
|
|
public boolean equals(Object obj) |
比较两个日期的相等性 |
- DateFormat抽象类（不能new）
获取日期格式器 public static final DateFormat getDateInstance()
获取时间格式器 public static final DateFormat getTimeInstance()
获取日期/时间格式器 public static final DateFormat getDateTimeInstance()
转换（date到String） public final String format(Date date) （String到date）public Date parse(String source)
- SimpleDateFormat类
获取日期格式器 public SimpleDateFormat(String pattern)
使用模式字符串和区域信息创建对象 SimpleDateFormat(String pattern, Locale locale)
转换 （date到String） public final String format(Date date) （String到date） public Date parse(String source)
SimpleDateFormat自定义日期风格示例：
Date date=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS");
String d=sdf.format(date);s
System.out.println(d);
三者综合代码：
public static void main(String[] args) {
// 无参数的构造
Date date = new Date();
// 输出
System.out.println(date);
// 1- 直接使用 date : 输出格式为 2021年12月15日 9:59:02
String result = date.getYear() + 1900 + "-"
+ (date.getMonth() + 1) + "-" + date.getDate();
System.out.println(result);// 2021-12-15
// 2- DateFormat的静态方法getDateInstance
// format 这个方法就是格式化
String result2 = DateFormat.getDateInstance().format(date);
System.out.println(result2);// 2021-12-15
// 3 - getDateTimeInstance() 日期和时间
String result3 = DateFormat.getDateTimeInstance().format(date);
/* 获取日期（默认风格）DateFormat dataformat=DateFormat.getDateInstance(int类型参数);
* 获取日期+时间格式的工厂 DateFormat dataformat=DateFormat.getDateTimeInstance(int类型参数1 ，int类型参数2);
*/
System.out.println(result3);// 2021-12-15 10:27:43
// 4 -> 只能用它规定好的格式
String result4 = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.MEDIUM).format(date);
/*参数样例：
*DateFormat.FULL模式的日期为： 2015年8月11日 星期二
*DateFormat.SHORT 模式的日期为：12-2-17 下午7:43
*DateFormat.MEDIUM 模式的日期为：2012-2-17 19:43:39
*DateFormat.LONG 模式的日期为：2012年2月17日 下午07时43分39秒
*DateFormat.FULL 模式的日期为：2012年2月17日 星期五 下午07时43分39秒 CST
*/
System.out.println(result4);// 2021年12月15日 星期三 10:27:43
// 5->自定义转换 SimpleDateFormat 比DateFormat更灵活
// 2021年12月15日 9:59:02 yyyy年MM月dd日 HH:mm:ss
SimpleDateFormat simple = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String result5 = simple.format(date);
System.out.println(result5);// 2021-12-15 10:27:43
}
- Calendar抽象类
由于版本的更新换代，很多date的方法都过时了，JDK1.1版本开始，增加了Calendar类，建议使用Calendar类代替Date类。
|
方法声明 |
方法描述 |
|
static Calendar getInstance() |
使用默认时区和语言环境获得日历对象； |
|
static Calendar getInstance(Locale aLocale) |
使用指定的语言环境获得日历对象； |
|
static Calendar getInstance(TimeZone zone) |
使用指定的时区获得日历对象； |
|
static Calendar getInstance(TimeZone zone, Locale aLocale) |
使用指定的时区及语言环境获得日历对象； |
|
方法声明 |
方法描述 |
|
Date getTime() |
将日历对象转换为Date对象返回； |
|
int get(int field) |
根据字段名称，返回该字段的值； |
|
方法声明 |
方法描述 |
|
SimpleDateFormat(String pattern) |
使用模式字符串创建对象； |
|
SimpleDateFormat(String pattern, Locale locale) |
使用模式字符串和区域信息创建对象； |
- 相关代码：
import java.text.SimpleDateFormat;
import java.util.Calendar;
public class TestCalendar {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
System.out.println(c);
// 希望输出格式为 yyyy年MM月dd日 HH:mm:ss
SimpleDateFormat simple = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 曲线 calendar ->date
String result5 = simple.format(c.getTime());
System.out.println(result5);
}
}
- LocalDate类与DateTimeFormatter类
JDK8中定义了java.time.LocalDate，用来表示日期，默认格式是yyyy-MM-dd；该类不包含时间信息。
|
方法声明 |
方法描述 |
|
static LocalDate now() |
使用当前日期生成LocalDate对象； |
|
static LocalDate of(int year, int month, int dayOfMonth) |
使用年月日数值生成LocalDate对象； |
LocalDate类只表示日期，JDK8中定义了新类LocalTime用来表示时间，用法与LocalDate类似；还有，LocalDateTime类，同时包含日期与时间，用法与LocalDate及LocalTime类似。
对于格式化及解析，JDK8中使用DateTimeFormatter类实现。
|
方法声明 |
方法描述 |
|
static DateTimeFormatter ofPattern(String pattern) |
指定模式字符串，生成DateTimeFormatter对象 |
|
static DateTimeFormatter ofPattern(String pattern, Locale locale) |
指定模式字符串及区域信息，生成DateTimeFormatter对象 |
相关代码：
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
/**
* 例如 生日: 年月日->LocalDate/Calendar/Date
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
//以下三种JDK1.8开始才能用
//java.time.LocalDate 本地日期
LocalDate ld=LocalDate.now();
System.out.println(ld);
//DateTimeFormatter格式化器用于打印和解析日期时间对象
DateTimeFormatter formatter1=DateTimeFormatter.ofPattern("yyyy年MM月dd日");
System.out.println(formatter1.format(ld));
//java.time.LocalTime 本地时间
LocalTime lt=LocalTime.now();
System.out.println(lt);
DateTimeFormatter formatter2=DateTimeFormatter.ofPattern("HH点mm分ss秒n纳秒");
System.out.println(formatter2.format(lt));
//java.time.LocalDateTime 本地日期时间
LocalDateTime ldt=LocalDateTime.now();
System.out.println(ldt);
DateTimeFormatter formatter3=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println(formatter3.format(ldt));
}
}
- 包装类型
- Java中的包装类型
Java提供一系列包装类，以便将原始数据类型当作对象进行操作。在java.lang包中，对于每个基本数据类型都有一个相应的包装类。
|
类型 |
字节型 |
短整型 |
整型 |
长整型 |
单精度 浮点型 |
双精度 浮点型 |
字符型 |
布尔型 |
|
基本数据类型 |
byte |
short |
int |
long |
float |
double |
char |
boolean |
|
包装器类型 |
Byte |
Short |
Integer |
Long |
Float |
Double |
Character |
Boolean |
注意：以上这些包装类都是final修饰的，不能派生出子类。
包装类在程序开发中主要用于基本数据类型和字符串之间的转换，比如：
int i7=Integer.parseInt("111");//字符串转成基本数据类型int
System.out.println(i7);
- Integer的两种构造方法：
Integer i1=new Integer(15);
Integer i2=new Integer("15");
1、构造方法赋值：Integer i = new Integer(11);
2、等号赋值：Integer i = 10；
- Integer静态方法
除了Character类以外，其它的包装类都有静态的parseXxx方法（Xxx指代具体的数据类型），用于将字符串转换成相对应的基本数据类型值。如：double d=Double.parseDouble("3.14");//3.14
- Character类的常用方法（这部分老师略过了，用的不多）
|
方 法 原 型 |
说 明 |
|
boolean isLetter(char ch) |
判断字符ch是否为英文字母 |
|
boolean isDigit(char ch) |
判断字符ch是否为0~9之间的数字 |
|
boolean isUpperCase(char ch) |
判断字符ch是否为大写形式 |
|
boolean isLowerCase(char ch) |
判断字符ch是否为小写形式 |
|
boolean isWhitespace(char ch) |
判断字符ch是否为空格或换行符 |
以上方法都是静态方法，可以直接通过类名调用，返回值均为boolean类型。(Ps:以is开头的方法名返回得到的多是布尔值，命名判断方法也依此规则，比较规范)
- Java自动装箱与拆箱的使用方法
装箱：基本数据类型转换为包装器类型，称为装箱（boxing）；例如，int型转换为Integer类型；
拆箱：包装器类型转换为基本数据类型，称为拆箱（unboxing）；例如Integer类型转换为int类型。
相关代码：
public static void main(String[] args) {
// 直接赋值
Integer i1 = 10;
Integer i2 = 10;
// 都是引用类型 == 比较的是地址 i1和i2地址是一样的
System.out.println(i1 == i2);// true
// 直接赋值 比较的是地址 i3和i4地址是不一样的[不在池中缓存]
Integer i3 = 210;
Integer i4 = 210;
System.out.println(i3 == i4);// false
// new 出来，存储一定将对象存储堆中.
Integer i5 = new Integer(30);
Integer i6 = new Integer(30);
// 都是引用类型 == 比较的是地址 i5和i6地址一定是不一样
System.out.println(i5 == i6);// false
}
public static void main(String[] args) {
Integer i1 = new Integer(15);
Integer i2 = new Integer("15");
System.out.println(i1 == i2);// new出来的指向堆中不同的空间，地址不同
System.out.println(i1.equals(i2));// 比较的是数值
double d = Double.parseDouble("3.14");
System.out.println(d);
Integer i3 = 15;
String bin = Integer.toBinaryString(2);// 10进制转为2进制
System.out.println(bin);
String hex = Integer.toHexString(11);// 10进制转为16进制
System.out.println(hex);
String octal = Integer.toOctalString(10);// 10进制转为8进制
System.out.println(octal);
Integer i4 = 15;
System.out.println(i3 == i4);// 数值在-128-127之间，都指向常量池中相同的空间
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);// 超出范围，存储地址在堆中,指向堆中不同的空间
int i7 = Integer.parseInt("111");// 字符串转成基本数据类型int
System.out.println(i7);
int i8 = new Integer(10);
int i9 = new Integer(10);
System.out.println(i8 == i9);// 拆箱了，比较的是值
}
public static void main(String[] args) {
// 直接new出来
Integer i1 = new Integer(1234);
Integer i2 = new Integer("1256");
// 直接将整数赋值给Integer
// Integer= int 装箱
Integer i3 = 1267;
// 也可以将int变量直接赋值给Integer
int i4 = 123;
Integer i5 = i4;
// static int parseInt(String s)
// 将字符串转化为int
int result = Integer.parseInt("123") + Integer.parseInt("456");
System.out.println(result);// 579
// toBinaryString 将10进制转换为二进制
String bin = Integer.toBinaryString(1024);
System.out.println(bin);// 10000000000
// toHexString(int i)
String hex = Integer.toHexString(123);// 7b
System.out.println(hex);
// Integer.valueOf => Integer
Integer i6 = Integer.valueOf("1234");
// int = Integer 拆箱
int i7 = i6;
}
- Java字符串（浅讲）（面试常考）
- String类
了解Java类库
- Java.lang java语言的基本类库
- Java.io 通过数据流，对象序列及文件系统实现输入、输出
- Java.math 整数算术的基本用法
- Java.sql 访问处理数据源数据的类
- Java.util 集合类、时间处理模式 、日期工具等常用工具包
Java包分为二大类：包名是java开头的核心包，包名是javax开头的扩展包
java.lang包中，程序不需要引入此包，就可以使用包中的类。
String类 用来处理创建之后不可以改变的字符串；
StringBuffer类 用来处理创建之后可以改变的字符串；
StringBuilder类 也用来处理创建之后可以改变的字符串。
共同点：它们都被final修饰，不能被其他类继承。
创建String对象的两种方式：String str1="aa"; String str2=new String("aa");
无论是直接初始化字符串，还是通过new关键字创建字符串它们都是会创建在堆内存中。字符串有一个非常重要的特征，即不可变性（能改变的是变量名指向了新的空间，而在"字符串"常量池的那个数据本身并没有被改变）。
相关代码：
public static void main(String[] args) {
// 存储在 "字符串" 字面值 常量池[数据只能有一份]
String str1 = "abc";
String str11 = "abc";
// ==是地址的比较
System.out.println(str1 == str11);//true
// 存储在内存堆中 ->先判断 常量池
String str2 = new String("abc");
System.out.println(str1 == str2);//false 地址不同
// "经典"面试题:
// String str2 = new String("abc");
// 创建几个对象?
// 遇到new 操作，就是一个对象
// 先判断池中是否存在，如果没有就放一份，创建了一个，再堆中再来一份 就是2个。
}
public static void main(String[] args) {
// 存储在 "字符串" 字面值 常量池[数据只能有一份]
String str1 = "abc";
System.out.println(str1);//abc
// = 只是指向作用
str1 = "xyz";
System.out.println(str1);//xyz
// 还是不变
String str2 = new String("abc");
str2 = new String("abcxyz");
}
关于字符串相关方法，明天再总结。
感想：东西不少，不过不难，只是时间那块有点繁琐。
18:21:51 2021-12-15
posted on 2021-12-15 18:21 heyiyang1312 阅读(10) 评论(0) 收藏 举报
浙公网安备 33010602011771号