Java 进阶知识（一）

文档注释

package doc;
/**
 * 文档注释只在三个地方使用
 * 类，方法，常量
 * 文档注释是功能级注释，用来说明类，方法或常量的
 * 设计意图及功能描述。
 * 文档注释最终可以被javadoc命令生成为手册。
 * @author ta
 * @version 1.0
 * @see java.lang.String
 * @since JDK1.0
 *
 */
public class ApiDocDemo {
	/**
	 * sayHello方法中使用的问候语
	 */
	public static final String INFO = "你好";
	
	/**
	 * 为给定的用户添加问候语
	 * @param name 要添加问候语的用户名的名字
	 * @return 含有问候语的字符串
	 */
	public String sayHello(String name) {
		return INFO+name;
	}
}

字符串

package string;
/**
 * String是不变对象，JVM对其做了一个优化，在内存
 * 中开辟了一段区域作为常量池，凡是通过"字面量"形
 * 式创建的字符串对象都会缓存并重用。因为会重用
 * 对象，所以该对象内容不可变。
 * @author ta
 *
 */
public class StringDemo {
	public static void main(String[] args) {
		String s1 = "123abc";
		//s2,s3重用s1创建的字符串对象
		String s2 = "123abc";
		String s3 = "123abc";
		System.out.println(s1==s2);//true
		System.out.println(s1==s3);//true
		//修改内容会创建并引用新对象
		s1 = s1+"!";
		System.out.println("s1:"+s1);
		//s2,s3不受影响
		System.out.println("s2:"+s2);
		//new则一定创建新对象
		String s4 = new String("123abc");
		System.out.println("s4:"+s4);
		System.out.println(s2==s4);//false
		/*
		 * 编译器有一个优化措施，当编译源代码
		 * 时发现一个计算表达式所有参数都是字面
		 * 量时，会直接进行计算，并将结果编译到
		 * class文件中。
		 * 所以，下面的代码在class文件中为:
		 * String s5 = "123abc";
		 */
		String s5 = "123"+"abc";
		System.out.println("s5:"+s5);
		System.out.println(s2==s5);//true
		
		/*
		 * 计算表达式一方为变量，那么会在运行期
		 * 拼接，那么会创建新对象
		 */
		String s = "123";
		String s6 = s + "abc";
		System.out.println("s6:"+s6);
		System.out.println(s2==s6);//false
	}	
}

package string;
/**
 * int length()
 * 返回当前字符串长度(字符个数)
 * @author ta
 *
 */
public class LengthDemo {
	public static void main(String[] args) {
		String str = "我爱java";
		System.out.println("len:"+str.length());
	}
}

package string;
/**
 * int indexOf(String str)
 * 返回给定字符串在当前字符串中的位置，若当
 * 前字符串不包含该内容则返回值为-1
 * @author ta
 *
 */
public class IndexOfDemo {
	public static void main(String[] args) {
		//            0123456789012345
		String str = "thinking in java";
		
		int index = str.indexOf("in");
		System.out.println("index:"+index);
		//可以从指定位置开始查找
		index = str.indexOf("in", 3);
		System.out.println("index:"+index);
		//查找最后一次出现的位置
		index = str.lastIndexOf("in");
		System.out.println("index:"+index);
	
	}
}

package string;
/**
 * String substring(int start,int end)
 * 截取指定范围内的字符串。两个参数为开始到
 * 结束的下标。
 * 注:java api有一个特点，通常用两个数字表示
 * 范围时都是"含头不含尾"的。
 * @author ta
 *
 */
public class SubstringDemo {
	public static void main(String[] args) {
		//             0123456789012
		String host = "www.baidu.com";
		
		String sub = host.substring(4, 9);
		System.out.println(sub);
		
		//一个参数为截取到末尾
		sub = host.substring(4);
		System.out.println(sub);
	}
}

package string;
/**
 * 完成方法，获取给定地址中的域名
 * @author ta
 *
 */
