java基础12_常用类_枚举

来源：互联网发布：laravel function.php 编辑：程序博客网时间：2024/04/29 19:08

常用java类StringBuffer类

public final class StringBuffer
extends Object
implements Serializable, CharSequence
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
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 Objectclone()
          抛出 CloneNotSupportedException。 intcompareTo(E o)
          比较此枚举与指定对象的顺序。 booleanequals(Object other)
          当指定对象等于此枚举常量时，返回 true。protected voidfinalize()
          枚举类不能有 finalize 方法。 Class<E>getDeclaringClass()
          返回与此枚举常量的枚举类型相对应的 Class 对象。 inthashCode()
          返回枚举常量的哈希码。 Stringname()
          返回此枚举常量的名称，在其枚举声明中对其进行声明。 intordinal()
          返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。 StringtoString()
          返回枚举常量的名称，它包含在声明中。static <T extends Enum<T>> TvalueOf(Class<T> enumType,String name)
          返回带指定名称的指定枚举类型的枚举常量。

用法一：常量

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

Java代码 

public enum Color {
RED, GREEN, BLANK, YELLOW
}

用法二：switch

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

Java代码 
enum Signal {  
    GREEN, YELLOW, RED  
}  
public class TrafficLight {  
    Signal color = Signal.RED;  
    public void change() {  
        switch (color) {  
        case RED:  
            color = Signal.GREEN;  
            break;  
        case YELLOW:  
            color = Signal.RED;  
            break;  
        case GREEN:  
            color = Signal.YELLOW;  
            break;  
        }  
    }  
}  

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

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

Java代码 
public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    // 普通方法  
    public static String getName(int index) {  
        for (Color c : Color.values()) {  
            if (c.getIndex() == index) {  
                return c.name;  
            }  
        }  
        return null;  
    }  
    // get set 方法  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public int getIndex() {  
        return index;  
    }  
    public void setIndex(int index) {  
        this.index = index;  
    }  
}  

用法四：覆盖枚举的方法

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

Java代码 
public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    //覆盖方法  
    @Override  
    public String toString() {  
        return this.index+"_"+this.name;  
    }  
}  

用法五：实现接口

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

Java代码 
public interface Behaviour {  
    void print();  
    String getInfo();  
}  
public enum Color implements Behaviour{  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
//接口方法  
    @Override  
    public String getInfo() {  
        return this.name;  
    }  
    //接口方法  
    @Override  
    public void print() {  
        System.out.println(this.index+":"+this.name);  
    }  
}  

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

Java代码

public interface Food {  
    enum Coffee implements Food{  
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
    }  
    enum Dessert implements Food{  
        FRUIT, CAKE, GELATO  
    }  
}  

1 0