常用类

1、

package day11;

public class Alignment {
	// 在JDK1.5之前，可以声明固定的常量值表示一些列常量。
	public static final int LEFT = 1;
	public static final int CENTER = 2;
	public static final int RIGHT = 3;

	/*
	 * 执行对齐的操作，对齐方式： 左对齐 居中对齐 右对齐
	 */
	public void align(int value) {
		if (value == 1) {
			// 左对齐
		} else if (value == 2) {
			// 居中对齐
		} else if (value == 3) {
			// 右对齐
		}
	}

	public void align2(int value) {
		if (value == LEFT) {
			// 左对齐
		} else if (value == CENTER) {
			// 居中对齐
		} else if (value == RIGHT) {
			// 右对齐
		}
	}

	// 使用枚举类型作为参数。
	public void align3(Align value) {
		if (value == Align.LEFT) {
			// 左对齐
		} else if (value == Align.CENTER) {
			// 居中对齐
		} else if (value == Align.RIGHT) {
			// 右对齐
		}
	}
}

class UseAlign {
	public void f() {
		Alignment a = new Alignment();
		// 客户端使用，实现对齐方式。
		a.align(1);
		a.align(Alignment.LEFT);
		// 虽然我们提供了一组常量值的表示方案（静态常量值），
		// 但是，客户端完全可以忽略我们提供的方案。依然
		// 坚持使用魔幻数字。
		a.align2(3);
		// 更有甚者，客户端完全可以传递一个我们根本就不提供
		// 的值，也不会产生任何编译错误。（没有编译期间的类型
		// 检查）
		a.align2(1000);
		// 枚举之后
		a.align3(Align.CENTER);
		// 错误，类型不匹配
		// a.align3(1);
		// 错误，枚举中没有声明JUSTIFY常量
		// a.align3(Align.JUSTIFY);

	}
}

　　2、switch对枚举类型的支持。

/*
 * switch对枚举类型的支持。
 * 
 */
package day11;

public class Switch {

	public static void main(String[] args) {
		Align a = Align.RIGHT;
		switch (a) {
		case LEFT:
			System.out.println("左对齐");
			break;
		case CENTER:
			System.out.println("居中对齐");
			break;
		case RIGHT:
			System.out.println("右对齐");
			break;
		}
	}
}

　　3、枚举类型

/*
 * 枚举类型
 * 枚举使用enum来声明。用来声明一组固定值的常量。
 * 按照惯例，枚举常量值全部大写。
 * 
 * 枚举的优势：
 * 比起编译期间的常量（JDK1.5之前），枚举提供了编译期间
 * 类型安全的检查。如果我们使用枚举做参数，则客户端必须提供
 * 相同的枚举类型，同时，提供的枚举值必须在枚举类型声明
 * 的常量值范围之内。
 * 
 * 枚举类型隐式继承java.lang.Enum类型，因此，枚举类型
 * 不能在继承其他类。
 * 编译器会自动为枚举类型生成两个静态方法：
 * values 返回一个枚举数组，包含枚举中声明的所有枚举常量
 * valueOf 根据参数（String）指定的值，返回对应的枚举
 * 常量值。
 * 
 * 枚举类型可以实现接口。此时，可以选择所有枚举常量统一
 * 的实现，也可以每个枚举常量都单独实现。
 * 
 * 枚举类型也可以声明抽象方法，此时，由各个枚举常量给出
 * 具体的实现。
 */
package day11;

public enum Align implements EInter {
	LEFT {
		@Override
		public void introduce() {
			System.out.println("我是左对齐");
		}

		@Override
		void absM() {
			// TODO Auto-generated method stub
			
		}
	},
	CENTER {
		@Override
		public void introduce() {
			System.out.println("我是居中对齐");
		}

		@Override
		void absM() {
			// TODO Auto-generated method stub
			
		}
	},
	RIGHT {
		@Override
		public void introduce() {
			System.out.println("我是右对齐");
		}

		@Override
		void absM() {
			// TODO Auto-generated method stub
			
		}
	};
	
	abstract void absM();
	
