java基础12_常用类_枚举

常用java类StringBuffer类

public final class StringBuffer
   
   
    
    extends 
    
    Object
   
   
   
   
    
    implements 
    
    Serializable, 
    
    CharSequence
   
   

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet"。

通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。

当发生与源序列有关的操作（如源序列中的追加或插入操作）时，该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。

public final class StringBuilder
   
   
    
    extends 
    
    Object
   
   
   
   
    
    implements 
    
    Serializable, 
    
    CharSequence
   
   

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快。 

package java基础;
/**
 * 对StringBuffer类的学习
 * @author 微信号：jobs1127
 */
public class TestStringBuffer {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("start");
sb.append("le");
System.out.println(sb.toString());//startle
sb.insert(4,"le");
System.out.println(sb.toString());//starletle 
sb.delete(4,sb.length());
System.out.println(sb.toString());//star
System.out.println(sb.reverse());//rats
Double a = new Double(123.33);
System.out.println(a.intValue());//123
try {
int i = Integer.parseInt(a.toString());
System.out.println(i);
} catch (NumberFormatException e) {
System.out.println("会报异常NumberFormatException");
}

String[][] s =null;
s = new String[3][];
s[0] = new String[2];
s[1] = new String[3];
s[2] = new String[3];
System.out.println("s.length="+s.length);
System.out.println("s[0].length="+s[0].length);
System.out.println("s[1].length="+s[1].length);
System.out.println("s[2].length="+s[2].length);
for(int i=0; i<s.length; i++) {
for(int j=0; j<s[i].length; j++) {
s[i][j] = i+"-"+j;
System.out.println(s[i][j]);
}
}
String str="1,2;3,4,5;6,7,8";
System.out.println("---------parse2Array(str)------");
double[][] haha = parse2Array(str);
for(int i=0; i<haha.length; i++) {
for(int j=0; j<haha[i].length; j++) {
System.out.println("haha["+i+"]["+j+"]="+haha[i][j]);
}
}
}
/**
* 
* @param s="1,2;3,4,5;6,7,8";
* @return 一个double类型的二维数组
* 该方法体会二维码数组的定义、赋值，通过调试程序，体会内存的动态情况
*/
public static double[][] parse2Array(String s) {
String[] s1 = s.split(";");
for(String s11:s1) {//增强型for循环
System.out.println(s11);
}
String[] s2 = null;
double[][] a = null;
a = new double[s1.length][];//声明二维数组
for(int i=0; i<a.length; i++) {
s2 = s1[i].split(",");
for(String s22:s2) {
System.out.println(s22);
}
System.out.println("s2.length="+s2.length);
a[i] = new double[s2.length];//声明二维数组中的一维数组
System.out.println("a["+i+"]"+".length="+a[i].length);
for(int j=0; j<a[i].length; j++) {
System.out.println("s2["+j+"]="+s2[j]);
a[i][j] = Double.parseDouble(s2[j]);
}
}
return a;
}
}

java.io
类 File

构造方法摘要
File(File parent,String child)           根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File(String pathname)           通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
File(String parent,String child)           根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
File(URI uri)           通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

getParentFile()

          返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。

mkdirs()
          创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

createNewFile()
          当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。

separator
          与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。

exists()
          测试此抽象路径名表示的文件或目录是否存在。

length()
          返回由此抽象路径名表示的文件的长度。

listFiles()
          返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