public class Test {
	public static void main(String[] args) {
		String url = "www.sohu.com";
		String name = getHostName(url);
		System.out.println(name);//sohu
		
		url = "http://www.tedu.com.cn";
		name = getHostName(url);
		System.out.println(name);//tedu
	}
	public static String getHostName(String url) {
		int start = url.indexOf(".")+1;
		int end = url.indexOf(".",start);
		return url.substring(start, end);
	}
	
}

package string;
/**
 * String trim()
 * 去除一个字符串两边的空白字符
 * @author ta
 *
 */
public class TrimDemo {
	public static void main(String[] args) {
		String str = "  hello			";
		System.out.println(str);
		String trim = str.trim();
		System.out.println(trim);
	}
}

package string;
/**
 * char charAt(int index)
 * 获取当前字符串中指定位置处对应的字符
 * @author ta
 *
 */
public class CharAtDemo {
	public static void main(String[] args) {
		//            0123456789012345
		String str = "thinking in java";
		
		char c = str.charAt(9);
		System.out.println(c);
		
		/*
		 * 判断回文
		 * 上海自来水来自海上
		 */
		str = "上海自来水自来海上";
		for(int i=0;i<str.length()/2;i++) {
			char c1 = str.charAt(i);
			char c2 = str.charAt(str.length()-1-i);
			if(c1!=c2) {
				System.out.print("不");
				break;
			}
		}
		System.out.println("是回文");
		
		
		
	}
}

package string;
/**
 * boolean startsWith(String str)
 * boolean endsWith(String str)
 * 判断当前字符串是否是以给定字符串开始或
 * 结尾的。
 * @author ta
 *
 */
public class StartsWithDemo {
	public static void main(String[] args) {
		String str = "thinking in java";
		
		boolean starts = str.startsWith("thi");
		System.out.println("starts:"+starts);
		
		boolean ends = str.endsWith("va");
		System.out.println("ends:"+ends);
		
	}
}

package string;
/**
 * String toUpperCase()
 * String toLowerCase()
 * 将当前字符串中的英文部分转换为全大写或者
 * 全小写
 * @author ta
 *
 */
public class ToUpperCaseDemo {
	public static void main(String[] args) {
		String str = "我爱Java";
		
		String upper = str.toUpperCase();
		System.out.println("upper:"+upper);
		
		String lower = str.toLowerCase();
		System.out.println("lower:"+lower);
	}
}

package string;
/**
 * String提供了一组重载的静态方法:valueOf
 * 可以将给定的内容转换为字符串
 * @author ta
 *
 */
public class ValueOfDemo {
	public static void main(String[] args) {
		int d = 1;
		String str = String.valueOf(d);
		System.out.println(str);
		
		double dou = 1.1;
		str = String.valueOf(dou);
		System.out.println(str);
		
		str = d+"";
		
	}
}

package string;
/**
 * 字符串频繁修改带来的性能损耗
 * @author ta
 *
 */
public class StringDemo2 {
	public static void main(String[] args) {
		String str = "a";
		for(int i=0;i<10000000;i++) {
			str += "a";
		}
		
		System.out.println("执行完毕!");
	}
}

package string;
/**
 * StringBuilder专门用来修改字符串内容的API.
 * String由于其优化设计导致的问题就是不能频繁
 * 修改(每次都创建新对象)
 * @author ta
 *
 */
public class StringBuilderDemo {
	public static void main(String[] args) {
		String str = "努力学习java";
		//默认表示空字符串
//		StringBuilder builder= new StringBuilder();
		
		StringBuilder builder
			= new StringBuilder(str);		
		/*
		 * append()
		 * 拼接字符串
		 */
		builder.append(",为了找个好工作!");
		/*
		 * StringBuilder的toString方法用来
		 * 获取其内部表示的字符串内容
		 */
		str = builder.toString();
		System.out.println(str);
		
		
		/*
		 * 努力学习java,为了找个好工作!
		 * 努力学习java,就是为了改变世界!
		 * replace()
		 */
		builder.replace(9, 16, "就是为了改变世界");
		System.out.println(builder.toString());
		
		
		/*
		 * 努力学习java,就是为了改变世界!
		 * ,就是为了改变世界!
		 * delete()
		 */
		builder.delete(0, 8);
		System.out.println(builder.toString());
		
		/*
		 * ,就是为了改变世界!
		 * 活着,就是为了改变世界!
		 * insert()
		 */
		builder.insert(0,"活着");
		System.out.println(builder.toString());
	}
}

