1.Object类
Object类 : 所有类的父类,一切类都直接或者是间接继承Object. Object类中的所有功能,子类都可以使用.
1.1 Object类的方法toString()
-
Object类的方法 toString默认输出对象的内存地址
1.2 Object类的方法equals()
-
Object类的方法 equals默认比较对象的内存地址
2.String字符串类
字符串对象,程序中定义""都是字符串对象,这个对象的使用频率最高.
字符串对象是常量,一旦创建不能修改.
2.1 字符串对象创建
public static void main(String[] args) {
//字符串创建,2个方式
//直接=创建
String s = "abc";
//使用构造方法创建
String str = new String("aa");
}2.2 字符串的实现原理
"abc",使用数组char[] ch = {'a','b','c'} ;来表示.
JDK9版本之后,节约内存,char数组改变为了byte数组
JDK8版本以前都是char数组
2.3 String类的构造方法
讲过字符编码, ASCII, 小写字母a的值97
String(byte[] b)字节数组转成字符串,使用平台的默认字符集String(byte[] b,int off,int len)字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数String(byte[] b,int off,int,len,String,charsetName)字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数,charsetName参数是你自己可以指定编码表-
String(char[] b)字节数组转成字符串 -
String(char[] b,int off,int,len)字节数组转成字符串,参数off数组的开始索引,len要转的个数
2.4 String类的常用方法
String类的判断类型的方法, 返回都是布尔类型
- boolean equals(Object obj) 字符串之间的比较,两个字符串相同,返回true
- boolean equalsIgnoreCase(String str ) 字符串之间的比较,两个字符串相同,返回true,忽略大小写
- boolean startWith(String str)判断字符串是否以另一个字符串开头,是开头就返回true
- boolean endsWith(String str)判断字符串是否以另一个字符串结尾,是结尾就返回true
- boolean contains(String str) 判断字符串中是否包含另一个字符串,完全包含返回true
- boolean isEmpty()判断字符串的长度是不是0,如果是0返回true
String类的获取方法,返回值不一定
- int length() 返回字符串长度,字符串中字符的个数
- char charAt(int index) 返回指定索引上的单个字符
- int indexOf(String str) 返回指定的字符串,在当前字符串中第一次出现的索引
- int lastIndexOf(String str) 返回指定的字符串,在当前字符串中最后一次出现的索引
- String substring(int start,int end)截取字符串,参数表示开始索引和结束索引,包含开头索引,不包含结束索引
String类的转换方法
- String toLowerCase() 字符串中的所有内容转成小写
- String toUpperCase() 字符串中的所有内容转成大写
- char[] toCharArray() 字符串转成字符数组
- byte[] getBytes() 字符串转成字节数组 (查询编码表),平台默认字符集
- byte[] getBytes(String charsetName) 字符串转成字节数组 (查询编码表),指定编码表
- static String valueOf(任意类型参数) 参数转成字符串对象
String类的比较方法
int compareTo(String str) 字符串之间的比较,谁大谁小,按照字典顺序(自然顺序)
String类的方法 去空格,替换,切割
- String trim() 去掉字符串两边空格,中间空格不去掉
- String replace(String oldString,String newString)替换字符串
- String[] split("规则字符串") 对字符串进行切割
String类正则表达式相关的功能
正则表达式 : 专门用于处理字符串的技术 (正则大神)
-
字符类 :
[abc]字符串的这个位置只能是abc[^abc]字符串的这个位置不能是abc[a-zA-Z]字符串的这个位置必须是字母,52个[^a-zA-Z]字符串的这个位置必须不能是字母,52个
-
数字类:
[0-9]字符串的这个位置只能是数字[^0-9]字符串的这个位置不能是数字[\d]等同于[0-9][\D]等同于[^0-9]
-
预定义字符 :
- . 匹配所有的字符
[\d]等同于[0-9][\D]等同于[^0-9][\w]文字字符,包含数字,字母,下划线[a-zA-Z0-9_][\W]文字字符,不能包含数字,字母,下划线[^a-zA-Z0-9_]
-
数量词 :
- X{m} X这个字符只能出现m次 a{3}
- X{m,} X这个字符至少出现m次
- X{m,n} X这个字符至少出现m次,不超过n次
- X? X这个字符出现一次,或者一次也没有
- X* X这个字符出现零次或者多次
- X+ X这个字符出现至少一次
正则表达式的匹配功能,String类的方法matches()
/**
* 检查邮箱
* 规则 :
* @ 前面 : 可以是数组,字母,混合,_ 位数放下
* @ 后面 : 数组,字母 sina qq 126 1393 yahoo gmail 位数放下
* . 固定 : com cn org edu gov 字母 位数放下
*/
public static void stringMethod2(){
String email = "shihehe@sina.com";
String reg = "[\\w]+@[a-z0-9]+(\\.[a-z]+)+";
boolean b = email.matches(reg);
System.out.println(b);
}
/**
* 正则表达式检查手机号是否合法
* 开头必须是1,长度固定11
* 第二位3 4 5 6 7 8 9
* 第三位 必须是都是数字
*/
public static void stringMethod(){
String tel = "13800138000";
//定义正则的规则,也是字符串
String regex = "1[3459678][0-9]{9}";
//正则规则,和字符串校验
//String类的方法 matches()
boolean b = tel.matches(regex);
System.out.println(b);
}String类的方法split
public static void stringMethod3(){
String str = "as123d387654w5465fasfr234567sa";
String[] strings = str.split("\\d+");
for (int i = 0; i < strings.length; i++) {
System.out.println(strings[i]);
}
System.out.println("================");
String ip = "192.....168.....35.121";
String[] ipArray = ip.split("\\.+");
for (int i = 0; i < ipArray.length; i++) {
System.out.println(ipArray[i]);
}
}String类的方法replaceAll
public static void stringMethod4(){
String str = "as123d387654w5465fasfr234567sa";
//字符串中的所有数组,换成#
String repString = str.replaceAll("\\d+","#");
System.out.println(repString);
String first = str.replaceFirst("\\d+","#");
System.out.println(first);
}3. StringBuilder
StringBuilder是字符串对象的缓冲区对象, 缓冲区(出现目的,为了高效)提供String类的效率.
3.1 StringBuilder类的实现原理
一个可变的字符序列,字符序列就是字符数组
字符序列是数组,Java数组的是定长的,一旦创建,长度固定!
创建对象的时候,StringBuilder中的数组的初始化长度为16个字符
StringBuilder自动的进行数组的扩容,新数组实现,原来数组的中元素复制到新的数组.
结论 : 无论怎么做字符串的操作,StringBuilder内部永远只有一个数组
StringBuilder类是线程不安全的类,运行速度快 , 推荐使用StringBuilder
StringBuffer是线程安全的类,运行速度慢,多线程的程序,使用
两个类的构造方法,和其他的方法,一模一样.
4. StringBuilder类的常用方法
StringBuilder append(任意类型) 参数追加成字符串,无论参数写的是什么,变成字符串.相当于是字符串里面的 + 运算
public static void builderAppend(){
StringBuilder builder = new StringBuilder();
//方法append追加字符串
builder.append(100);
builder.append(5.8);
builder.append(true);
System.out.println("builder = " + builder);
}-
方法调用链, 链式编程 :
链式编程 : 保证一个方法的返回值是一个对象,再使用这个对象调用的调用方法 :
对象.方法().方法().方法()......
4.1 StringBuilder对象和String对象的互转
- String对象转成StringBuilder对象 String --> StringBuilder
- StringBuilder类的构造方法 StringBuilder(String str)
- append方法 append(String str)
/**
* String -> StringBuilder
*/
public static void stringToStringBuilder(){
//构造方法
StringBuilder builder = new StringBuilder("abc");
//对象的方法append
builder.append("hello");
}- StringBuilder对象转成String对象 StringBuilder ->String
- StringBuilder的方法toString()
- String类的构造方法
/**
* StringBuilder -> String
*/
public static void stringBuilderToString(){
StringBuilder builder = new StringBuilder();
builder.append("我是字符串的缓冲区");
//builder对象转成String对象,调用builder对象的方法 toString()
String str = builder.toString();
System.out.println(str);
//String类的构造方法
String s = new String(builder);
System.out.println(s);
}5.System类
System系统类 : 定义在java.lang包中
定义了大量常用的字段(成员变量)和方法,该类不能实例化对象,不能new,类中的成员全部是静态修饰,类名直接调用.
全部静态成员,无需对象创建,类名调用. 构造方法private修饰
5.1 System类的方法
-
static long currentTimeMillis() 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 , 1000毫秒=1秒
-
static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length )复制数组的元素.
- src : 要赋值的数据源,源数组
- srcPos : 源数组的开始索引
- dest : 要复制的目标数组
- destPos : 目标数组的开始索引
- length : 要复制的元素个数
- static Properties getProperties() 返回当前的操作系统属性
6.Math类
-
static double PI 圆周率
-
static double E 自然数的底数
-
static int abs(int a) 返回参数的绝对值
-
static double ceil(double d)返回大于或者等于参数的最小整数
-
static double floor(double d)返回小于或者等于参数的最大整数
-
static long round(double d)对参数四舍五入
-
static double pow(double a,double b ) a的b次幂
-
static double random() 返回随机数 0.0-1.0之间
-
static double sqrt(double d)参数的平方根
7.数组的相关操作
7.1数组的翻转
所谓的数组的翻转例子 : 原始数组 {1,2,3,4} 翻转后是 {4,3,2,1}
数组的翻转不等于倒叙遍历
/**
* 数组的翻转
*/
public static void arrayReverse(){
int[] arr = {1,2,7,5,0,22,3,4};
//最远的元素,交换位置 (使用第三方变量)
for(int min = 0 , max = arr.length -1; min < max ; min++ ,max-- ){
int temp = arr[min] ;//记录数组的最小索引上的元素
arr[min] = arr[max] ; //数组最大索引上的元素,赋值到最小元素的位置上
arr[max] = temp;
}
//遍历看结果
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}7.2数组的二分搜索法
- 数组的基本搜索法 : 判断一个元素是否存在于数组中
- 遍历数组,查找就可以
- 二分搜索法提高效率 : 前提是数组必须是有序的.
/** * 数组的二分搜索法 * 返回查找的元素在数组中的索引,没有呢返回负数 */ public static int binarySearch(int[] arr,int key){ int min = 0 ; //数组的最小索引 int max = arr.length - 1; //数组的最大索引 int mid ;//数组折半后的,中间位置的索引 //循环折半,次数不定,while循环 //条件,,最小索引不能超过最大索引 while (min <= max){ //折半 mid = (min + max) / 2; //折半后的mid作为索引,取出数组的元素,和关键字比较 if (key > arr[mid]) //移动最小索引 min = mid + 1; else if (key < arr[mid]) //移动最大索引 max = mid - 1; else { //查找到了,返回索引 return mid; } } return -1; }7.3 数组的排序
在无序的数组中,对元素进行排序,默认都是升序. 效率
数组排序 : 元素在内存中的位置交换,效率最低.
选择排序,冒泡 (选择优化),插入排序,折半排序,希尔排序,快速排序
7.3.1冒泡排序
/** * 排序实现 */ public static void bubbleSort(int[] arr){ //外循环,次数固定的 for (int i = 0 ; i < arr.length ; i++){ //内循环,每次都要进行递减操作 for (int j = 0 ; j < arr.length - i - 1; j++){ //j 0-6 //比较换位 if (arr[j] > arr[j + 1]){ int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } }7.3.2选择排序法
/** * 选择排序的优化 * 最值获取: * 利用元素 * 用索引 */ public static void selectSort(int[] arr){ //获取数组的最值 for (int i = 1 ; i < arr.length ;i++){ //定义变量,保存数组的第一个元素 int min = arr[i-1]; //[1-1 = 0] //定义记录最小值索引 int minIndex = i-1; for(int j = i ; j < arr.length ; j++){ if (min > arr[j]){ //记录的索引 minIndex = j; //记录最小值 min= arr[j]; } } //位置交换 if (minIndex != (i-1)){ int temp = arr[i-1]; arr[i-1] = arr[minIndex]; arr[minIndex] = temp; } } }7.4 Arrays工具包
java.util包中定义了类Arrays,数组操作的工具类.类不能创建对象,直接静态调用
- Arrays类的静态方法
- static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
- static int binarySearch(数组,查找的关键字) 对数组 进行二分搜索法
- static void fill(数组,填充的元素)
- static String toString(数组) 返回数组字符串表现形式
- static List asList(T...t) 元素转成List集合
8.字符串相关操作
8.1字符串翻转
/**
* 翻转字符串的另一个实现
*/
public static String stringReverse2(String str){
//str转成StringBuilder
//StringBuilder builder = new StringBuilder(str);
// builder.reverse();
//字符串缓冲区转成字符串返回
//return builder.toString();
return new StringBuilder(str).reverse().toString();
}
/**
* 翻转字符串
* 传递字符串,返回翻转后的字符串
*/
public static String stringReverse(String str){
//字符串转成数组
char[] chars = str.toCharArray();
//翻转数组
for(int min = 0 ,max = chars.length - 1; min <= max ; max--,min++){
char temp = chars[min];
chars[min] = chars[max];
chars[max] = temp;
}
//数组转成字符串
return new String(chars);
}5.2 自定义trim()
去掉字符串两边的空格
" abcd efg " ==>"abcd efg"
/**
* 自定义的方法trim()
* " abcde fg "
* "abcde fg "
*/
public static String myTrim(String str){
//去掉字符串开头的空格,方法替换
str = str.replaceFirst(" +","");
//判断字符串,是不是以空格结尾
while (str.endsWith(" ")){ //"abcde fg1"
//截取字符串
str = str.substring(0,str.length()-1);
}
return str;
}5.3字符出现的次数
要求 : 指定字符串 "asdfg3435erAAEExc" , 统计处,小写字母,大写字母,数字,各自出现了多少次,不考虑其它字符.
统计的案例 : 计数器思想 变量++
实现思想 : 字符串换成数组,取出每个元素,分别统计 ASCII码熟悉
/**
* 统计字符串中字符和数字出现的次数
*/
public static void stringCount(String str){
if (str == null)
return;
//定义三个计数器变量
int upper = 0 , lower = 0 , number = 0;
//字符串转成数组
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
//取出每个元素
char ch = chars[i];
//判断ch字符的ASCII范围
if ( ch >= 'A' && ch <= 'Z')
//大写字母
upper ++;
else if ( ch >= 'a' && ch <= 'z')
//小写字母
lower ++;
else if (ch >= '0' && ch <= '9'){
//数字
number ++;
}
}
System.out.println("大写字母:"+upper);
System.out.println("小写字母:"+lower);
System.out.println("数字:"+number);
}9.String相关的内容
9.1字符串出现的次数
字符串A,另一个字符串B,计算B字符串在A字符串中出现几次
- 实现过程
- 对字符串进行索引查找 indexOf
- 找到的字符串的索引记录,进行字符串的截取
- 直到找打到未知, indexOf方法是-1
- 一旦找到了,计数器++
/**
* @param str 原始字符串
* @param sub 要查找的字符串
* @return 出现次数
*/
public static int stringCount(String str ,String sub){
//定义变量,计数器
int count = 0;
//定义变量,记录字符串查找后的索引
int index = 0;
//对字符串出现的位置,进行查询
//反复查找,使用循环while
//循环条件就是indexOf方法返回-1
while ( (index=str.indexOf(sub)) != -1 ) {
//执行了循环index !=-1 字符串出现了
count ++;
//截取字符串,开始索引 index+被查找字符串的长度
str = str.substring(index + sub.length());
}
return count;
}9.2哪个字符出现的最多
- 实现过程 :
- 字符串转成数组 (单个字符操作)
- 创建长度为26的数组,计数器使用
- 取出数组中的字符, (字符-97)对应数组的索引,计数器++
- 找出数组中的最大值
/**
* 查找字符串中,哪个字符出现的次数最多
* @param str 要查找字符串
* @return 返回出现次数最多的字符
*/
public static char charCount(String str){
//字符串转成数组
char[] chars = str.toCharArray();
//定义26长度的数组,保存每个字符出现的次数
int[] count = new int[26];
//遍历数组
for (int i = 0 ; i < chars.length; i++){
//取出单个字符
char ch = chars[i];
//字符 - 97 作为数组的索引使用 (数组,计数器数组)
count[ ch - 97 ] ++;
}
//System.out.println("Arrays.toString(count) = " + Arrays.toString(count));
//取出count数组中的,最大值的索引
int index = 0 ; //数组最大值索引
int max = count[0];
for(int i = 1 ; i < count.length ; i++){
if (max < count[i]){
index = i;
max = count[i];
}
}
//index索引,正好和字符相差97
return (char) (index+97);
}10.大数运算
基本数据类型long ,double 都是有取值范围.遇到超过范围数据怎么办.引入了大数运算对象. 超过取出范围了,不能称为数字了,称为对象
java.math包 : BigInteger大整数, BigDecimal大浮点(高精度,不损失精度)
- BigInteger类使用,计算超大整数的
- 构造方法直接new BigInteger(String str) 数字格式的字符串,长度任意
- BigInteger add(BigInteger b)计算两个BigInteger的数据求和
- BigInteger subtract(BigInteger b)计算两个BigInteger的数据求差
- BigInteger multiply(BigInteger b)计算两个BigInteger的数据求乘积
- BigInteger divide(BigInteger b)计算两个BigInteger的数据求商
public static void main(String[] args) {
//创建大数据运算对象
BigInteger b1 = new BigInteger("2345673456786554678996546754434343244568435678986");
BigInteger b2 = new BigInteger("8765432345678987654323456787654");
//b1+b2 求和
BigInteger add = b1.add(b2);
System.out.println("add = " + add);
//b1 - b2 求差
BigInteger subtract = b1.subtract(b2);
System.out.println("subtract = " + subtract);
//b1 * b2 求积
BigInteger multiply = b1.multiply(b2);
System.out.println("multiply = " + multiply);
//b1 / b2 求商
BigInteger divide = b1.divide(b2);
System.out.println("divide = " + divide);
}- BigDecimal 类使用,计算超大浮点数
- 构造方法,和BigInteger一样
- 方法 + - * 和BigInteger一样
- BigDecimal divide除法运算
- divide(BigDecimal big,int scalar,int round)方法有三个参数
- big 被除数
- scalar 保留几位
- round 保留方式
- 保留方式 : 该类的静态成员变量
- BigDecimal.ROUND_UP 向上+1
- BigDecimal.ROUND_DOWN 直接舍去
- BigDecimal.ROUND_HALF_UP 四舍五入
BigDecimal divide = b1.divide(b2,3,BigDecimal.ROUND_HALF_UP);11.日期和日历类
11.1Date
表示当前的日期对象,精确到毫秒值. java.util.Date类
-
构造方法
- 无参数构造方法 new Date()
- 有long型参数的构造方法 new Date(long 毫秒值)
-
Date类没有过时的方法
- long getTime() 返回当前日期对应的毫秒值
- void setTime(long 毫秒值) 日期设定到毫秒值上
/**
* 创建对象,使用有参数的构造方法
*/
public static void date2(){
Date date = new Date(0);
System.out.println("date = " + date);
}
/**
* 创建对象,使用无参数的构造方法
*/
public static void date1(){
Date date = new Date();
//Tue Apr 13 10:33:40 CST 2021
System.out.println("date = " + date);
}
/**
* getTime()
* setTime()
*/
public static void date3(){
Date date = new Date();
//获取毫秒值
long time = date.getTime();
System.out.println(time);
//设置日期
date.setTime(0);
System.out.println(date);
}11.2Date类最重要的内容
- 日期对象和毫秒值之间的相互转换
- 日期对象,转成毫秒值
- new Date().getTime()
- System.currentTimeMillis()
- 毫秒值转成日期对象
- new Date(毫秒值)
- new Date().setTime(毫秒值)
11.3 日历类 Calendar
日历类 : java.util.Calendar
日历字段 : 组成日历的每个部分,都称为日历字段 : 年,月,日,时分秒,星期
Calendar抽象类,不能建立对象,子类继承 : GregorianCalendar (格林威治)
11.3.1 获取Calendar类的对象
- Calendar类定义了静态方法 : static Calendar getInstance() 返回的是Calendar 的子类的对象 GregorianCalendar
11.3.2 日历类的方法
- int get(int field) 返回给定日历字段的值
- 日历中的任何数据,都是int类型
- 参数是具体的日历字段,传递年,月,日
- 日历字段的写法,看Calendar类的静态成员变量
calendar.get(Calendar.YEAR)+"年" + (calendar.get(Calendar.MONTH) +1)+"月" +
calendar.get(Calendar.DAY_OF_MONTH)+"日" + calendar.get(Calendar.HOUR_OF_DAY)+"点" +
calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒"- void set() 修改日历的值
- set(int field,int value)field要修改的字段,value具体的数据
- set(int,int,int) 传递年月日
//自己设置日历,传递了年月日
//calendar.set(2021,5,30);
//设置某一个字段
calendar.set(Calendar.DAY_OF_MONTH,30);- add() 设置日历字段的偏移量
- add(int field,int value) field要修改的字段,value具体的数据
calendar.add(Calendar.DAY_OF_MONTH,180);11.4 日期格式化
自定义日期的格式
11.4.1 DateFormat日期格式化
java.text.DateFormat : 类的作用是格式化日期的,但是抽象类不能建立对象,需要创建子类的对象, SimpleDateFormat
11.4.2 SimpleDateFormat子类使用
- 构造方法: 带有String参数的构造方法
- 参数字符串 : 日期格式化后的样子
- 调用SimpleDateFormat类的父类方法format
- String format(Date date)传递日期对象,返回字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH点mm分ss秒");
String str = sdf.format(new Date());- 字符串转成日期对象
- SimpleDateFormat调用方法Date parse(String str)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
/**
* dateString用户输入的日期
* 转成Date对象
* 前提 : 格式必须和SimpleDateFormat("格式一致")
*/
String dateString = "2021-04-13";
//sdf对象的方法parse
Date date = sdf.parse(dateString);12 JDK8新的时间日期对象
12.1 LocalDate本地日期
- 获取该类的对象,静态方法
- static LocalDate now() 获取LocalDate的对象,跟随操作系统
- static LocalDate of() 获取LocalDate的对象,自己设置日期
- of方法中传递年月日 of(int year,int month,int day)
/**
* LocalDate的静态方法获取对象
*/
public static void getInstance(){
//静态方法now()
LocalDate localDate = LocalDate.now();
System.out.println("localDate = " + localDate);
//静态方法of()设置日期
LocalDate of = LocalDate.of(2022,5,10);
System.out.println("of = " + of);
}- 获取日期字段的方法 : 名字是get开头
- int getYear() 获取年份
- int getDayOfMonth()返回月中的天数
- int getMonthValue() 返回月份
/**
* LocalDate类的方法 getXXX()获取日期字段
*/
public static void get(){
LocalDate localDate = LocalDate.now();
//获取年份
int year = localDate.getYear();
//获取月份
int monthValue = localDate.getMonthValue();
//获取天数
int dayOfMonth = localDate.getDayOfMonth();
System.out.println("year = " + year);
System.out.println("monthValue = " + monthValue);
System.out.println("dayOfMonth = " + dayOfMonth);
}-
设置日期字段的方法 : 名字是with开头
-
LocalDate withYear(int year)设置年份
-
LocalDate withMonth(int month)设置月份
-
LocalDate withDayOfMonth(int day)设置月中的天数
-
LocalDate对象是不可比对象,设置方法with开头,返回新的LocalDate对象
-
/**
* LocalDate类的方法 withXXX()设置日期字段
*/
public static void with(){
LocalDate localDate = LocalDate.now();
System.out.println("localDate = " + localDate);
//设置年,月,日
//方法调用链
LocalDate newLocal = localDate.withYear(2025).withMonth(10).withDayOfMonth(25);
System.out.println("newLocal = " + newLocal);
}- 设置日期字段的偏移量, 方法名plus开头,向后偏移
- 设置日期字段的偏移量, 方法名minus开头,向前偏移
/**
* LocalDate类的方法 minusXXX()设置日期字段的偏移量,向前
*/
public static void minus() {
LocalDate localDate = LocalDate.now();
//月份偏移10个月
LocalDate minusMonths = localDate.minusMonths(10);
System.out.println("minusMonths = " + minusMonths);
}
/**
* LocalDate类的方法 plusXXX()设置日期字段的偏移量,向后
*/
public static void plus(){
LocalDate localDate = LocalDate.now();
//月份偏移10个月
LocalDate plusMonths = localDate.plusMonths(10);
System.out.println("plusMonths = " + plusMonths);
}12.2 Period和Duration类
12.2.1 Period 计算日期之间的偏差
- static Period between(LocalDate d1,LocalDate d2)计算两个日期之间的差值.
- 计算出两个日期相差的天数,月数,年数
public static void between(){
//获取2个对象,LocalDate
LocalDate d1 = LocalDate.now(); // 2021-4-13
LocalDate d2 = LocalDate.of(2022,4,13); // 2022-6-15
//Period静态方法计算
Period period = Period.between(d1, d2);
//period非静态方法,获取计算的结果
int years = period.getYears();
System.out.println("相差的年:"+years);
int months = period.getMonths();
System.out.println("相差的月:"+months);
int days = period.getDays();
System.out.println("相差的天:"+days);
}12.2.2 Duration计算时间之间的偏差
- static Period between(Temporal d1,Temporal d2)计算两个日期之间的差值.
LocalDateTime d1 = LocalDateTime.now();
LocalDateTime d2 = LocalDateTime.of(2021,5,13,15,32,20);
// Duration静态方法进行计算对比
Duration duration = Duration.between(d1, d2);
// Duration类的对象,获取计算的结果
long minutes = duration.toMinutes();
System.out.println("相差分钟:" + minutes);12.2.3 DateTimeFormatter
- static DateTimeFormatter ofPattern(String str)自定义的格式
- String format(TemporalAccessor t)日期或者时间的格式化
- TemporalAccessor parse(String s)字符串解析为日期对象
/**
* 方法parse,字符串转日期
*/
public static void parse(){
//静态方法,传递日期格式,返回本类的对象
DateTimeFormatter dateTimeFormatter =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String str = "2021-04-13 15:55:55";
//dateTimeFormatter调用方法parse转换
//返回接口类型,接口是LocalDate,LocalDateTime 都实现了该接口
TemporalAccessor temporalAccessor = dateTimeFormatter.parse(str);
//System.out.println(temporalAccessor);
LocalDateTime localDateTime = LocalDateTime.from(temporalAccessor);
System.out.println(localDateTime);
}
/**
* 方法format格式化
*
*/
public static void format(){
//静态方法,传递日期格式,返回本类的对象
DateTimeFormatter dateTimeFormatter =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//dateTimeFormatter对象调用方法format
String format = dateTimeFormatter.format(LocalDateTime.now());
System.out.println(format);
}13 基本数据类型对象包装类
| 基本数据类型 | 对应的包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
基本数据类型的包装类的最重要功能 : 实现类基本数据类型和String的互转
13.1 基本类型int变成Integer类的对象
- Integer类的构造方法
- Integer(int a) int类型转成Integer对象
- Integer(String s)字符串转成Integer对象,字符串必须纯数字格式
- static Integer valueOf(int a) int类型转成Integer对象
- static Integer valueOf(String s) 字符串转成Integer对象,字符串必须纯数字格式
/**
* 创建Integer类的对象
* 构造方法,new
* static方法 valueOf
*/
public static void getInstance(){
Integer i1 = new Integer(100);
Integer i2 = new Integer("120");
System.out.println(i1);
System.out.println(i2);
Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf("220");
System.out.println(i3);
System.out.println(i4);
}13.2 String对象转成基本数据类型int
- static int parseInt(String str) 参数字符串转成基本类型,字符串数字格式.
- int intValue() Integer对象构造方法中的字符串,转成基本类型
/**
* 字符串转成基本类型int
* 静态方法parseInt()
* 非静态方法 intValue()
*/
public static void stringToInt(){
int i = Integer.parseInt("100");
System.out.println(i+1);
Integer integer = new Integer("2");
int j = integer.intValue();
System.out.println(j+1);
}13.3 自动装箱和拆箱
- 自动装箱 : 基本数据类型自动转成引用类型 int -> Integer
- 自动拆箱 : 引用类型自动转成基本数据类型 Integer ->int
public static void auto(){
//自动装箱 int类型自动转成Integer对象
//javac编译特效 Integer integer = Integer.valueOf(1000) 本质还是new Integer
Integer integer = 1000;
System.out.println(integer);
//自动拆箱 Integer类型自动转成int类型
//javac编译特点 integer + 1; integer.intValue()返回int类型 + 1 = 1001
//Integer integer2 = 1001 装箱
Integer integer2 = integer + 1;
System.out.println(integer2);
}/**
* 自动装箱和拆箱中的问题
*/
public static void auto2(){
Integer i1 = 1000; //new Integer(1000)
Integer i2 = 1000; //new Integer(1000)
System.out.println("i1==i2::" + (i1 == i2) ); // F
System.out.println(i1.equals(i2)); // T
System.out.println("=====忧郁的分割线======");
Integer i3 = new Integer(1);
Integer i4 = new Integer(1);
System.out.println("i3==i4::"+(i3 == i4));// F
System.out.println(i3.equals(i4)); // T
System.out.println("=====忧郁的分割线======");
Integer i5 = 127;
Integer i6 = 127;
System.out.println("i5==i6::"+(i5 == i6)); //true 数据不要超过byte
}14. 异常
一切都是对象,异常也是对象,JDK为异常定义了大量的类,类之间产生继承关系
异常中的顶级父类 :
- java.lang.Throwable : 所有异常和错误的父类
- java.lang.Error : 所有错误的父类
- java.lang.Exception : 所有异常的父类
- java.lang.RuntimeExeption : 所有的运行异常父类
错误: 程序中出现了错误,程序人员只能修改代码,否则不能运行
异常: 程序中出现了异常,可以把异常处理调用,程序继续执行
- JVM对异常进行了处理 : 输出信息,结束程序
- 处理异常,没有异常,继续执行程序
扫一扫
780
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