package java基础;
import java.io.*;
public class TestFile {
public static void main(String[] args) {
//文件的分隔符
String s1 = File.separator;
System.out.println("File.separator:"+s1);
String s2 = File.pathSeparator;
System.out.println("File.pathSeparator:"+s2);
char s3 = File.separatorChar;
System.out.println(" File.separatorChar:"+s3);
//定义一个虚拟路径
String myPath = "myDir1"+s1+"myDir2";
//定义一个文件
String myText = "myText.txt";
//File f = new File(myPath,myText);或者如下
File f = new File(myPath+s1+myText);
if(f.exists()) {
System.out.println("文件名："+f.getAbsolutePath());
System.out.println("文件大小："+f.length());
} else {
System.out.println("文件不存在，开始新创建");
//文件包括路径和文件名以及文件里的内容
f.getParentFile().mkdirs();//返回此抽象路径名父目录的抽象路径名；创建文件路径
try {
f.createNewFile();//创建文件名
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

package java基础;
import java.io.*;
/**
 * 在命令行中义树状结构展现特定文件夹极其子文件夹，其实就是递归调用
 * @author 微信号:jobs1127
 *
 */
public class ListFile {
public static void main(String[] args) {
File f = new File("d:\\test");
File[] files = f.listFiles();
for (File ff : files) {
System.out.println(ff.getName());
}
System.out.println("----------------树妆结构----------------");
listChilds(f, 0);
}


public static void listChilds(File f, int level) {
String preStr = "";
for (int i = 0; i < level; i++) {
preStr += "    ";
}
System.out.println(preStr + f.getName());
if (!f.isDirectory()) {//如果不是一个目录就返回
return;
}
File[] childs = f.listFiles();
for (int i = 0; i < childs.length; i++) {
listChilds(childs[i], level + 1);
}
}
}

java.lang
类 Enum<E extends Enum<E>>

方法摘要
protected  Object	clone()           抛出 CloneNotSupportedException。
int	compareTo(E o)           比较此枚举与指定对象的顺序。
boolean	equals(Object other)           当指定对象等于此枚举常量时，返回 true。
protected  void	finalize()           枚举类不能有 finalize 方法。
Class<E>	getDeclaringClass()           返回与此枚举常量的枚举类型相对应的 Class 对象。
int	hashCode()           返回枚举常量的哈希码。
String	name()           返回此枚举常量的名称，在其枚举声明中对其进行声明。
int	ordinal()           返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
String	toString()           返回枚举常量的名称，它包含在声明中。
static <T extends Enum<T>> T	valueOf(Class<T> enumType,String name)           返回带指定名称的指定枚举类型的枚举常量。

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 

Java代码 

1. public enum Color {  
2.   RED, GREEN, BLANK, YELLOW  
3. }  

用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。 

Java代码 

1. enum Signal {  
2.     GREEN, YELLOW, RED  
3. }  
4. public class TrafficLight {  
5.     Signal color = Signal.RED;  
6.     public void change() {  
7.         switch (color) {  
8.         case RED:  
9.             color = Signal.GREEN;  
10.             break;  
11.         case YELLOW:  
12.             color = Signal.RED;  
13.             break;  
14.         case GREEN:  
15.             color = Signal.YELLOW;  
16.             break;  
17.         }  
18.     }  
19. }  

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 

Java代码 

1. public enum Color {  
2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
3.     // 成员变量  
4.     private String name;  
5.     private int index;  
6.     // 构造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     // 普通方法  
12.     public static String getName(int index) {  
13.         for (Color c : Color.values()) {  
14.             if (c.getIndex() == index) {  
15.                 return c.name;  
16.             }  
17.         }  
18.         return null;  
19.     }  
20.     // get set 方法  
21.     public String getName() {  
22.         return name;  
23.     }  
24.     public void setName(String name) {  
25.         this.name = name;  
26.     }  
27.     public int getIndex() {  
28.         return index;  
29.     }  
30.     public void setIndex(int index) {  
31.         this.index = index;  
32.     }  
33. }  

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。 

Java代码 

1. public enum Color {  
2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
3.     // 成员变量  
4.     private String name;  
5.     private int index;  
6.     // 构造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     //覆盖方法  
12.     @Override  
13.     public String toString() {  
14.         return this.index+"_"+this.name;  
15.     }  
16. }  

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。 

Java代码 

1. public interface Behaviour {  
2.     void print();  
3.     String getInfo();  
4. }  
5. public enum Color implements Behaviour{  
6.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
7.     // 成员变量  
8.     private String name;  
9.     private int index;  
10.     // 构造方法  
11.     private Color(String name, int index) {  
12.         this.name = name;  
13.         this.index = index;  
14.     }  
15. //接口方法  
16.     @Override  
17.     public String getInfo() {  
18.         return this.name;  
19.     }  
20.     //接口方法  
21.     @Override  
22.     public void print() {  
23.         System.out.println(this.index+":"+this.name);  
24.     }  
25. }  

用法六：使用接口组织枚举

 Java代码 

1. public interface Food {  
2.     enum Coffee implements Food{  
3.         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
4.     }  
5.     enum Dessert implements Food{  
6.         FRUIT, CAKE, GELATO  
7.     }  
8. }