package string;
/**
 * StringBuilder修改性能
 * @author ta
 *
 */
public class StringBuilderDemo2 {
	public static void main(String[] args) {
		StringBuilder builder = new StringBuilder("a");
		for(int i=0;i<10000000;i++) {
			builder.append("a");
		}
		
		System.out.println("执行完毕!");
	}
}

package string;
/**
 * String支持正则表达式方法之一:
 * boolean matches(String regex)
 * 用给定的正则表达式验证当前字符串是否符合
 * 其格式要求。
 * @author ta
 *
 */
public class MatchesDemo {
	public static void main(String[] args) {
		String email = "fancq@tedu.cn";
		/*
		 * 验证email格式的正则表达式
		 * \w+@\w+(\.[a-zA-Z]+)+
		 */
		String regex = "\\w+@\\w+(\\.[a-zA-Z]+)+";
		/*
		 * 注意:matches方法指定的正则表达式就算不
		 * 指定边界匹配符，也是做全匹配验证的。
		 */
		boolean match = email.matches(regex);
		if(match) {
			System.out.println("是邮箱");
		}else {
			System.out.println("不是邮箱");
		}
	}
}

package string;

import java.util.Arrays;

/**
 * String[] split(String regex)
 * 使用给定的正则表达式来拆分当前字符串。
 * 并将拆分后的内容以字符串数组形式返回。
 * @author ta
 *
 */
public class SplitDemo {
	public static void main(String[] args) {
		String str = "abc123def456jhi789klm";
		String regex = "[0-9]+";
		String[] array = str.split(regex);
		System.out.println(array.length);
		System.out.println(Arrays.toString(array));
	}
}

package string;

import java.util.Date;

/**
 * 图片重命名
 * @author ta
 *
 */
public class Test2 {
	public static void main(String[] args) {
		String imageName = "abc.jpg";
		imageName = imageRename(imageName);
		System.out.println(imageName);
	}
	
	public static String imageRename(String imageName) {
		//按照"."拆分
		String[] data = imageName.split("\\.");
		imageName 
			= System.currentTimeMillis()+"."+data[1];
		return imageName;
	}
}

package string;
/**
 * String replaceAll(String regex,String str)
 * 将当前字符串中符合正则表达式要求的部分替换
 * 为给定内容
 * @author ta
 *
 */
public class ReplaceAllDemo {
	public static void main(String[] args) {
		String str = "abc123def456ghi789jkl";
		/*
		 * 将数字部分替换为"#NUMBER#"
		 */
		String regex = "[0-9]+";
		str = str.replaceAll(regex, "#NUMBER#");
		System.out.println(str);
	}
}

package string;
/**
 * 和谐用语
 * @author ta
 *
 */
public class Test3 {
	public static void main(String[] args) {
		String regex = "(wqnmlgdsb|mmp|nc|mdzz|cnm|djb)";
		String message = "wqnmlgdsb!你怎么这么nc!cnm,你个djb!";
		message = message.replaceAll(regex, "***");
		System.out.println(message);
	}
}

对象

package object;
/**
 * 使用当前类测试重写Object相关方法
 * @author ta
 *
 */
public class Point {
	private int x;
	private int y;
	
