目录
②StringBuilder insert(int 索引, 任意类型)
①String对象转成StringBuilder对象 String --> StringBuilder
②StringBuilder对象转成String对象 StringBuilder ->String
①static long currentTimeMillis()
②static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length )
③static Properties getProperties()
常用类Object类String类
一、API概念
应用程序编程接口 : 每一个技术,官方都会定义出许多的功能,开发人员可以直接拿来使用API可以理解为Sun公司已经开发好的类和方法
二、Object类
所有类的父类,一切类都直接或者是间接继承Object
Object类中的所有功能,子类都可以使用
Object类定义在了java.lang包, lang包是核心包,此包中的任何类,在使用的时候不需要import 导入
1.Object类的本地方法
①本地方法 :
方法的定义上使用关键字,是修饰符native,这个方法就是本地方法
②特点：
方法没有方法体
方法是C++语言编写的,Sun公司不开源
方法运行的时候,是一个独立的内存 (本地方法栈)
③作用 :
凡是遇到本地方法,方法的作用是和本机的操作系统交互的
2.Object类的方法toString()
自己定义类Person类,默认的继承Object,Object类定义定义了方法
结果是字符串,就是对象内地地址
public String toString();输出语句中System.out.println(对象) 调用对象的toString()
System.out.println(对象) == System.out.println(对象.toString())
toString方法的结果,和开发没有任何的关系，我们需要的是重写父类的方法toStirng(),建立我们对象自己的字符串表现形式
①重写父类的方法toString()
public class Person {
private String name;
private int age;
public Person(){}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 重写了父类的方法toString()
* 返回字符串
* @return
* 重写方法目标 : 方法中,返回类中成员变量的值
*/
public String toString(){
return name + "::" + age;
}
}3.Object类的方法equals()
Java技术认为任何对象都具备比较性,Object类定义了方法equals()，作用就是用来比较对象的。方法结果是boolean值,对象相等就是true
boolean b = p1.equals(p2);结果：false 对象不相等
Object类的方法源码equals
public boolean equals(Object obj){
return this == obj ;
}引用数据类型 == 就是比较对象的地址是不是相同的
Object类的方法equals默认比较对象的内存地址
对象的地址没有可比性，不能比较对象的地址，我们要重写equals方法，建立我们对象Person自己的比较形式
public class Person {
private String name;
private int age;
public Person(){}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 重写equals,建立Person对象自己的比较方式
* 比较对象的age年龄,年龄相同返回true
*/
public boolean equals(Object obj){
//健壮性判断,如果obj对象的值是null,比较的另一个对象不存在
if (obj == null){
return false;
}
//判断this和参数obj是不是一个对象 "p1" 如果是,返回true
//怎么确定this和obj是不是一个对象,内地地址要是一样
if ( this == obj ) {
return true;
}
//比较对象的年龄,this和obj
//obj向下转型为Person,安全性判断
if (obj instanceof Person) {//obj是Person对象
Person p = (Person) obj;
return this.age == p.age;
}
//不是Person,没有可比性
return false;
}
}三、String字符串类
字符串对象,程序中定义""都是字符串对象,这个对象的使用频率最高
字符串类 java.lang.String类,继承Object类,实现了三个接口
字符串对象是常量,一旦创建不能修改
1.字符串对象创建
例：
public static void main(String[] args) {
//字符串创建,2个方式
//直接=创建
String s = "abc";
//使用构造方法创建
String str = new String("aa");
}直接 = 创建方式,代码少,书写简单,推荐使用
new String() 使用了构造方法的创建形式,代码大,不推荐使用
2.字符串的实现原理
字符串这个数据类,在Java中是不存在的,字符串的实现原理是用char[]数组表示
例："abc",使用数组char[] ch = {'a','b','c'} ;来表示，JDK9版本之后,节约内存,char数组改变为了byte数组
JDK中String类的源码
private final char value[];3.字符串创建对象的区别
例：
String str = "abc";
String str = new String("abc");public class StringTest {
public static void main(String[] args) {
String s1 = "abc";
String s2 = new String("abc");
System.out.println(s1 == s2); //false
System.out.println("==========");
/**
* s3 = hello 内存中出现String对象,里面是char数组
* s3保存的是String对象
*
* s4 = "hello" 和s3中的字符串在内存中的数组表现是一样的
* 共用
* s3的内存地址,赋值给s4
*/
String s3 = "hello";
String s4 = "hello";
System.out.println(s3 == s4); //true
System.out.println("========");
String s5 = "how";
String s6 = "you";
String s7 = "howyou";
/**
* s7 == (s5+s6) s5和s6是变量
* 变量在编译的时候,javac不确定变量的计算结果是什么
* 运行的时候,JVM会为 s5+s6的结果,新开内存空间
*/
System.out.println(s7 == (s5+s6)); //false
System.out.println("============");
/**
* "how"+"you" 是常量,值在编译期间就已经确定
* 运行,不会建立新的内存空间
*/
System.out.println(s7 == ("how"+"you"));// true
String s8 = "a"+"b"+"c";
}
public static void print(){
//字符串的不变
//abc内存是不会改变
String s = "abc";
System.out.println(s);
//变量s,指向了新的字符串对象
s = "bbc";
System.out.println(s);
}
}4.String类的构造方法
String(byte[] b) 字节数组转成字符串,使用平台的默认字符集
String(byte[] b,int off,int len) 字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数
String(byte[] b,int off,int,len,String,charsetName) 字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数,charsetName参数是你自己可以指定编码表
5.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类的转换方法
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次
X{m,} X这个字符至少出现m次
X{m,n} X这个字符至少出现m次,不超过n次
X? X这个字符出现一次,或者一次也没有
X* X这个字符出现零次或者多次
X+ X这个字符出现至少一次
正则表达式的匹配功能,String类的方法matches()
⑥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);
}四、StringBuilder
StringBuilder是字符串对象的缓冲区对象, 缓冲区(出现目的,为了高效)提供String类的效率.
1.StringBuilder类的实现原理
一个可变的字符序列,字符序列就是字符数组
字符序列是数组,Java数组的是定长的,一旦创建,长度固定
创建对象的时候,StringBuilder中的数组的初始化长度为16个字符
StringBuilder自动的进行数组的扩容,新数组实现,原来数组的中元素复制到新的数组
结论 : 无论怎么做字符串的操作,StringBuilder内部永远只有一个数组
StringBuilder类是线程不安全的类,运行速度快 , 推荐使用StringBuilder
StringBuffer是线程安全的类,运行速度慢,多线程的程序,使用两个类的构造方法,和其他的方法,一模一样
2.StringBuilder类的常用方法
StringBuilder append(任意类型) 参数追加成字符串,无论参数写的是什么,变成字符串.相当于是字符串里面的 + 运算
①方法调用链, 链式编程
链式编程 : 保证一个方法的返回值是一个对象,再使用这个对象调用的调用方法 :
对象.方法().方法().方法()......
public static void builderAppend2(){
StringBuilder builder = new StringBuilder();
//方法append() 返回值是StringBuilder
//return this 返回值是this (谁调用,我是谁)
builder.append("hehe").append(false).append(1.5).append(1); //执行的结果,是builder对象,继续使用builder对象调用方法
System.out.println("builder = " + builder);
}②StringBuilder insert(int 索引, 任意类型)
可以将任意类型的参数,插入到字符串缓冲区,指定索引
③StringBuilder类的其它方法
int length() 返回字符串缓冲区的长度
StringBuilder delete(int start,int end) 删除缓冲区中的字符,包含开头索引,不包含结束索引
void setCharAt(int 索引,char ch) 修改指定元素上的字符
StringBuilder reverse() 翻转字符串
3.StringBuilder对象和String对象的互转
①String对象转成StringBuilder对象 String --> StringBuilder
StringBuilder类的构造方法 StringBuilder(String str)
append方法 append(String str)
例：
public static void stringToStringBuilder(){
//构造方法
StringBuilder builder = new StringBuilder("abc");
//对象的方法append
builder.append("hello");
}②StringBuilder对象转成String对象 StringBuilder ->String
StringBuilder的方法toString()
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);
}五、System类
System系统类 : 定义在java.lang包中
定义了大量常用的字段(成员变量)和方法,该类不能实例化对象,不能new,类中的成员全部是静态修饰,类名直接调用
全部静态成员,无需对象创建,类名调用. 构造方法private修饰
1.System类的方法
①static long currentTimeMillis()
返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 , 1000毫秒=1秒
/**
* static long currentTimeMillis()
* 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 ,
* 1000毫秒=1秒
*/
public static void systemCurrentTimeMillis(){
long timeMillis = System.currentTimeMillis();
System.out.println("timeMillis = " + timeMillis);
}②static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length )
复制数组的元素
src : 要赋值的数据源,源数组
srcPos : 源数组的开始索引
dest : 要复制的目标数组
destPos : 目标数组的开始索引
length : 要复制的元素个数
③static Properties getProperties()
返回当前的操作系统属性
五、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)参数的平方根
六、数组的相关操作
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]);
}
}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;
}3.数组的排序
在无序的数组中,对元素进行排序,默认都是升序
数组排序 : 元素在内存中的位置交换,效率最低
分类：选择排序,冒泡 (选择优化),插入排序,折半排序,希尔排序,快速排序
①冒泡排序(bubble)
核心思想 : 元素之间比较换位. 冒泡排序的比较方式 : 相邻元素比较
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;
}
}
}
}②选择排序优化
优化 : 不是每次比较完成都要换位,获取到最值,用这个最值在换位值
/**
* 选择排序的优化
* 最值获取:
* 利用元素
* 用索引
*/
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;
}
}
}4.Arrays工具类
java.util包中定义了类Arrays,数组操作的工具类.类不能创建对象,直接静态调用
Arrays类的静态方法
①static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
②static int binarySearch(数组,查找的关键字) 对数组 进行二分搜索法
③static void fill(数组,填充的元素)
④static String toString(数组) 返回数组字符串表现形式
⑤static List asList(T...t) 元素转成List集合
七、字符串相关操作
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);
}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;
}3.字符出现的次数
例：指定字符串 "asdfg3435erAAEExc" , 统计出小写字母,大写字母,数字,各自出现了多少次,不考虑其它字符
统计的案例 : 计数器思想 变量++
实现思想 :字符串换成数组,取出每个元素,分别统计
/**
* 统计字符串中字符和数字出现的次数
*/
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);
}八、常用类
1. String相关的内容
①字符串出现的次数
例：字符串A,另一个字符串B,计算B字符串在A字符串中出现几次
如：dsabdnabdsnabeabiwpabekabd 中‘ab’出现多少次
实现过程
对字符串进行索引查找 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;
}②哪个字符出现的最多
例：指定字符串小写字母 abeegewff , 计算出哪个字符出现的次数最多
实现过程 :
字符串转成数组 (单个字符操作)
创建长度为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);
}2. 大数运算
基本数据类型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 四舍五入
public static void main(String[] args) {
BigDecimal b1 = new BigDecimal("3.55");
BigDecimal b2 = new BigDecimal("2.12");
/* System.out.println(b1.add(b2));
System.out.println(b1.subtract(b2));
System.out.println(b1.multiply(b2));*/
//b1 / b2
/**
* 1.674528301886792
* 除不尽,出现异常
* 高精度运算,不能产生无序循环小数,无限不循环
* 保留几位,怎么保留
*
* BigDecimal.ROUND_UP 向上+1
* BigDecimal.ROUND_DOWN 直接舍去
* BigDecimal.ROUND_HALF_UP 四舍五入
*/
BigDecimal divide = b1.divide(b2,3,BigDecimal.ROUND_HALF_UP);
System.out.println("divide = " + divide);
}3. 日期和日历类
①Date
表示当前的日期对象,精确到毫秒值. java.util.Date类
构造方法
无参数构造方法 new Date()
有long型参数的构造方法 new Date(long 毫秒值)
Date类其他方法
long getTime() 返回当前日期对应的毫秒值
void setTime(long 毫秒值) 日期设定到毫秒值上
②Date类最重要内容
日期对象和毫秒值之间的相互转换
日期对象,转成毫秒值
new Date().getTime()
System.currentTimeMillis()
毫秒值转成日期对象
new Date(毫秒值)
new Date().setTime(毫秒值)
日期是特殊的数据,不能数学计算,但是毫秒值能
③日历类 Calendar
日历类 : java.util.Calendar
日历字段 : 组成日历的每个部分,都称为日历字段 : 年,月,日,时分秒,星期
Calendar抽象类,不能建立对象,子类继承 : GregorianCalendar (格林威治)
Ⅰ获取Calendar类的对象
由于创建日历对象的过程非常的繁琐,考虑语言,时区...Sun公司工程师开发了一简单获取对象的方式,不要自己new
Calendar类定义了静态方法 : static Calendar getInstance()
返回的是Calendar 的子类的对象 GregorianCalendar
Ⅱ日历类的方法
int get(int field) 返回给定日历字段的值
日历中的任何数据,都是int类型
参数是具体的日历字段,传递年,月,日
日历字段的写法,看Calendar类的静态成员变量
void set() 修改日历的值
set(int field,int value)field要修改的字段,value具体的数据
set(int,int,int) 传递年月日
add() 设置日历字段的偏移量
add(int field,int value) field要修改的字段,value具体的数据
④日期格式化
ⅠDateFormat日期格式化
java.text.DateFormat : 类的作用是格式化日期的,但是抽象类不能建立对象,需要创建子类的对象, SimpleDateFormat
ⅡSimpleDateFormat子类使用
构造方法: 带有String参数的构造方法
参数字符串 : 日期格式化后的样子
调用SimpleDateFormat类的父类方法format
String format(Date date)传递日期对象,返回字符串
字符串转成日期对象
SimpleDateFormat调用方法Date parse(String str)
4. JDK8新的时间日期对象
①LocalDate 本地日期
获取该类的对象,静态方法
static LocalDate now() 获取LocalDate的对象,跟随操作系统
static LocalDate of() 获取LocalDate的对象,自己设置日期
of方法中传递年月日 of(int year,int month,int day)
获取日期字段的方法 : 名字是get开头
int getYear() 获取年份
int getDayOfMonth()返回月中的天数
int getMonthValue() 返回月份
设置日期字段的方法 : 名字是with开头
LocalDate withYear(int year)设置年份
LocalDate withMonth(int month)设置月份
LocalDate withDayOfMonth(int day)设置月中的天数
LocalDate对象是不可比对象,设置方法with开头,返回新的LocalDate对象
设置日期字段的偏移量, 方法名plus开头,向后偏移
设置日期字段的偏移量, 方法名minus开头,向前偏移
②Period和Duration类
ⅠPeriod 计算日期之间的偏差
static Period between(LocalDate d1,LocalDate d2)计算两个日期之间的差值
计算出两个日期相差的天数,月数,年数
ⅡDuration计算时间之间的偏差
static Period between(Temporal d1,Temporal d2)计算两个日期之间的差值
③DateTimeFormatter
JDK8中的日期格式化对象 : java.time.format包
static DateTimeFormatter ofPattern(String str)自定义的格式
String format(TemporalAccessor t)日期或者时间的格式化
TemporalAccessor parse(String s)字符串解析为日期对象
5. 基本数据类型对象包装类
JDK提供了一套基本数据类型的包装类,功能增强,全部在lang包
| 基本数据类型 | byte | short | int | long | float | double | boolean | char |
|---|---|---|---|---|---|---|---|---|
| 对应的包装类 | Byte | Short | Integer | Long | Float | Double | Boolean | Char |
基本数据类型的包装类的最重要功能 : 实现类基本数据类型和String的互转
①基本类型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对象,字符串必须纯数字格式
②String对象转成基本数据类型int
static int parseInt(String str) 参数字符串转成基本类型,字符串数字格式.
int intValue() Integer对象构造方法中的字符串,转成基本类型
③自动装箱和拆箱
自动装箱 : 基本数据类型自动转成引用类型 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
}6. 异常
程序在运行中出现的不正常现象就是异常
①异常继承体系
一切都是对象,异常也是对象,JDK为异常定义了大量的类,类之间产生继承关系
异常中的顶级父类 :
java.lang.Throwable : 所有异常和错误的父类
java.lang.Error : 所有错误的父类
java.lang.Exception : 所有异常的父类
java.lang.RuntimeExeption : 所有的运行异常父类
错误: 程序中出现了错误,程序人员只能修改代码,否则不能运行
异常: 程序中出现了异常,可以把异常处理调用,程序继续执行
②Throwable 的方法
String toString() 返回异常信息简短描述 (控制台红色部分)
String getMessage() 返回异常信息的详细描述
void printStackTrace() 异常信息追踪到标准的错误流
③异常的产生和默认的处理方式
1550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
