21天学通Java学习笔记-Day11(常用类)
java 常用类（重点）：
String 类：
String 类代表字符串。创建以后不能更变。
public class tests {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "hello";
System.out.println(s1==s2);//true,指向String池中的同一块内存
s1 = new String("hello");
s2 = new String("hello");
System.out.println(s1==s2); //false,两个不同的对象
System.out.println(s1.equals(s2)); //true,String类重写了Object类的equals方法，内容相同就相等
char[] c = {'s','u','n',' ','j','a','v','a'};
s1 = new String(c); //将一个字符数组赋值给一个字符串
s2 = new String(c,4,4); //截取字符数组的一部分赋值给字符串（从c中第4个字符开始截取4个）
System.out.println(s1); //sun java
System.out.println(s2); //java
}
}
String 类常用方法：
char chasrAt( int index )返回字符串中第index个字符( 字符串实际是一个字符数组)
int length( ) 返回字符串长度
int indexOf( String str, int fromIndex ) 返回字符串从 fromIndex 开始出现 str 的第一个位置
boolean equalsIgnoreCasr( String another ) 比较字符串与 another 是否一样（忽略大小写）
String replace( charoldChar, char newChar ) 在字符串中用 newChar 字符替换 oldChar 字符
boolean startsWith( String prefix ) 判断字符串是否以 prefix 字符串开头
boolean endsWith( String suffix ) 判断字符串是否以 suffix 字符串结尾
String toUpperCase( ) 返回字符串大写形式
String toLowerCase( ) 返回字符串小写形式
String substring( int beginIndex ) 返回该字符串从 beginIndex 开始到结尾的字符串
String substring( int beginIndex, int endIndex ) 返回该字符串从 beginIndex 开始到 endIndex 结尾的子字符串
String trim( ) 返回该字符串去掉开头和结尾空格的字符串
String value Of( ...... ) 可以将基本类型（对象类型）装换为字符串类型（相当于调用toString( )方法）
String[ ] split( String regex ) 可以将一个字符串按照指定的分隔符 regex 分隔成一个个子串，放进一个字符串数组中
StringBuffer 类：
StringBuffer 类代表可变字符序列。
StringBuffer 常用方法：
StringBuffer append( ...... ) 参数可以是基本类型，String，StringBuffer，char数组，对象类型，可以为该 StringBuffer 对象添加字符串序列，返回添加后的该StringBuffer对象引用
StringBuffer insert( int offset , ...... ) 参数可以是基本类型，String，StringBuffer，char数组，对象类型，可以为该 StringBuffer 对象在指定位置插入字符序列，返回修改后的该StringBuffer对象引用
Stringuffer delete( int start , int end ) 可以删除 start 开始到 end-1 为止的一段字符序列，返回修改后的该 StringBuffer 对象引用
StringBuffer reverse( ) 将字符序列逆序排列
枚举类 ：
java.lang.Enum 枚举类型
使用关键字 enum
public class TestEnum {
public enum MyColor { red, green, blue };
public enum MyDoorOpener { me, mywife };
public static void main(String[] args) {
MyColor m = MyColor.red;
switch(m) {
case red:
System.out.println("red");
break;
case green:
System.out.println("green");
break;
default:
System.out.println("default");
}
System.out.println(m);
}
}
日期类：
格式化日期：
import java.text.*;
import java.util.*;
public class testd {
public static void main(String[] args)throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日"); //以这种模式格式化日期
Date d = new Date(); //获得当前时间
System.out.println(sdf.format(d)); //将日期以指定模式输出
}
}
System.currentTimeMillis( ) 返回从1970年1月1日零时开始到当前以毫秒为单位的时间。
将String类型转换为日期类型：
import java.sql.*;
public class testd {
public static void main(String[] args)throws Exception {
String s = "1990-11-12 08:24:27";
Timestamp ts = Timestamp.valueOf(s);
System.out.println(ts);
}
}
正则表达式：
用途：1. 字符串匹配（字符匹配）；2. 字符串查找；3. 字符串替换
类：1. java.lang.String；2. java.util.regex.Pattern ; 3. java.util.regex.Matcher
java.lang.String 类中与正则表达式相关的方法：
boolean matches( String regex ) 告知这个字符串是否匹配给定的正则表达式。
String replaceAll( String regex , String replacement ) 使用给定的 replacement 替换这个字符串匹配给定的正则表达式的子字符串。
String replaceFirst( String regex , String replacement ) 使用给定的 replacement 替换这个字符串匹配给定的正则表达式的第一个子字符串。
String[ ] split( String regex ) 根据给定正则表达式的匹配拆分此字符串。
String[ ] split( String regex , int limit ) 根据匹配给定的正则表达式来拆分这个字符串。
public class testd {
public static void main(String[] args)throws Exception {
System.out.println("abc".matches("...")); //true, .代表任何字符
System.out.println("a56t879a".replaceAll("\\d","-")); //a--t--a, \\d 代表一个数字
}
}
import java.util.regex.*;
public class testd {
public static void main(String[] args)throws Exception {
Pattern p = Pattern.compile("[a-z]{3}"); //compile()方法：返回在其中编译过此模式的正则表达式。
Matcher m = p.matcher("fgh"); //matcher()方法：创建匹配给定输入与此模式的匹配器。
System.out.println(m.matches()); //matches()方法:尝试将整个区域与模式匹配，当且仅当整个区域序列匹配此匹配器的模式时才返回 true。
}
}
关于 . * + ? 的例子代码：
import java.util.regex.*;
public class testd {
public static void main(String[] args)throws Exception {
print("a".matches(".")); //. 所有字符
print("aa".matches("a*")); //* a出现零次或者多次
print("aaa".matches("a+")); //+ a出现一次或者多次
print("a".matches("a?")); //？ a出现零次或者一次
print("".matches("a*")); //* a出现零次或者多次
print("".matches("a?")); //？ a出现零次或者一次
print("2134567898767895".matches("\\d{3,20}")); // \\d{ ，} 数字出现最少3次，最多20次
print("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\D{1,3}")); // \\. 代表点，\\D 代表非数字
print("192".matches("[0-2][0-9][0-9]")); // [ ] 范围 ，一个[]只匹配一个字符
}
public static void print(Object b){
System.out.println(b);
}
}
关于[ ] 例子代码：
import java.util.regex.*;
public class testd {
public static void main(String[] args)throws Exception {
print("a".matches("[abc]")); //范围 abc
print("a".matches("[^abc]")); //范围 非abc，^ 为取反
print("A".matches("[a-z]|[A-Z]")); //范围 a-z或者A-Z
print("A".matches("[a-z[A-Z]]")); //范围 a-z或者A-Z
print("R".matches("[A-Z&&[RFG]]")); //范围 A-Z 并且在 RFG 中
}
public static void print(Object b){
System.out.println(b);
}
}
关于 \\d , \\D , \\s , \\S , \\w , \\W
import java.util.regex.*;
public class testd {
public static void main(String[] args)throws Exception {
print(" ".matches("\\s")); // \\s 表示空字符
print("a".matches("\\S")); // \\S 非空字符
print("5w".matches("\\w{2}")); // \\w 单词字符(范围[a-zA-Z_0-9]字母加下划线加数字) {3} 正好出现三次
print("1qazxsw2".matches("\\W{2,7}")); // \\W 非单词 {2 , 7}最少出现2次，最多出现7次
print("R".matches("\\D")); // \\D 非数字
print("3".matches("\\d")); // \\d 数字
print("\\".matches("\\\\")); // 匹配一个反斜杠"\\" ， 需要"\\\\"
}
public static void print(Object b){
System.out.println(b);
}
}
关于边界符 ^ , $ , \\b 例子代码：
import java.util.regex.*;
public class testd {
public static void main(String[] args)throws Exception {
print("hello world".matches("^he.*")); // ^ 表示以什么开头
print("hello java".matches(".*va$")); // $ 表示以什么结尾
print("hello sir".matches("^h[a-z]{1,3}o\\b.*r$")); // \\b 表示单词边界（空格，换行等符号）
}
public static void print(Object b){
System.out.println(b);
}
}
邮箱匹配的正则表达式：
import java.util.regex.*;
public class testd {
public static void main(String[] args)throws Exception {
String email1 = "[email protected]";
String email2 = "[email protected]";
print(email1.matches("[\\w[.-]]+@[\\w[.-]]+.[\\w]+"));
print(email2.matches("[\\w[.-]]+@[\\w[.-]]+.[\\w]+"));
}
public static void print(Object b){
System.out.println(b);
}
}
分组：
import java.util.regex.*;
public class testd {
public static void main(String[] args)throws Exception {
Pattern p = Pattern.compile("(\\d{1,5})([a-z]{3})"); //用小括号表示分组，一个小括号表示一个分组，根据左小括号表示是第几个分组
String s = "123aaa-4567bbb-89ccc-000";
Matcher m = p.matcher(s);
while(m.find()) { //find() 尝试查找与该模式匹配的输入序列的下一个子序列。
print(m.group(1)); //group() 返回由以前匹配操作所匹配的输入子序列。 0 代表原来的字符，1代表第一个分组
}
}
public static void print(Object b){
System.out.println(b);
}
}
反射机制：
ClassLoader 的类加载机制
并非一次性加载，而是需要的时候加载（运行期间动态加载）
static 语句块在加载后执行一次
dynamic （动态）语句块每次 new 新的对象都会执行（等同于构造方法中的语句，用的较少）
public class testd {
public static void main(String[] args){
new A();
System.out.println("-------");
new B(); //new 出来才会加载
new C();
new C(); //static 内容只会加载一次
new D();
new D(); //动态语句每次都会加载
}
}
class A{
}
class B{
}
class C{
static {
System.out.println("CCCCCCC");
}
}
class D{
{
System.out.println("DDDDDD");
}
}
public class testd {
public static void main(String[] args)throws Exception{
String s = "T";
Class c = Class.forName(s); // forName( )回与带有给定字符串名的类或接口相关联的 Class 对象
c.newInstance(); // newInstance( ) 创建此 Class 对象所表示的类的一个新实例。
}
}
class T{
static {
System.out.println("T loaded");
}
public T() {
System.out.println("T constructed!");
}
}