	public Point(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	/**
	 * toString方法会被很多API调用。所以当我们
	 * 定义一个类时，很常见的操作就是重写这个
	 * 方法。
	 * 该方法的意义是将当前对象转换为一个字符串
	 * 形式。该字符串内容格式没有严格的要求。
	 * 原则为包含这个对象的相关属性信息。
	 */
	public String toString() {
		//(1,2)
		return "("+x+","+y+")";
	}
	/**
	 * equals的作用是比较当前对象与参数对象
	 * 的内容是否一致。
	 */
	public boolean equals(Object obj) {
		if(obj==null) {
			return false;
		}
		if(this==obj) {
			return true;
		}
		if(obj instanceof Point) {
			Point p = (Point)obj;
			return this.x==p.x&&this.y==p.y;
		}
		return false;
	}
	
}

package object;
/**
 * 测试Point重写的Object相关方法
 * @author ta
 *
 */
public class TestPoint {
	public static void main(String[] args) {
		Point p = new Point(1,2);
		/*
		 * 通常我们定义的类如果需要使用到
		 * toString方法时，就应当重写这个
		 * 方法，Object提供的输出的是该对象
		 * 的句柄，没有什么实际意义
		 */
		String str = p.toString();
		System.out.println(str);
		/*
		 * System.out.println(Object obj)
		 * 该方法会将给定对象的toString方法
		 * 返回的字符串输出到控制台
		 */
		System.out.println(p);
		
		
		Point p2 = new Point(1,2);
		System.out.println(p==p2);//false
		/*
		 * 我们定义的类如果使用equals，就应当
		 * 重写这个方法。Object提供的equals方法
		 * 本身内部就是用“==”进行比较的，没有
		 * 实际意义。
		 * 而java API提供的类，toString,equals
		 * 方法都妥善进行了重写。
		 */
		System.out.println(p.equals(p2));//true
	}
}

整数

package integer;
/**
 * 包装类
 * 包装类是为了解决基本类型不能直接参与面向
 * 对象开发的问题。
 * 其中6个数字类型的包装类继承自Number类。
 * java.lang.Number是一个抽象类，定义了几个
 * 抽象方法，要求数字类型的包装类可以将其表示
 * 的数字以任意数字类型返回。
 * @author ta
 *
 */
public class IntegerDemo1 {
	public static void main(String[] args) {
		int d = 128;
		//转换为包装类
//		Integer i1 = new Integer(d);
//		Integer i2 = new Integer(d);
		//推荐用valueOf转换为包装类
		Integer i1 = Integer.valueOf(d);
		Integer i2 = Integer.valueOf(d);
		
		System.out.println(i1==i2);
		System.out.println(i1.equals(i2));
		
		/*
		 * 包装类转换为基本类型
		 */
		d = i1.intValue();
		System.out.println(d);
		
		double dou = i1.doubleValue();
		System.out.println(dou);
		
		byte b = i1.byteValue();
		System.out.println(b);
		
		
		/*
		 * 数字类型的包装类都定义了两个常量
		 * MAX_VALUE
		 * MIN_VALUE
		 * 用于表示该包装类对应的基本类型的
		 * 取值范围
		 */
		int imax = Integer.MAX_VALUE;
		System.out.println(imax);
		int imin = Integer.MIN_VALUE;
		System.out.println(imin);
		
		long lmax = Long.MAX_VALUE;
		System.out.println(lmax);
	}
	
}

package integer;
/**
 * 包装类都提供了一个静态方法:
 * parseXXX(String str)
 * 可以将字符串解析为对应的基本类型，但是需要
 * 注意，该字符串必须能够正确描述该基本类型可
 * 以保存的值,否则会抛出异常。
 * @author ta
 *
 */
public class ParseDemo {
	public static void main(String[] args) {
		String str = "123";
		int d = Integer.parseInt(str);
		System.out.println(d);
		
		double dou = Double.parseDouble(str);
		System.out.println(dou);
		
				
				
	}
}

package integer;
/**
 * JDK1.5版本推出时推出了一个特性:
 * 自动拆装箱
 * 该特性是编译器认可的，当我们在基本类型和
 * 其对应的引用类型之间互相赋值时，编译器会
 * 自动补全代码在两者之间进行转换。
 * @author ta
 *
 */
public class AutoBoxingDemo {
	public static void main(String[] args) {
		/*
		 * 触发了编译器的自动拆箱特性:
		 * 编译器会补全代码，将包装类转换为
		 * 基本类型。
		 * 下面的代码会被编译器补充代码为:
		 * int d = new Integer(1).intValue();
		 */
		int d = new Integer(1);
		/*
		 * 触发自动装箱特性，编译器会补充代码
		 * Integer i = Integer.valueOf(d);
		 */
		Integer i = d;
	}
}