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();
}
}