	public static void main(String[] args) {
		// 返回枚举常量的数组
		Align[] a = Align.values();
		for (Align al : a) {
			// 当输出一个引用类型时，会调用该类型的toString方法。
			// System.out.println(al);
			EInter e = al;
			e.introduce();

		}
		// Align t = Align.valueOf("LEFT");
		// System.out.println(t);

	}
	/*
	 * @Override public void introduce() { System.out.println("枚举的接口实现"); }
	 */
}

interface EInter {
	void introduce();
}

　　4、包装类

 boolean-> Boolean
 byte -> Byte
 short -> Short
 char -> Character
 int -> Integer
 long -> Long
 float -> Float
 double -> Double

　　5、包装类型

/*
 * 包装类型
 * 每个基本数据类型都对应一个包装类型。当我们需要将基本数据类型当
 * 成对象使用时（例如在集合中），就可以使用对应的包装类型。
 * 基本数据类型与包装类型之间是可以进行相互转换的。
 * 
 * 封箱：将基本数据类型转换成包装类型。
 * 拆箱：将包装类型转换成基本数据类型。
 * 自动拆箱与封箱
 * 自动封箱：当需要包装类型时，如果我们提供的是基本数据类型，则
 * 编译器可以自动的将基本数据类型转换成包装类型。（通过调用包装
 * 类型的valueOf方法）
 * 自动拆箱：当需要基本数据类型时，如果我们提供的是包装类型，则
 * 编译器可以自动的将包装类型转换成基本数据类型。（调用包装类型
 * 的TValue方法，T就是对应的基本数据类型）
 * 
 * 包装类是非可变类，包装类型对象一经创建，其所包装的基本数据
 * 类型值就不能够再进行更改。
 * 非可变类的优势：非可变类创建的对象，其内部数据不能更改，因此
 * 非可变对象可以自由的实现共享。（没有必要为每一个需要该对象
 * 的位置去创建一个不同的对象）。
 * 
 * 包装类的缓存机制：
 * 包装类会缓存常用的对象。这样可以避免创建重复的对象，实现
 * 对象的共享。
 * Boolean，Byte缓存全部
 * Character 0 ~ 127
 * Short,Integer,Long -128 ~ 127
 * Float， Double 没有缓存。
 * 
 * 当使用== !=（既可以应用于基本数据类型，也可以应用于引用
 * 类型）比较基本数据类型与包装类型时，会将包装类型拆箱处理，
 * 然后比较基本数据类型的值。
 */
package day11;

public class Wrapper {
	public static void main(String[] args) {
		int x = 5;
		// 基本数据类型转换成包装类型
		// 第一种方式：通过new创建对象
		Integer i = new Integer(x);
		// 第二种方式：调用包装类的静态方法valueOf。
		Integer i2 = Integer.valueOf(x);
		// 包装类型转换成基本数据类型。
		// 通过调用包装类型的TValue方法，其中，T
		// 为对应的基本数据类型。
		int y = i.intValue();

		int a = 5;
		Integer aw = a;
		// Integer aw = Integer.valueOf(a);
		int b = aw;
		// int b = aw.intValue();
		Object o = 100;
		/*
		 * 不要这样使用。 for (Integer ax = 1; ax <= 100; ax++) {
		 * 
		 * }
		 */
		Integer x1 = 100; // Integer x1 = Integer.valueOf(100);
		Integer x2 = 100;
		System.out.println(x1 == x2);
		x1 = 200; // Integer x1 = Integer.valueOf(200);
		x2 = 200;
		System.out.println(x1 == x2);
		// 拆箱还是封箱？
		Integer e = new Integer(200);
		int u = 200;
		System.out.println(e == u);

	}
}

　　6、String 的方法 

package day11;

public class StringTest {

