1Object类
Object() 默认构造方法
clone() 创建并返回此对象的一个副本。
equals(Object obj) 指示某个其他对象是否与此对象“相等”
getClass() 返回一个对象的运行时类
hashCode() 返回该对象的哈希码值
toString() 返回该对象所在的类名和哈希码值。
equals(Object obj):判断两个对象是否指向同一块内存区域。和==的区别,基本数据类型之间==比较的是他们的数值,符合数据类型之间==比较的是他们在内存中的存放地址。String和Date类等对equals进行重写,比较的是对象的内容。
public class test{
public static void main(String[] args){
int a = 3;
int b = 3;
Integer c = 3;
Integer d = 3;//自动装箱。c、d堆地址指向相同的常量池,堆地址也相同
//指向相同常量池,没有new则堆地址相同。
Integer e = 4;
Integer f = new Integer(4);//新建堆空间,再指向常量池。f在内存中有两个对象,分别在方法区的常量池和堆中。
String g = "hello";
String h = new String("hello");
String i = h;//引用拷贝,i、h在栈中指向同一个堆地址
System.out.println(a == b);//true
System.out.println(a == c);//true
System.out.println(c == d);//true
System.out.println(c == f);//false
System.out.println(c.equals(b));//true
System.out.println(c.equals(d));//true
System.out.println(c.equals(f));//false
//System.out.println(a.equals(b));//报错
System.out.println(c.equals(e));//false
System.out.println(g == h);//false
System.out.println(g.equals(h));//true
System.out.println(i == h);//true
System.out.println(i.equals(h));//true
h = "hi";
//深拷贝:引用对象的值等信息,复制一份一样的。
//浅拷贝:只复制引用,另一处修改,你当下的对象也会修改。
//浅拷贝:能复制变量,如果对象内还有对象,则只能复制对象的地址,意味着两个内部对象为一个对象。
//深拷贝:能复制变量,也能复制当前对象的内部对象,对内部对象修改只会影响一个
System.out.println(i);
System.out.println(h);
System.out.println(i == h);//false
System.out.println(i.equals(h));//false。这里是深拷贝。其实拷贝分为引用拷贝和对象拷贝,对象拷贝才分深拷贝和浅拷贝。
}
}
import java.io.*;
import java.util.regex.*;
public class CheckQQDemo
{
public static void main(String[] args) throws Exception
{
String h = new String("hello");
String i = h;//引用拷贝,i、h在栈中指向同一个堆地址
System.out.println(i.equals(h));
System.out.println(String.class.getName() + "@" + Integer.toHexString(System.identityHashCode(h)));
System.out.println(String.class.getName() + "@" + Integer.toHexString(System.identityHashCode(i)));
//true
//java.lang.String@15db9742 堆地址
//java.lang.String@15db9742
h = "hi";//相当于= new String("hi");
System.out.println(i.equals(h));
System.out.println(String.class.getName() + "@" + Integer.toHexString(System.identityHashCode(h)));
System.out.println(String.class.getName() + "@" + Integer.toHexString(System.identityHashCode(i)));
String g = new String("hello");
System.out.println(String.class.getName() + "@" + Integer.toHexString(System.identityHashCode(g)));
String z = "hi";
System.out.println(String.class.getName() + "@" + Integer.toHexString(System.identityHashCode(z)));
//false
//java.lang.String@6d06d69c. h(和i值不同,地址也不同)
//java.lang.String@15db9742. i
//java.lang.String@7852e922. g(和h的值相同,地址不同)
//java.lang.String@6d06d69c. z(和h值相同,地址也相同)
}
}
2System类
public final class System extends Object
System类所有属性都是静态的,类名.进行访问。System类是公共最终类,不能被继承,也不能被实例化,因为构造函数是私有的。
/** Don't let anyone instantiate this class */
private System() {
}
System.gc():垃圾收集机制,内部调用 Runtime.getRuntime().gc()
currentTimeMillis():返回以毫秒为单位的当前时间
exit(int status):系统退出 ,如果status为0就表示退出
arraycopy(Object src, int srcPos, Object dest, int desPos, int length) :数组拷贝操作
getProperties() :取得当前系统的全部属性
getProperty(String key) :根据键值取得属性的具体内容
3String、StringBuffer类
public final class String extends Object implements Serializable, Comparable<String>, CharSequence
public final class StringBuffer extends Object implements Serializable, CharSequence
字符串是常量对象(和常数一样,放在常量池中,可以被共享),值在创建后不能修改,变量指向可以变;字符串缓冲区支持可变的字符串,即值可以变。Java不允许程序员重载任何操作符,但用于String类的“+”和“+=”,两个符号被重载过(写元源码的人改的)。
public class test{
public static void main(String[] args){
String a = "字符串";
a = "更改";
System.out.println(a);//a
//a是引用数据类型可以更改(其指向),“字符串”被创建后不能更改
}
}
线程不同步StringBuilder
4包装类
基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型(数值类型)转字符串:
“5+5=”5+5 ---5+5=55
包装类对象.toString(值)
String.valueof(值) 静态方法
字符串转基本数据类型(数值类型):
包装类名.parse***(string) 静态方法
[***表示基础数据类型名,如parseInt,没有Character.parseChar]
基本数据类型转包装类:
包装类构造函数
自动装箱
包装类转基本数据类型:
包装类对象.***Value()
[***表示基础数据类型名,如intValue,没有Character.parseChar]
自动拆箱
public class test{
public static void main(String[] args){
int m = 5;
Integer o = m;//自动装箱。相当于new Integer(m);
int n = o;//自动拆箱。相当于o.intValue();
System.out.println(n);//5
System.out.println(o.equals(m));//true
}
}
字符串转包装类:
包装类构造函数参数可以接收String
public class test{
public static void main(String[] args){
String s = "5";
Integer i = new Integer(s);//5
//相当于Integer i = new Integer(Integer.parseInt(s));
System.out.println(i);
int m = 5;
System.out.println("5+5="+m+m);//5+5=55
}
}
包装类转字符串:
包装类对象.toString(空);
Integer o = new Integer(5);
System.out.println(o.toString());//5
5Math、Random、BigInteger、BigDecimal、Date、SimpleDateFormat、Calendar类
Math.ramdom() floor() ceil() round()
Random对象.next***(值/空)
BigDecimal("0.1") BigDecimal(0.1)
Date.getTime()//Date构造函数内部调用System.currentTimeMillis()
SimpleDateFormat对象.format(Date对象)
Calendar.getInstance()
Calendar.getTime()
6正则表达式
.,\d,\s,\w,\b,大写,[ ],^,X?,X+,X*,X{ },?i,?s,
用IO流和String类方法checkQQ:
import java.io.*;
public class CheckQQDemo{
public static void main(String[] args)throws Exception{
//throws Exception
//1.用缓存字符流
//BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
//String str = bf.readLine();//只有缓存流有readLine,相当于对char[]的封装
//boolean flag = checkQQ(str);
//2.用缓存字节流或字节流
//BufferedInputStream inputStream = (BufferedInputStream)System.in;
InputStream inputStream = System.in;
boolean flag = checkQQ1(inputStream);
System.out.println("此QQ号码为"+flag);
}
public static boolean checkQQ(String str) throws QQException{
/* 规则1:号码长度在4到11之间
规则2:应该是纯数字
规则3:首字母不为0
*/
boolean flag = true;
if (!(str.length()>=4&&str.length()<=11)){
flag = false;
throw new QQException("长度非法!");//或者直接打印错误
}
for(int i=0;i<str.length();i++){
if(!(str.charAt(i)>='0'&&str.charAt(i)<='9')){
flag = false;
throw new QQException("字符非法!");
}
}
if(str.startsWith("0")){
flag = false;
throw new QQException("首字符为0!");
}
return flag;
}
public static boolean checkQQ1(InputStream inputStream) throws IOException,QQException{
boolean flag = true;
byte[] buff = new byte[20];
int len;
while (((len = inputStream.read(buff)) != -1)) {
String str = new String(buff, 0, len - 2);//2代表windows的回车符\r\n
System.out.println("您输入的数据是:" + str + (len-2));
if (!(str.length()>=4&&str.length()<=11)){
flag = false;
throw new QQException("长度非法!");
}
for(int i=0;i<str.length();i++){
if(!(str.charAt(i)>='0'&&str.charAt(i)<='9')){
flag = false;
throw new QQException("字符非法!");
}
}
if(str.startsWith("0")){
flag = false;
throw new QQException("首字符为0!");
}
}
return flag;
}
}
class QQException extends Exception{
QQException(String str){
super(str);
}
}
用包装类检查是否为数字
try
{
long l = Long.parseLong(qq);
System.out.println("qq:"+l);
}
catch (NumberFormatException e)
{
System.out.println("出现非法字符.......");
}
用正则表达式检查 QQ:
import java.io.*;
public class CheckQQDemo
{
public static void main(String[] args) throws Exception
{
BufferedReader fr = new BufferedReader(new InputStreamReader(System.in));
String qq = fr.readLine();
String regex = "[1-9]\\d{4,14}";//5-15位QQ
boolean flag = qq.matches(regex);
if(flag)
System.out.println(qq+"...is ok");
else
System.out.println(qq+"... 不合法");
}
}
正则表达式检查邮箱:
import java.io.*;
public class CheckQQDemo
{
public static void main(String[] args) throws Exception
{
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String s = "\\w+@\\w+(\\.\\w+)+";
//jht@hpu.edu.cn
//1958262680@qq.com
String t = b.readLine();
System.out.println(t.matches(s));
}
}
java正则表达其他语言一个斜杠需要两个,一个斜杠。其他语言\\,java\\\\
import java.io.*;
import java.util.regex.*;
public class CheckQQDemo
{
public static void main(String[] args) throws Exception
{
//1用String的matches方法匹配,返回boolean。
//BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
//String s = "\\+\\w+@\\w+(\\.\\w+)+\\\\";
//jht@hpu.edu.cn
//1958262680@qq.com
//String t = b.readLine();
//System.out.println(t.matches(s));
//--------------------------------
//2用Pattern的matcher方法匹配,返回一个Matcher对象可以进行具体操作。find,group
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String t = b.readLine();
String s = "\\+\\w+@\\w+(\\.\\w+)+\\\\";
//将规则封装成对象。
Pattern p = Pattern.compile(s);
//让正则对象和要作用的字符串相关联。获取匹配器对象。
Matcher m = p.matcher(t);
while(m.find())
{
System.out.println(m.pattern());//返回正则表达式
/* \+\w+@\w+(\.\w+)+\\ \+代表普通+,\\代表普通\*/
System.out.println(m.group());//返回匹配的子序列
System.out.println(m.start()+"...."+m.end());
}
}
}
?的非贪心匹配:每次尽可能匹配到少的字符,但是要遵循从左到右
import java.io.*;
import java.util.regex.*;
public class test
{
public static void main(String[] args) throws Exception
{
String t = "oooo";
String s = "o+?";
//将规则封装成对象。
Pattern p = Pattern.compile(s);
//让正则对象和要作用的字符串相关联。获取匹配器对象。
Matcher m = p.matcher(t);
System.out.println(m.pattern());//返回正则表达式
while(m.find())
{
System.out.println(m.group());//返回匹配的子序列
System.out.println(m.start()+"...."+m.end());
}
}
}
运行结果:
o+?
o
0....1
o
1....2
o
2....3
o
3....4
再看一题:
import java.io.*;
import java.util.regex.*;
public class test
{
public static void main(String[] args) throws Exception
{
String t = "aabaaabaaaab";
String s = "aaa??b";
//将规则封装成对象。
Pattern p = Pattern.compile(s);
//让正则对象和要作用的字符串相关联。获取匹配器对象。
Matcher m = p.matcher(t);
System.out.println(m.pattern());//返回正则表达式
while(m.find())
{
System.out.println(m.group());//返回匹配的子序列
System.out.println(m.start()+"...."+m.end());
}
}
}
运行结果:
aaa??b
aab
0....3
aaab
3....7
aaab
8....12
有用到IO流一定要抛出IOException/Exception异常,用throws可以不用try catch处理异常。