织梦网站安装教程,论坛制作,济南做网站哪好,嘉兴做微网站Day19
1.包装类的使用 理解#xff1a;8种基本数据类型对应类 出现原因#xff1a; Java为纯面向对象语言(万物皆对象)#xff0c;8种基本数据类型不能new对象#xff0c; 就破坏Java为纯面向对应语言的特征#xff0c;Java又为8种基本数据类型分别 匹配了对应的…Day19
1.包装类的使用 理解8种基本数据类型对应类 出现原因 Java为纯面向对象语言(万物皆对象)8种基本数据类型不能new对象 就破坏Java为纯面向对应语言的特征Java又为8种基本数据类型分别 匹配了对应的类这种类叫做包装类/封装类 8种基本数据类型对应包装类
基本数据类型包装类继承关系byteByteObject.Number.ByteshortShortObject.Number.ShortintIntegerObject.Number.IntegerlongLongObject.Number.LongfloatFloatObject.Number.FloatdoubleDoubleObject.Number.DoublecharCharacterObject.CharacterbooleanBooleanObject.Boolean 注意 1.int的包装类的写法为Integer 2.char的包装类的写法是Character 3.其余基本数据类型的包装类均是基本类型的首字母大写。 1.1 手动装箱 手动装箱基本数据类型 - 包装类 int num 100;Integer integer Integer.valueOf(num);System.out.println(integer); //打印出来是100,这个是字符串String类型1.2 自动拆箱 手动拆箱包装类 - 基本数据类型 Integer integer new Integer(100);int num integer.intValue();System.out.println(num); //打印出来是100,这个是int类型1.3 自动拆装箱 JDK1.5开始的新特性自动拆装箱 自动装箱基本数据类型 - 包装类 int num 100;Integer integer num;//底层实现Integer.valueOf(num);System.out.println(integer);自动拆箱包装类 - 基本数据类型 Integer integer new Integer(100);int num integer;//底层实现integer.intValue(); JVM自动封装System.out.println(num);//将字符串转换为int值 String str 123; //String str 123aaaa; 直接报错int num Integer.parseInt(str);System.out.println(num);1.4 深入Integer类的底层原理 面试题描述Integer的valueOf底层实现原理 答判断输入的int值是否在-128~127的区间内 如果在就从Integer的缓存类的缓存数组中获取对象 如果不在就重新new Integer的对象 public class Test02 {public static void main(String[] args) {//面试题描述下列代码的运行结果Integer integer1 Integer.valueOf(100);Integer integer2 Integer.valueOf(100);System.out.println(integer1 integer2);//true // 两个对象比较不是100在比较而是比较的是内存地址Integer integer3 Integer.valueOf(200);Integer integer4 Integer.valueOf(200);System.out.println(integer3 integer4);//falseSystem.out.println(---------------------);//面试题解释如下
// Integer integer new Integer(100);
// System.out.println(integer);//100
// int num1 integer.intValue();
// System.out.println(num1);//100
//
// MyInteger myInteger new MyInteger(100);
// System.out.println(myInteger);//100不写下面的myInteger类的toString方法就会打印全类名
// int num2 myInteger.intValue();
// System.out.println(num2);//100MyInteger myInteger1 MyInteger.valueOf(100);MyInteger myInteger2 MyInteger.valueOf(100);System.out.println(myInteger1 myInteger2);//trueMyInteger myInteger3 MyInteger.valueOf(200);MyInteger myInteger4 MyInteger.valueOf(200);System.out.println(myInteger3 myInteger4);//false 200 不在-128,127中就去new一个新的对象}
} 手写Integer方法看看底层代码 public class MyInteger {private int value;//将值传入到value中public MyInteger(int value) {this.value value;}public int intValue(){return value;}//手动装箱public static MyInteger valueOf(int i){//判断 i 在不在缓存数组中-128,127if(iMyIntegerCache.low iMyIntegerCache.high){//在就把下标取出来return MyIntegerCache.cache[i (-MyIntegerCache.low)];}//如果不在-128,127中就去new一个新的对象return new MyInteger(i);}Overridepublic String toString() {return String.valueOf(value);//将int值转换为字符串}//缓存类内部类设置private不想让外部调用 private static class MyIntegerCache{private static final int low -128;//低位private static final int high 127;//高位private static final MyInteger[] cache;//缓存数组-128~127的MyInteger的对象//静态代码块static{//初始化缓存数组cache new MyInteger[high - low 1];//256int j low;for (int i 0; i cache.length; i) {cache[i] new MyInteger(j);}}}
}将字符串转换为整数 练习将一个字符串如”1,2,3,4,5,6”转换成一个整型数组信息列表 public class Main { public static void main(String[] args) { String str 1,2,3,4,5,6; String[] array str.split(,); // 分割字符串为数组 int[] intArray new int[array.length]; // 创建一个整型数组 for (int i 0; i array.length; i) { intArray[i] Integer.parseInt(array[i]); // 将每个元素转换为整数 } // 打印整型数组 for (int i : intArray) { System.out.println(i); } }
}
2.关于字符串类 分类 1.String 2.StringBuffer 3.StringBuilder 2.1 String的使用 理解String是****不可变****类, 即一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。 String类是final类不能有子类。 注意字符串效果上相当于字符数组( char[] )但是底层原理是字节数组( byte[] ) 2.1.1 获得新字符串的常用方法拼接替换 String concat(String str) 拼接字符串并返回新的字符串 String subString(int beginIndex) 从开始下标处beginIndex截取到末尾并返回新的字符串 public String toLowerCase() 转小写并返回新的字符串 public String toUpperCase() 转大写并返回新的字符串 public String trim() 去除首尾空格并返回新的字符串 public String replace(char oldChar, char newChar) 替换字符并返回新的字符串 public String replace(CharSequence target, CharSequence replacement) 替换字符串并返回新的字符串 public String replaceAll(String regex, String replacement) 替换字符串并返回新的字符串 public replaceFirst(String regex, String replacement) 替换第一次出现的字符串并返回新的字符串 2.1.2 计算字符串长度的方法 public int length(); 返回字符串字符的个数。(从1开始) 2.1.3 字符串比较 equals() 比较两个字符串内容是否相同区分大小写(字符串类对此方法进行了重写) equalsIgnoreCase() 比较两个字符串内容是否相同不区分大小写 比较两个字符串是否为同一对象即在内存中的地址是否一样 startsWith() 判断字符串是否以某个字符串开头 endsWith() 判断字符串是否以某个字符串结尾 2.1.4 字符串查找 charAt(char ch) 获取字符串中指定下标的字符 indexOf(String str) 查找子字符串在此字符串第一次出现的下标,如果没找到则返回 -1 lastIndexOf(String str) 查找子字符串在此字符串最后一次出现的下标 2.1.5 其他数据类型转成字符串 在String类中定义了一些静态的重载方法 public static String valueOf(…)可以将基本类型数据、Object类型转换为字符串。如 public static String valueOf(double d) 把double类型数据转成字符串 public static String valueOf(Object obj) 调用obj的toString()方法得到它的字符串表示形式。 其他类型 “”加一个空字符串也是可以转成字符串 public class Test01 {public static void main(String[] args) {String str 123abc;//底层new char[]{1,2,3,a,b,c};str str.concat(DEF123);//拼接字符串并返回新的字符串str str.substring(2);//从开始下标处截取到末尾并返回新的字符串str str.substring(1, 7);//从开始下标处(包含)截取到结束下标处(排他)并返回新的字符串str str.toUpperCase();//转大写并返回新的字符串str str.toLowerCase();//转小写并返回新的字符串str 123 abc DEF 123 ;str str.trim();//去除首尾空格并返回新的字符串str str.replace(a, A);//替换字符并返回新的字符串str str.replace(Abc, ABC);//替换字符串并返回新的字符串str str.replaceAll(ABC, abc);//替换字符串并返回新的字符串str str.replaceFirst(23, 66);//替换第一次出现的字符串并返回新的字符串str str.replaceAll( , );//去除空格将空格字符串替换成空内容的字符串int len str.length();System.out.println(获取字符串的字符个数 len);System.out.println(判断两个字符串内容是否相同区分大小写 str.equals(166abcDEF123));//trueSystem.out.println(判断两个字符串内容是否相同不区分大小写 str.equalsIgnoreCase(166ABCdef123));//trueSystem.out.println(判断字符串是否以某个字符串开头 str.startsWith(166a));//trueSystem.out.println(判断字符串是否以某个字符串结尾 str.endsWith(DEF123));//trueSystem.out.println(查找子字符串在此字符串第一次出现的下标 str.indexOf(1));//0System.out.println(查找子字符串在此字符串最后一次出现的下标 str.lastIndexOf(1));//9System.out.println(获取字符串中指定下标的字符 str.charAt(6));//D//166abcDEF123System.out.println(str);System.out.println(-------------------------);//把其他类型转换为String类型System.out.println(String.valueOf(10));//int - StringSystem.out.println(String.valueOf(11.11));//double - StringSystem.out.println(String.valueOf(true));//boolean - StringSystem.out.println(String.valueOf(A));//char - StringSystem.out.println(-------------------------);//把其他类型转换为String类型System.out.println(10 );//int - StringSystem.out.println(11.11 );//double - StringSystem.out.println(true );//boolean - StringSystem.out.println(A );//char - String}
}String练习题 练习完成一个邮箱格式的校验 hhyqq.com 1“”不能在第一位 2“.”不能在最后一位 3“”和“.”中间应该有字符 4.*** 当然还有更严格的校验规则我们此处考虑到这即可 String email hhyqq.com;int indexOf1 email.indexOf();int indexOf2 email.indexOf(.);if(indexOf10 || indexOf2email.length()-1 || indexOf2-indexOf11){System.out.println(邮箱格式错误);}else{System.out.println(邮箱格式正确);}注意号的作用 比较基本数据类型比较的是具体的值 比较引用数据类型比较的是对象地址值 2.2 StringBuffer StringBuffer代表****可变****的字符序列。 StringBuffer称为字符串缓冲区它的工作原理是预先申请一块内存存放字符序列如果字符序列满了会重新改变缓存区的大小以容纳更多的字符序列。 StringBuffer是可变对象这个是String最大的不同 StringBuffer可以理解为一个字符串容器可以动态的改变容器中的内容。 2.2.1 StringBuffer常用方法 append() 在末尾追加字符串 insert(int offsetString str) 将子字符串插入到此字符串指定下标的位置 setCharAt(int offsetchar ch) 替换指定下标上的字符 replace(int startint endString str) //从开始下标处包含替换到结束下标处排他的字符串 deleteCharAt(int index) 删除指定下标上的字符 delete(int startint end) 从开始下标处包含删除到结束下标处排他的字符串 reverse() 反转字符串 length() 确定Stringbuffer字符串的长度 public class Test02 {/*** 知识点*/public static void main(String[] args) {StringBuffer sb new StringBuffer();sb.append(123abc);//在末尾追加字符串sb.append(DEF123);//在末尾追加字符串sb.insert(6, xyz);//将子字符串插入到此字符串指定下标的位置sb.setCharAt(6, X);//替换指定下标上的字符sb.replace(3, 9, ABCABC);//从开始下标处包含替换到结束下标处排他的字符串sb.deleteCharAt(6);//删除指定下标上的字符sb.delete(3, 11);//从开始下标处包含删除到结束下标处排他的字符串sb.reverse();//反转字符串int len sb.length();System.out.println(字符串长度为 len);//321321System.out.println(sb.toString());}
}普及 因为StringBuilder是Java已经写好的类 java在底层对他做了一些特殊处理。 打印对象不是地址值而是属性值。 2.3 StringBuilder StringBuilder与StringBuffer的用法完全一致唯一的区别是StringBuffer是线程安全的而StringBuilder不是线程安全的。所以StringBuilder的性能要比StringBuffer要好。 单线程推荐使用StringBuilder多线程使用StringBuffer。 2.3.1 StringBuilder常用方法 注意在调用方法的层面上StringBuilder和StringBuffere是一样的 2.3.2 为什么需要StringBuilder及StringBuffer类 字符串的不变性 一个String对象的长度是固定的不能改变它的内容或者是附加新的字符到String对象中。 您也许会使用来串联字符串以达到附加新字符或字符串的目的但会产生一个新的String对象。 String s1 “abc”;String s2 “abc”;String s3 s1s2;如果程序对这种附加字符串的需求很频繁系统会频繁在内存中创建String对象造成性能下降。所以并不建议使用来进行频繁的字符串串联。应该使用java.lang.StringBuffer类。 public class Test03 {public static void main(String[] args) {StringBuilder sb new StringBuilder();sb.append(123abc);//在末尾追加字符串sb.append(DEF123);//在末尾追加字符串sb.insert(6, xyz);//将子字符串插入到此字符串指定下标的位置sb.setCharAt(6, X);//替换指定下标上的字符sb.replace(3, 9, ABCABC);//从开始下标处包含替换到结束下标处排他的字符串sb.deleteCharAt(6);//删除指定下标上的字符sb.delete(3, 11);//从开始下标处包含删除到结束下标处排他的字符串sb.reverse();//反转字符串int len sb.length();System.out.println(字符串长度为 len);//321321System.out.println(sb.toString());}
}2.4 深入String – 面试题 常量池概念 Java运行时会维护一个常量池 常量池用来存放运行时中产生的各种字符串并且池中的字符串的内容不重复。 public class Test04 {public static void main(String[] args) {//面试题描述下列代码会创建几个String对象//答案1个常量池中的数据不允许重复//没有new对象//只是记录字面值常量会在常量池中开辟一个对象abc 0x01//所以只有1个
// String str1 abc;
// String str2 abc;
// System.out.println(str1);
// System.out.println(str2);//面试题描述下列代码会创建几个String对象//答案3个new了两个String对象 abc//new 对象 会在堆中开辟内存空间str1 0x001str2 0x002//字面值常量会在常量池中开辟一个对象abc 0x01//所以有3个String str1 new String(abc);String str2 new String(abc);System.out.println(str1);System.out.println(str2);}
}关于字符串的小扩展 1.字符串存储的内存原理 String s “abc”直接赋值 特点 此时字符串abc是存在字符串常量池中的。 先检查字符串常量池中有没有字符串abc如果有不会创建新的而是直接复用。如果没有abc才会创建一个新的。 所以直接赋值的方式代码简单而且节约内存。 2.new出来的字符串 看到new关键字一定是在堆里面开辟了一个小空间。 String s1 new String“abc” String s2 “abc” s1记录的是new出来的在堆里面的地址值。 s2是直接赋值的所以记录的是字符串常量池中的地址值 2.5 深入String创建对象 两个常量在编译时直接拼接 两个常量在编译时直接拼接 有变量参与字符串拼接的情况底层会创建StringBuilder进行拼接 new StringBuilder(String.value(s3)).append(s4).toString(); -- 先创建StringBuilder对象再进行拼接 public class Test05 {public static void main(String[] args) {String str1 abc;String str2 abc;System.out.println(str1 str2);//true//注意两个常量在编译时直接拼接String str3 ab c;//String str3 abc;System.out.println(str1 str3);//true//注意两个常量在编译时直接拼接final String s1 ab; //常量final String s2 c; //常量String str4 s1 s2;//String str3 abc;System.out.println(str1 str4);//注意有变量参与字符串拼接的情况底层会创建StringBuilder进行拼接String s3 ab; //变量String s4 c; //变量String str5 s3s4;//new StringBuilder(String.value(s3)).append(s4).toString();System.out.println(str1 str5);//false}
}注意 常量在程序执行过程中不可发生改变的量 常量的分类数字字面量、字面值常量、final修饰的变量 2.6.1 创建字符串对象两种方式的区别 通过构造方法创建 通过 new 创建的字符串对象每一次 new 都会申请一个内存空间虽然内容相同但是地址值不同直接赋值方式创建 以“ ”方式给出的字符串只要字符序列相同(顺序和大小写)无论在程序代码中出现几次JVM 都只会建立一个 String 对象并在字符串池中维护 2.6 StringBuilder 和 StringBuffer的底层原理 注意 1.StringBuffer和StringBuilder都是继承的AbstractStringBuilder 2.StringBuffer和StringBuilder的核心功能都是由父类使用 3.StringBuffer在方法中上锁、解锁 – 在多线程下使用 4.StringBuffer和StringBuilder相比因为有了上锁和解锁的步骤所以效率没有StringBuilder高 public class Test06 {public static void main(String[] args) {//StringBuilder的功能StringBuffer sb new StringBuffer();sb.append(xxx);sb.append(yyy);sb.append(zzz);System.out.println(sb); //StringBuilder的功能
// StringBuilder sb new StringBuilder();
// sb.append(xxx);
// sb.append(yyy);
// sb.append(zzz);
// System.out.println(sb); }
}AbstractStringBuilder底层代码 import java.util.Arrays;abstract class MyAbstractStringBuilder {//缓存数组char[] value;//存储字符个数int count;MyAbstractStringBuilder() {}MyAbstractStringBuilder(int capacity) {value new char[capacity];}//获取字符个数public int length() {return count;}public MyAbstractStringBuilder append(String str) {//如果添加的字符串为nullif (str null)return appendNull();int len str.length();ensureCapacityInternal(count len);str.getChars(0, len, value, count);count len;return this;}//添加字符串为null的情况private MyAbstractStringBuilder appendNull() {int c count;//判断是否扩容的方法ensureCapacityInternal(c 4);//4 - null.length()final char[] value this.value;value[c] n;value[c] u;value[c] l;value[c] l;count c;return this;}//判断是否扩容private void ensureCapacityInternal(int minimumCapacity) {// 有溢出意识的代码容量必须大于缓存数组的长度才扩容if (minimumCapacity - value.length 0) {value Arrays.copyOf(value,newCapacity(minimumCapacity));}}//计算新的长度private int newCapacity(int minCapacity) {// 扩容机制原来的长度*2 2int newCapacity (value.length 1) 2;//为什么2的原因怕用户设置初始化数组长度为001还是0就得不到扩容return newCapacity;}}StringBuilder底层代码 public class MyStringBuilder extends MyAbstractStringBuilder{public MyStringBuilder() {super(16);//默认缓冲数组长度为16}public MyStringBuilder(int capacity) {super(capacity);//自定义缓冲数组的长度}public MyStringBuilder(String str) {super(str.length() 16);//自定义缓冲数组的长度字符串长度16append(str);//追加字符串}Overridepublic MyStringBuilder append(String str) {super.append(str);//依赖于父类的appendreturn this;}
}StringBuffer底层代码 public class MyStringBuffered extends MyAbstractStringBuilder{public MyStringBuffered() {super(16);//默认缓冲数组长度为16}public MyStringBuffered(int capacity) {super(capacity);//自定义缓冲数组的长度}public MyStringBuffered(String str) {super(str.length() 16);//自定义缓冲数组的长度字符串长度16append(str);//追加字符串}//synchronized - 线程安全的方法Overridepublic synchronized MyStringBuffered append(String str) {//上锁super.append(str);//依赖于父类的appendreturn this;}//解锁
}2.7 StringBuilder 和 StringBuffer的构造方法 StringBuilder/StringBuffer代表可变的字符序列 StringBuilder/StringBuffer称为字符串缓冲区 它的工作原理是预先申请一块内存(char[] value new char[])存放字符序列 如果字符序列满了会重新改变缓存区的大小以容纳更多的字符序列(扩容机制原来数组长度的两倍2)。 StringBuilder/StringBuffer是可变对象因为char[] value new char[]; String是不可变的对象因为final char[] value new char[]; public class Test07 {public static void main(String[] args) {//缓冲区默认长度16个字符//StringBuffer sb new StringBuffer();//自定义缓冲长度100个字符//StringBuffer sb new StringBuffer(100);//自定义缓冲长度abc.length() 16
// StringBuffer sb new StringBuffer(abc);
// System.out.println(sb);System.out.println(-------------);//缓冲区默认长度16个字符//StringBuilder sb new StringBuilder();//自定义缓冲长度100个字符//StringBuilder sb new StringBuilder(100);//自定义缓冲长度abc.length() 16
// StringBuilder sb new StringBuilder(abc);
// System.out.println(sb);System.out.println(-------------);//底层有两个字符串“abc”,abcdString str abc;str abcd;System.out.println(str);//底层只有一个缓存数组StringBuilder sb new StringBuilder();sb.append(abc);sb.append(c);System.out.println(sb);}
}2.8 频繁拼接字符串使用StringBuilder/StringBuffer
public class Test08 {public static void main(String[] args) {//获取自1970年1月1日0:0:0 到现在的毫秒数1000毫秒 1秒//long currentTimeMillis System.currentTimeMillis();// long startTime System.currentTimeMillis();
// String str 莹莹;
// for (int i 1; i 50000; i) {
// str 小可爱皇冠给你带;//底层实现// str str 小可爱皇冠给你带;// str new StringBuidler(str).append(小可爱皇冠给你带);
// }
// long endTime System.currentTimeMillis();
// System.out.println(消耗时长 (endTime-startTime));//6640System.out.println(--------------------------------------------);// long startTime System.currentTimeMillis();
// StringBuffer sb new StringBuffer(莹莹);
// for (int i 1; i 50000; i) {
// sb.append(小可爱皇冠给你带);
// }
// long endTime System.currentTimeMillis();
// System.out.println(消耗时长 (endTime-startTime));//5System.out.println(--------------------------------------------);long startTime System.currentTimeMillis();StringBuffer sb new StringBuffer(450060);//优化方案减少底层扩容次数sb.append(莹莹);for (int i 1; i 50000; i) {sb.append(小可爱皇冠给你带);}long endTime System.currentTimeMillis();System.out.println(消耗时长 (endTime-startTime));//5}
}3.正则表达式 理解符合某个语句规范的字符串 逻辑运算符 并且 | 或者 \ 转义字符 预定义字符 “.” 匹配任何字符。 “\d”任何数字[0-9]的简写 “\D”任何非数字[^0-9]的简写 “\s” 空白字符[ \t\n\x0B\f\r] 的简写 “\S” 非空白字符[^\s] 的简写 “\w”单词字符[a-zA-Z_0-9]的简写 “\W”非单词字符[^\w] 预定义字符 “.” 匹配任何字符。 “\d”任何数字[0-9]的简写 “\D”任何非数字[^0-9]的简写 “\s” 空白字符[ \t\n\x0B\f\r] 的简写 “\S” 非空白字符[^\s] 的简写 “\w”单词字符[a-zA-Z_0-9]的简写 “\W”非单词字符[^\w] 分组括号( ) 只看左括号不看有括号按照左括号的顺序从左往右依次为第一组第二组第三组等等 3.1 利用正则表达式做替换 案例把一个字符串中带电话号码替换成130****1111 public class Test01 {public static void main(String[] args) {String str 小红13012341111 小绿15112342222 小黑13912343333;String regex (1\\d{2})(\\d{4})(\\d{4});str str.replaceAll(regex, $1****$3);//$n保留第几组正则表达式里的数据System.out.println(str);}
} 3.2 利用正则表达式做验证 案例校验QQ邮箱 public class Test02 {public static void main(String[] args) {String email 1445584980qq.com;String regex \\d{4,11}qq.com;boolean matches email.matches(regex);System.out.println(matches);}
} 3.3 利用正则表达式做字符串的分割 案例分隔路径 public class Test03 {public static void main(String[] args) {String str C:\\资源\\日韩\\波多野结衣.avi;//:?表示冒号出现1次或0次String regex :?\\\\;//分割 :\\ 或 \\String[] split str.split(regex);for (String string : split) {System.out.println(string);}}
} 3.4 利用正则表达式做字符串的爬数据的工作 Pattern表示正则表达式 Matcher文本匹配器作用按照正则表达式的规则去读取字符串从头开始读取。 在大串中去找符合匹配规则的子串。 案例PatternMatcher 找到前端代码中的图片路径 import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Test04 {public static void main(String[] args) {String str img srchhy/aaa.jpg/divdiv/ input typeimage srcsubmit.gif /img srcbbb.jpg/;String regex img\\b[^]*\\bsrc\\b\\s*\\s*(|\)?([^\\n\r\f](\\.jpg)\\b)[^]*;//获取正则表达式对象Pattern pattern Pattern.compile(regex);//获取匹配结果Matcher matcher pattern.matcher(str);//循环遍历匹配结果while(matcher.find()){//获取匹配结果String group matcher.group(2);//2表示第2组数据System.out.println(group);}}
} 4.日期时间类 Datejava.util – 日期类 SimpleDateFormat – 格式化日期类 Calendar – 日历类 4.1 Date 日期类 java.util.Date类表示特定的瞬间精确到毫秒 public class Test01 {public static void main(String[] args) {Date date new Date();//星期 月份 日期 时:分:秒 时区 年份//Sat Jan 27 14:31:41 CST 2024System.out.println(date);}
}4.2 SimpleDateFormat 格式化日期类 将显示的日期信息格式化 import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class Test02 {public static void main(String[] args) throws ParseException {SimpleDateFormat sdf new SimpleDateFormat(yyyy年MM月dd日 HH时mm分ss秒);//Date 转 StringString datetime sdf.format(new Date());System.out.println(datetime);//String 转 Date Date date sdf.parse(2024年01月27日 14时37分61秒);System.out.println(date);}
}4.3 Calendar 日历类 Calendar类(日历)是一个抽象基类主要用于完成日期字段之间相互操作的功能。即可以设置和获取日期数据的特定部分。 import java.util.Calendar;public class Test03 {public static void main(String[] args) {//获取当前系统的日历对象Calendar c Calendar.getInstance();int year c.get(Calendar.YEAR);int month c.get(Calendar.MONTH)1;//注意月份0~110表示1月所以加个1int day c.get(Calendar.DAY_OF_MONTH);int hour c.get(Calendar.HOUR);int minute c.get(Calendar.MINUTE);int second c.get(Calendar.SECOND);System.out.println(year);System.out.println(month);System.out.println(day);System.out.println(hour);System.out.println(minute);System.out.println(second);}
}小结 Date SimpleDateFormat一起使用获取我们想要的日期时间格式 获取单个日历信息考虑使用Calendar 5.Math类 Math 类提供了一序列基本数学运算和几何函数的方法 Math类是final类并且它的所有成员变量和成员方法都是静态的。 public class Test01 {public static void main(String[] args) {System.out.println(求次方 Math.pow(3, 2));//9.0System.out.println(求平方根 Math.sqrt(9));//3.0System.out.println(求绝对值 Math.abs(-100));//100System.out.println(求最大值 Math.max(10, 20));//20System.out.println(求最小值 Math.min(10, 20));//10System.out.println(向下取整地板 Math.floor(1.9));//1.0System.out.println(向上取整天花板 Math.ceil(1.1));//2.0System.out.println(四舍五入 Math.round(1.5));//2System.out.println(获取随机值 Math.random());//注意随机出0~1的数字0包含1排他//需求随机出1~100的数字int num (int)(Math.random()*100)1;System.out.println(获取随机值 num);}
}面试题Math.abs会出现负数吗 会出现负数 -- -2147483648(极限) public class Test02 {public static void main(String[] args) {//获取int类型的最大值 - 2147483647 -- 2的31次方-1System.out.println(Integer.MAX_VALUE);//获取int类型的最小值 - -2147483648 - -2的31次方System.out.println(Integer.MIN_VALUE);//面试题Math.abs会出现负数吗//会出现负数 -- -2147483648System.out.println(Math.abs(-2147483648));}
}5.1 静态导入 理解将类中所有的静态属性和方法都导入到本类来作为本来自己的静态属性和方法 缺点如果类中的方法和静态导入类中的方法重名了会调用本类自己的静态方法所以可读性差不建议使用 //静态导入将类中所有的静态属性和方法都导入到本类来作为本来自己的静态属性和方法
import static java.lang.Math.*;public class Test03 {public static void main(String[] args) {System.out.println(求次方 pow(3, 2));//9.0System.out.println(求平方根 sqrt(9));//3.0}public static int sqrt(int i){return 123456;}
}6.Random 理解随机类 import java.util.Random;public class Test01 {public static void main(String[] args) {Random ran new Random();System.out.println(随机出int取值范围里的数值 ran.nextInt());System.out.println(随机出0~9的int数值 ran.nextInt(10));System.out.println(随机出double取值范围里的数值 ran.nextDouble());System.out.println(随机出boolean取值范围里的数值 ran.nextBoolean());}
}6.1 深入Random 注意seed叫做种子数种子数一旦固定随机出的数字就是固定的 MyRandom myRandom new MyRandom(种子数); 为空可随机有了具体的数值不可随机 import java.util.Random;public class Test02 {public static void main(String[] args) {Random ran new Random(1000);System.out.println(随机出int取值范围里的数值 ran.nextInt());System.out.println(随机出0~9的int数值 ran.nextInt(10));System.out.println(--------------------);MyRandom myRandom new MyRandom();System.out.println(随机出int取值范围里的数值 myRandom.nextInt());System.out.println(随机出0~9的int数值 myRandom.nextInt(10));}
}Random底层代码 public class MyRandom {//种子数private long seed;public MyRandom() {this(seedUniquifier() ^ System.nanoTime());}private static long seedUniquifier() {for (;;) {long current System.currentTimeMillis();long next current * 181783497276652981L;if (next%30 || next%120 || next%170){return next;}}}public MyRandom(long seed) {this.seed seed;}public int nextInt(){return (int) seed;}public int nextInt(int bound){return Math.abs((int) seed)%bound;}
}7.Runtime 理解Runtime表示运行时系统(JVM) Runtime代表Java程序的运行时环境可以通过 getRuntime 方法获取当前运行时。 应用程序不能自己创建Runtime对象可以通过Runtime的静态方法getRuntime()获得Runtime对象。 Runtime类可以访问jvm的相关信息如处理器数量内存信息等 public class Test01 {public static void main(String[] args) {//获取运行时系统对象Runtime run Runtime.getRuntime();System.out.println(获取最大操作数 run.availableProcessors());//8System.out.println(获取最大内存数(byte) run.maxMemory());System.out.println(获取闲置内存数(byte) run.freeMemory());}
}7.1 程序的效率时间、内存
public class Test02 {public static void main(String[] args) {// Runtime run Runtime.getRuntime();
// long startTime System.currentTimeMillis();
// long startMemory run.freeMemory();
// String str 莹莹;
// for (int i 1; i 50000; i) {
// str 小可爱皇冠给你带;
// }
// long endMemory run.freeMemory();
// long endTime System.currentTimeMillis();
// System.out.println(消耗时长 (endTime-startTime));//6640
// System.out.println(消耗内存 (startMemory-endMemory));System.out.println(--------------------------------------------);// Runtime run Runtime.getRuntime();
// long startTime System.currentTimeMillis();
// long startMemory run.freeMemory();
// StringBuffer sb new StringBuffer(莹莹);
// for (int i 1; i 50000; i) {
// sb.append(小可爱皇冠给你带);
// }
// long endMemory run.freeMemory();
// long endTime System.currentTimeMillis();
// System.out.println(消耗时长 (endTime-startTime));//5
// System.out.println(消耗内存 (startMemory-endMemory));//2293808System.out.println(--------------------------------------------);Runtime run Runtime.getRuntime();long startTime System.currentTimeMillis();long startMemory run.freeMemory();StringBuffer sb new StringBuffer(450060);//优化方案减少底层扩容次数sb.append(莹莹);for (int i 1; i 50000; i) {sb.append(小可爱皇冠给你带);}long endMemory run.freeMemory();long endTime System.currentTimeMillis();System.out.println(消耗时长 (endTime-startTime));//5System.out.println(消耗内存 (startMemory-endMemory));//900136}
}
8.System 理解 1、System类提供了一些静态属性和方法允许通过类名直接调用 2、System类提供了代表标准输入、标准输出、错误输出的类属性 3、System类提供了一些静态方法用于访问环境变量、系统属性的方法 8.1 System - 属性 err“标准”错误输出流 in“标准”输入流 out“标准”输出流 import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;public class Test01 {public static void main(String[] args) {//获取系统标准的输入流 - 方向控制台-程序InputStream in System.in;Scanner scan new Scanner(in);System.out.println(请输入int值);int num scan.nextInt();//获取系统标准的输出流 - 方向程序 - 控制台
// PrintStream out System.out;
// out.println(num);//获取系统标准的错误输出流 - 方向程序 - 控制台PrintStream err System.err;err.println(num);scan.close();}
}8.2 System.out和System.err的区别 注意稍微感受多线程抢资源的场景 public class Test02 {public static void main(String[] args) {System.out.println(小明);System.err.println(小红);System.out.println(小强);}
} 运行结果 小明 小明 小红 小明 小红 小强 小明 小强小红 小强 小红 小强 ···· 8.3 System - 方法 public static void *exit*(int status) 退出当前虚拟机 public static long *currentTimeMillis*() 获得当前系统的毫秒值(与1970 年 1 月 1 日午夜之间的时间差)–测试程序的消耗时间 public static Properties *getProperties*() 获得当前的所有系统属性 public static String *getProperty*(String key) 获得指定键的系统属性 public static void *setIn*(InputStream in) 输入重定向 public static void *setOut*(PrintStream out) 输出重定 publ****ic static void setErr****(PrintStream err) 错误重定向 public static void arraycopy([Object](mk:MSITStore:C:\Users\hehanyu\Desktop\jdk api 1.8_google.CHM::/java/lang/…/…/java/lang/Object.html) src,int srcPos, [Object](mk:MSITStore:C:\Users\hehanyu\Desktop\jdk api 1.8_google.CHM::/java/lang/…/…/java/lang/Object.html) dest, int destPos, int length) 拷贝数组 import java.util.Properties;public class Test03 {public static void main(String[] args) {long currentTimeMillis System.currentTimeMillis();System.out.println(获取自1970年1月1日到现在的毫秒数 currentTimeMillis);//获取系统参数Properties properties System.getProperties();System.out.println(properties);//通过具体Key获取对应的ValueString property System.getProperty(os.name);System.out.println(通过具体Key获取对应的Value property);//拷贝数组int[] arr {1,2,3,4,5,6,7,8,9,10};int[] newArr new int[4];System.arraycopy(arr, 3, newArr, 0, 4);//(源数组开始下标目标数组开始下标拷贝长度)for (int num : newArr) {System.out.println(num);}//利用System.arraycopy做数组的删除功能String[] names {aaa,bbb,ccc,ddd,eee,fff,null,null,null}; System.arraycopy(names, 2, names, 1, 4);names[5] null;for (String str : names) {System.out.println(str);}//退出当前虚拟机0表示正常退出System.exit(0);}
}9.大数值运算类
9.1 BigInteger - 整数的大数值运算类 BigInteger: 能表示比Integer更大的数字 import java.math.BigInteger;public class Test01 {public static void main(String[] args) {BigInteger big1 new BigInteger(2100000000);BigInteger big2 new BigInteger(2100000000);BigInteger add big1.add(big2);System.out.println(加法 add);BigInteger subtract big1.subtract(big2);System.out.println(减法 subtract);BigInteger multiply big1.multiply(big2);System.out.println(乘法 multiply);BigInteger divide big1.divide(big2);System.out.println(除法 divide);}
}
9.2 BigDecimal - 小数大数值运算类 注意 1.小数做运算会失去精度所以小数做运算都要生成大数值的运算类 2.构造方法里的值使用字符串 import java.math.BigDecimal;public class Test02 {public static void main(String[] args) {BigDecimal big1 new BigDecimal(0.5);BigDecimal big2 new BigDecimal(0.4);BigDecimal add big1.add(big2);System.out.println(加法 add);BigDecimal subtract big1.subtract(big2);System.out.println(减法 subtract);BigDecimal multiply big1.multiply(big2);System.out.println(乘法 multiply);BigDecimal divide big1.divide(big2);System.out.println(除法 divide);}
}import java.math.BigDecimal;public class Test03 {public static void main(String[] args) {BigDecimal big1 new BigDecimal(10);BigDecimal big2 new BigDecimal(3);BigDecimal divide big1.divide(big2, 3, BigDecimal.ROUND_HALF_UP);System.out.println(除法 divide);}
}总结 1.包装类 注意 1.装箱、拆箱 2.Integer的底层原理 2.字符串的类 注意字符串类的深入 3.正则表达式 - 了解 4.日期时间类 Math 注意静态导入的概念 6.Random 注意种子数 7.System 注意理解System.out和System.err多线程抢资源 8.Runtime 9.大数值运算类