	public static void main(String[] args) {
		String s = "abcdefg";
		String s2 = new String("1234578");
		// 返回String对象字符的长度。（以字符为单位）。
		System.out.println(s.length());
		// 判断当前对象与参数指定的String对象字符序列
		// 是否相等，如果相等，返回true，否则返回false。
		System.out.println(s.equals("abc"));
		// 与equals相同，但是会忽略大小写。
		System.out.println(s.equalsIgnoreCase("aBC"));
		// 如果当前对象大于参数指定的对象，返回值大于0，如果
		// 当前对象等于参数指定的对象，返回0，如果当前对象小于
		// 参数指定的对象，返回值小于0。
		System.out.println(s.compareTo("ABC"));
		// 判断当前对象是否以参数指定的对象开头，是则返回true，
		// 否则返回false。
		System.out.println(s.startsWith("ab"));
		// 判断当前对象是否以参数指定的对象结尾，是则返回true，
		// 否则返回false。
		System.out.println(s.endsWith("ab"));
		// 返回参数指定索引位置的字符。（索引从0开始）
		System.out.println(s.charAt(1));
		// 返回子字符序列，参数指定开始的位置，一直到字符序列
		// 末尾。
		System.out.println(s.substring(2));
		// 返回子字符序列，第一个参数指定起始点，第二个参数
		// 指定结束点。（包括起始点，不包括结束点）
		System.out.println(s.substring(2, 5));
		// 使用当前的字符序列，连接参数字符序列，返回连接
		// 之后的结果。（用的不多）
		System.out.println(s.concat("1234"));
		// 使用第二个参数替换第一个参数，返回替换之后的结果。
		System.out.println(s.replace('b', 'x'));
		System.out.println("abcabc".replace('b', 'x'));
		System.out.println(s.replace("ab", "xyz"));
		// 返回参数在当前对象中首次出现的位置。如果没有出现，
		// 返回-1。
		System.out.println(s.indexOf("bc"));
		System.out.println(s.indexOf("kk"));
		// 返回参数在当前对象中最后一次出现的位置。如果没有出现，
		// 返回-1。
		System.out.println(s.lastIndexOf("kk"));
		// 去除字符序列两端的空格，返回去除之后的结果。
		System.out.println("   a    b    ".trim());
		// 返回当前对象的大写形式。
		System.out.println(s.toUpperCase());
		// 返回当前对象的小写形式。
		System.out.println(s.toLowerCase());
		String[] keys = "2016-10-15".split("-");
		for (String key : keys) {
			System.out.println(key);
		}
		// 判断当前对象是否包含参数指定的对象，如果包含，返回
		// true，否则返回false。
		System.out.println(s.contains("cd"));
		System.out.println(s.indexOf("cd") >= 0);
	}

}

　　7、

/*
 * String类是非可变类，String对象一经创建，
 * 就不能进行修改。
 * 在String类中，所有看似修改String字符序列的方法
 * （toUpperCase，substring等），都是在新创建的对象
 * 上进行的，而没有修改原有的String对象。
 */
package day11;

public class StringTest2 {

	public static void main(String[] args) {
		String s = "abc";
		s = "def";
		System.out.println(s);
		System.out.println(s.toUpperCase());
		System.out.println(s);
	}

}

　　8、String常量池

/*
 * String常量池
 * String常量池用来维护编译期间的String常量。
 * 常量池初始为空，当出现编译期间的String常量时，首先会
 * 搜索String常量池，如果常量池中不存在该String对象，则
 * 将该String对象加入到常量池中，并返回该对象（起始地址）。
 * 如果该对象已经存在（根据String对象的equals方法），
 * 、则直接返回常量池中的String对象（不会再创建String对象）。
 * 
 * String常量池可以避免令我们创建重复的对象，因为String对象
 * 是不可改变的，因为我们只需创建一个，由所有需要的位置共享即可。
 * 
 */
package day11;

public class StringPool {

	public static void main(String[] args) {
		String s1 = "abc";
		String s2 = "abc";
		System.out.println(s1.equals(s2));
		System.out.println(s1 == s2);

		String s3 = new String("abc");
		String s4 = new String("abc");
		System.out.println(s3.equals(s4));
		System.out.println(s3 == s4);

		//编译器特征：能够在编译期间计算的结果，就不会
		//等到运行时再去计算。
		s1 = "ab" + "c";
		//s1 = "abc";
		s1 = "a" + "b" + "c";
		final String t = "c";
		s1 = "ab" + t;
		System.out.println(s1 == s2);
	}

}
/*
 * String常量池
 * String常量池用来维护编译期间的String常量。
 * 常量池初始为空，当出现编译期间的String常量时，首先会
 * 搜索String常量池，如果常量池中不存在该String对象，则
 * 将该String对象加入到常量池中，并返回该对象（起始地址）。
 * 如果该对象已经存在（根据String对象的equals方法），
 * 、则直接返回常量池中的String对象（不会再创建String对象）。
 * 
 * String常量池可以避免令我们创建重复的对象，因为String对象
 * 是不可改变的，因为我们只需创建一个，由所有需要的位置共享即可。
 * 
 */
package day11;

public class StringPool {

	public static void main(String[] args) {
		String s1 = "abc";
		String s2 = "abc";
		System.out.println(s1.equals(s2));
		System.out.println(s1 == s2);

		String s3 = new String("abc");
		String s4 = new String("abc");
		System.out.println(s3.equals(s4));
		System.out.println(s3 == s4);

		//编译器特征：能够在编译期间计算的结果，就不会
		//等到运行时再去计算。
		s1 = "ab" + "c";
		//s1 = "abc";
		s1 = "a" + "b" + "c";
		final String t = "c";
		s1 = "ab" + t;
		System.out.println(s1 == s2);
	}

}

　　9、equals与==

/*
 * equals与==
 * equals是Object类中声明的方法，在Object类中，equals
 * 与==是没有任何区别的，因为Object类中，equals就是用==
 * 进行判断的。但是，Object类中equals比较可能过于严格，子类
 * 可以根据需要实现自己的比较方式。例如，String类重写了equals方法，
 * 只要两个String字符序列相当，则认为两个String对象就是相等的。
 * 
 * ==比较的永远是两个变量的值，当变量是引用类型时，比较的是两个
 * 引用的值是否相等，即对象的起始地址是否相等（两个对象是否是同一个
 * 对象。）
 */
package day11;

public class Equals {
	public static void main(String[] args) {
		String s = new String("abc");
		String s2 = new String("abc");
		System.out.println(s.equals(s2));
		System.out.println(s == s2);
	}
}

　　10、StringBuilder与StringBuffer

/*
 * StringBuilder与StringBuffer
 * StringBuilder是非线程安全的，StringBuffer是
 * 线程安全的。我们应该首选（优先使用）StringBuilder。
 * 
 * String是非可变类，StringBuilder是可变类，对StringBuilder
 * 进行的一切修改操作，都是在原有对象上进行的，而没有创建新的
 * 对象。
 */
package day11;

public class StringBuilderTest {
	public static void main(String[] args) {
		StringBuilder s = new StringBuilder("abc");
		// 不同与String，StringBuilder不支持直接赋值的形式。
		// StringBuilder s2 = "abc";
		// 将第二个参数指定的对象插入到第一个参数指定的位置上。
		s.insert(2, "1234");
		// 改变了原有的对象
		System.out.println(s);
		// 返回当前对象的长度。（以字符为单位）。
		System.out.println(s.length());
		// 返回StringBuilder对象的存储空间。
		// 存储空间会随着字符的增加而自动扩容。
		System.out.println(s.capacity());
		// 转换成String对象。
		System.out.println(s.toString());
		// 删除指定区间的字符。第1个参数指定开始点，第2个参数
		// 指定结束点。（包括起始点，不包括终止点。）
		s.delete(0, 3);
		System.out.println(s);
		// 将参数指定的对象追加到当前StringBuilder对象
		// 的尾部。
		s.append("xyz");
		System.out.println(s);
		s.append("abc");
		s.append("def");
		// StringBuilder的delete，append等方法可以返回
		// 当前的对象，因此，我们可以实现链式方法调用。
		s.append("abc").append("def");

	}

}

　　11、

/*
 * String与StringBuilder
 * String是非可变类，String对象一经创建就不能再进行修改。
 * StringBuilder可变类，StringBuilder的对象可以改变。
 * 因为String对象是不可改变的，所以String对象可以在多线程
 * 并发访问时，安全的实现共享。但是，当我们频繁对String进行
 * 修改时，就会创建大量的临时对象，影响性能。此时，我们应该
 * 使用StringBuilder来代替String。
 */

package day11;

public class StringAndBuilder {
	public static void main(String[] args) {
		long start = System.nanoTime();
		// System.currentTimeMillis();
		String s = "";
		// 使用String，会创建大量的临时对象
		for (int i = 0; i < 1000; i++) {
			s += "a";
		}
		long end = System.nanoTime();
		System.out.println(end - start);

		start = System.nanoTime();
		StringBuilder b = new StringBuilder(1200);
		for (int i = 0; i < 1000; i++) {
			b.append("a");
		}
		// s = b.toString();
		end = System.nanoTime();
		System.out.println(end - start);
	}
}

　　12、Math类中声明的成员都是静态的。

/*
 * Math类中声明的成员都是静态的。
 */

package day11;

import static java.lang.Math.*;

public class MathTest {
	public static void main(String[] args) {
		// 返回一个[0, 1)之间的随机小数（double）。
		System.out.println(random());
		// 返回绝对值
		System.out.println(abs(-10));
		System.out.println(Integer.MIN_VALUE);
		System.out.println(abs(Integer.MIN_VALUE));
		// 返回大于等于参数的最小整数。（向上取整）
		System.out.println(ceil(3.2));
		// 返回小于等于参数的最大整数。（向下取整）
		System.out.println(floor(2.3));
		// 返回两个参数中较大的一个。
		System.out.println(max(5, 10));
		// 返回两个参数中较小的一个。
		System.out.println(min(5, 10));
	}
}

　　13、Date

package day11;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest {

	public static void main(String[] args) {
		// 当前日期和时间
		Date date = new Date();
		System.out.println(date);
		// 从1970-01-01 00:00:00所走过的毫秒数（参数指定）
		Date date2 = new Date(10000000);
		System.out.println(date2);
		// 返回从1970-01-01 00:00:00到Date所表示
		// 时间走过的毫秒数。
		long time = date.getTime();
		System.out.println(time);
		// 设置时间（毫秒数）
		date.setTime(30000);

		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		// 对日期进行格式化
		System.out.println(df.format(date));
	}
}

　　14、Calendar

package day11;

import java.util.Calendar;
import java.util.Date;

public class CalendarTest {

	public static void main(String[] args) {
		// Calendar是抽象类，不能创建对象，通过getInstance
		// 方法获得的是Calendar子类型的对象。
		Calendar c = Calendar.getInstance();
		System.out.println(c.get(Calendar.YEAR));
		// 获取的月份从0开始。
		System.out.println(c.get(Calendar.MONTH));
		System.out.println(c.get(Calendar.DATE));
		// 12小时制
		System.out.println(c.get(Calendar.HOUR));
		// 24小时制
		System.out.println(c.get(Calendar.HOUR_OF_DAY));
		System.out.println(c.get(Calendar.MINUTE));
		System.out.println(c.get(Calendar.SECOND));
		c.set(Calendar.YEAR, 1990);
		c.set(1990, 7, 8);
		c.set(1990, 7, 8, 15, 30, 30);
		// 获取Date对象
		Date d = c.getTime();
	}

}

　　15、Random

package day11;

import java.util.Random;

public class RandomTest {

	public static void main(String[] args) {
		Random r = new Random();
		// 返回一个int类型的值。
		System.out.println(r.nextInt());
		// 返回一个0~参数范围，int类型的值。
		// 包括0，不包括参数指定的上限
		System.out.println(r.nextInt(30));
		// 返回[0,1)之间的随机float值。
		System.out.println(r.nextFloat());
		// 返回[0,1)之间的随机double值。
		System.out.println(r.nextDouble());
	}

}

　　16、Scanner

package day11;

import java.util.Scanner;

public class ScannerTest {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		// 手动设置分隔符。
		// s.useDelimiter("*");
		while (s.hasNext()) {
			String str = s.next();
			// 判断是否含有下一行
			// s.hasNextLine();
			// 获取下一行。
			// s.nextLine();
			// s.nextInt();
			if (str.equals("q")) {
				break;
			}
			System.out.println(str);
		}
		// 释放本地的资源。
		s.close();
	}

}