枚举、缓冲流、
一、枚举
1.1 概述
- 枚举也是一种特殊的类(枚举也是一种数据类型)枚举可以定义在类中
- 语法：
- [访问修饰符] enum 枚举名称{ }
- 也可以单独创建一个枚举类
- [访问修饰符] enum 枚举名称{ }
- 什么时候解决枚举问题
- 当一个类的对象时有固定范围时，不能随意创建类的对象，这时我们可以采用枚举来解决这一类型问题。
1.2 枚举的特点
- 声明枚举类以后，就必须在枚举类中的第一句代码中，声明枚举类的所有实例，实例之间用逗号隔开，如果一个枚举类没有声明实例，那么这个枚举则永远不会有实例产生，列出这些实例时系统会自动添加 public static final 修饰，无序自行添加
- 在枚举中也可以定义属性和方法
- 如果枚举类确实不存在任何的实例，则枚举类中的第一句代码需要添加一个分号，否则枚举无法编译
- Java 为每个枚举类都提供了一个 values() 方法，用来获取枚举中所有的实例对象
- 可以通过枚举类.对象名.属性名/方法名的方式调用枚举类中的普通方法和属性
- 如果调用枚举类中的静态方法和属性，语法：枚举类.静态属性/静态方法
- 枚举类也可以有构造方法，而且构造方法的访问修饰符必须时 private 当枚举类在被使用时，枚举类会自动调用构造方法，创造出在枚举中声明的所有实例对象
- 枚举中的构造方法也可以有参数，如果构造方法是由参数的，那么在声明枚举实例对象时，就必须传递参数， 语法：实例名称(参数列表)
- 枚举也可以实现接口
- 枚举不可以继承任何形式的类
package com.bdit.vifition;
/**
* 枚举类
* 类的对象只有有限个，确定的称为枚举类
* 线程状态：创建、就绪、运行、阻塞、死亡
* 当需要定义一组常量时，强力建议枚举类
* 如果枚举类只有一个常量时，则可以作为单例模式的实现方式
*定义枚举类
* 一：jdk5.0之前，自定义枚举类
* 二：jdk5.0时，使用enum关键字定义
*
* */
public class Vifi01 {
public static void main(String[] args) {
Season season01 = Season.aaa;
String sde01 = Season.BBB.getSeasonDesc();
System.out.println(season01);
System.out.println(sde01);
}
}
//自定义
class Season{
//声明Season 对象的属性(最好为常量：使用 private final 修饰)
private final String seasonName;
private final String seasonDesc;
//1. 私有化类的构造器(不是私有化，可以在外部调用，调用则不确定数目)
//类私有化，而且不能在外部创建对象
private Season(String seasonName,String seasonDesc){
//2.私有化构造方法，并给对象属性赋值
this.seasonName=seasonName;
this.seasonDesc=seasonDesc;
}
//3.提供当前枚举类的多个对象: public static final 修饰
public static final Season aaa = new Season("春天","春天01");
public static final Season BBB = new Season("夏天","夏天01");
public static final Season CCC = new Season("秋天","秋天01");
public static final Season ddd = new Season("冬天","冬天01");
//4.如果想获取枚举类的属性(final 只能生成get方法)
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//5.toString()
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
package com.bdit.vifition;
/*
* 使用enum关键字定义
* 默认继承 class java.lang.Enum
* 自定义的继承于 Object
* */
public class Vifi01_01 {
public static void main(String[] args) {
Seasa seasa = Seasa.CCC;
System.out.println(seasa);
//获取其父类
System.out.println(Seasa.class.getSuperclass());
}
}
// 使用enum关键字定义
enum Seasa{
//1.提供当前枚举类的对象，多个对象之间用逗号隔开，末尾用分号结束
aaa("春天","春天01"),
BBB("夏天","夏天01"),
CCC("秋天","秋天01"),
ddd("冬天","冬天01");
//2.声明Seasa 对象的属性
public final String seaName;
public final String seaDes;
//3.私有化类的构造器
private Seasa(String seaName,String seaDes){
//4.私有化构造方法，并给对象属性赋值
this.seaName = seaName;
this.seaDes = seaDes;
}
//5.如果想获取枚举类的属性(final 只能生成get方法),不重写toString()生成其方法名称；
public String getSeaName() {
return seaName;
}
public String getSeaDes() {
return seaDes;
}
}
package com.bdit.vifition;
/*
* enum 方法
* values() 返回枚举类型的对象数组，遍历所有的枚举值
* valueof(String str) 可以把一个字符串转换为对应的枚举类对象，要求改字符串必须是枚举对象
* toString()
* */
public class Vifi01_02 {
public static void main(String[] args) {
Seasonda seasonda01 = Seasonda.ddd;
System.out.println(seasonda01);
System.out.println("-------------------------------------------");
// values
Seasonda[] seavalues = Seasonda.values();
for (int i = 0; i < seavalues.length; i++) {
System.out.print(seavalues[i]+" ");
}
System.out.println();
// 看枚举类状态
Thread.State[] values = Thread.State.values();
for (int i = 0; i < values.length; i++) {
System.out.print(values[i]+" ");
}
System.out.println();
// valuesof()
Seasonda seasonda02 = Seasonda.valueOf("BBB");//如果没有此对象，则抛异常
System.out.println(seasonda02);
}
}
enum Seasonda{
aaa("春天","春天01"),
BBB("夏天","夏天01"),
CCC("秋天","秋天01"),
ddd("冬天","冬天01");
public final String seaName;
public final String seaDes;
private Seasonda(String seaName,String seaDes){
this.seaName = seaName;
this.seaDes = seaName;
}
public String getSeaName() {
return seaName;
}
public String getSeaDes() {
return seaDes;
}
}
package com.bdit.vifition;
/*
* 实现接口,转Vifi01_04
* */
public class Vifi01_03 {
public static void main(String[] args) {
Seaa seaa01 = Seaa.aaa;
System.out.println(seaa01);
seaa01.show();
}
}
//第一种 实现接口,在enum中实现接口
interface Infoa{
void show();
}
enum Seaa implements Infoa{
aaa("春天","春天01"),
BBB("夏天","夏天01"),
CCC("秋天","秋天01"),
ddd("冬天","冬天01");
public final String seaName;
public final String seaDes;
private Seaa(String seaName,String seaDes){
this.seaName = seaName;
this.seaDes = seaDes;
}
public String getSeaName() {
return seaName;
}
public String getSeaDes() {
return seaDes;
}
@Override
public void show() {
System.out.println("接口，实现接口");
}
}
package com.bdit.vifition;
public class Vifi01_04 {
public static void main(String[] args) {
Seaabb seaa01 = Seaabb.aaa;
Seaabb seaa02 = Seaabb.BBB;
System.out.println(seaa01);
seaa01.show();
seaa02.show();
}
}
//第二种 实现接口,在enum属性中每一个实现接口
interface Infoab{
void show();
}
enum Seaabb implements Infoab{
aaa("春天","春天01"){
@Override
public void show() {
System.out.println("春天，实现抽象方法");
}
},
BBB("夏天","夏天01"){
@Override
public void show() {
System.out.println("夏天，实现抽象方法");
}
},
CCC("秋天","秋天01"){
@Override
public void show() {
System.out.println("秋天，实现抽象方法");
}
},
ddd("冬天","冬天01"){
@Override
public void show() {
System.out.println("冬天，实现抽象方法");
}
};
public final String seaName;
public final String seaDes;
private Seaabb(String seaName,String seaDes){
this.seaName = seaName;
this.seaDes = seaDes;
}
public String getSeaName() {
return seaName;
}
public String getSeaDes() {
return seaDes;
}
}
二、缓冲流
2.1 概述
- 缓冲流也称高效流，是对基本的写入写出流的增强，所以也是四个，根据数据类型划分为：
- 字节缓冲流：BufferedInputStream、BufferedOutputStream
- 字符缓冲流：BufferedReader、BufferWriter
- 缓冲流基本原理：就是在创建对象的时候，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写(因为在内存中，所以速度最快)减少了IO的次数，从而提高了效率
2.2 字节缓冲流
- 构造方法：
- public BufferedIinputStream(InputStream in)：创建一个新的缓冲流输入对象
- public BufferedOutputStream(OutputStream out)：创建一个新的缓冲流输出对象
效率测试：应选取大的文件
package com.bdit.test;
import java.io.*;
public class Test04_hcliu {
public static void main(String[] args) {
try {
long open = System.currentTimeMillis();
BufferedInputStream bin = new BufferedInputStream(new FileInputStream("d:\\jdk.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("f:\\jdk.exe"));
byte[] ch01 = new byte[1024];
int a = bin.read(ch01);
while(a!=-1){
bos.write(ch01,0,a);
// bos.write(a);
a= bin.read(ch01);
}
bos.flush();
bos.close();
bin.close();
long end = System.currentTimeMillis();
System.out.println("耗时："+(end-open));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
基本流
package com.bdit.test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test04_01 {
public static void main(String[] args) {
try {
long open = System.currentTimeMillis();
FileInputStream fin = new FileInputStream("d:\\jdk.exe");
FileOutputStream fos = new FileOutputStream("f:\\jdk.exe");
byte[] ch01 = new byte[1024];
int a = fin.read(ch01);
while (a!=-1){
fos.write(ch01,0,a);
a=fin.read(ch01);
}
fos.flush();
fos.close();
fin.close();
long end = System.currentTimeMillis();
System.out.println("耗时："+(end-open));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.3 字符缓冲流
- 构造方法
- public BufferedReader(Reader in)：创建使用默认大小的输入缓冲区的缓冲字符输入流
- public BUfferedWriter(Writer out)：创建使用默认大小的输出缓冲区的缓冲字符输出流
- 特有方法
- BufferedReader： public String readLine()：读一行文字
- BufferedWriter：public coid newLine()：写一行分隔符
package com.bdit.test;
import java.io.*;
public class Test05_01zfhcl {
public static void main(String[] args) {
try {
BufferedWriter bwr = new BufferedWriter(new FileWriter("F:\\bdit\\as.txt"));
bwr.write("一二三四，二二三四");
bwr.newLine();//换行
bwr.write("十四点：十八分");
bwr.flush();
bwr.close();
BufferedReader brd = new BufferedReader(new FileReader("F:\\bdit\\as.txt"));
String a = brd.readLine();//一次读一行
while(a!= null){
System.out.println(a+"--------");
a= brd.readLine();
}
brd.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
三、转换流
3.1 字符编码、字符集
- 这是两个概念
- 在计算机上面显示的东西都是二进制的，而这些都是通过某种规则，将字符存储到计算机中，称为编码
- 将储存在计算机中的二进制数按照某种规则解析出来称为解码
- 字符编码 就是一套自然语言的字符与二进制数之间的对应规则
3.2 字符集
- 字符集Charset：也叫编码表，是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
计算机要准确的存储和识别各种字符集数据，需要进行字符编码，一套字符集必然至少有一套字符编码，常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。
所以，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们要最终关心的。
-
ASCII字符集：
- ASCII美国信息交换标准代码，是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符（英文大小写字符、阿拉伯数字和西文符号）
- 基本的ASCII字符集，使用7位(bites)表示一个字符，共128字符，ASCII的扩展字符集使用8位，表示一个字符，共256字符，方便之处欧洲常用字符。
-
ISO-8859-1字符集
- 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括：荷兰、丹麦、德语、意大利等
- ISO-8859-1使用单字节编码，兼容ASCII编码
-
GBxxx字符集：
- GB就是国标的意思，是为了显示中文而设计的一套字符集
- GB2312：简体中文编码表，一个小于127的字符的意义与原来相同；但两个大于127的字符连在一起就表示一个汉字，这样大约可以组合了包含7000多个简体汉字
- GBK：最常用的中文编码表，是在GB2312的基础上扩展规范，使用了双字节编码，共收录20000多个汉字，兼容GB2312
- GB18030:最新的中文编码表，收录汉字7万多个，采用多字节编码，每个字可以由1个，2个或4个字节组成
-
Unicode字符集
- Unicode编码系统为为表达任意语言的任意字符而设计的，是业界的一种标准，也称为统一编码，标准万国码
- 它最多使用4个字节的数字表达字母、符号、或者文字、有三种编码方案，UTF-8、UTF-16和UTF-32
- UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传输文字应用中，优先采用的编码。IETF要求所有互联网协议都必须支持UTF-8编码，所以我们做程序开发，也要使用UTF-8编码。编码规则：
- 128个US-ASCII字符，只需要一个字节
- 拉丁文字符，需要两个字节
- 中文，使用三个字节编码
3.3 InputStreamReader 类
- 转换流 java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁，它读取字节，并使用指定的字符集将其解码成字符。他的字符集可以由名称指定，也可以接受平台的默认字符集
- 构造方法：
- InputStreamReader(InputStream in)：创建一个使用默认字符集的InputStreamReader
- InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
package com.bdit.test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
//InputStreamReader 字节流到字符流的桥梁，读取字节，再按指定的解码格式给其解码(解码成字符)，不同的解码格式会爆乱码
public class Test06_01jiema {
public static void main(String[] args) {
try {
InputStreamReader isr = new InputStreamReader(new FileInputStream("F:\\bdit\\as.txt"),"gb2312");
int a =isr.read();
while(a!=-1){
System.out.print((char)a);
a=isr.read();
}
isr.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.4 OutputStreamWriter 类
转换流java.io.OutputStreamWriter 是Writer的子类，是从字符流到字节流的桥梁，使用指定的字符集将字符编码为字节，字符集可以自己定义也可默认平台
- 构造方法
- OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
- OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
package com.bdit.test;
import java.io.*;
public class Test06_02 {
public static void main(String[] args) {
try {
OutputStreamWriter bwr = new OutputStreamWriter(new FileOutputStream("F:\\bdit\\as.txt"),"gb2312");
bwr.write(100);
bwr.write("一二三四");
bwr.flush();
bwr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
四、打印流
4.1 概述
- 在控制台输出时，调用的是：print、println，而这两个方法来自于 java.io.PrintStream类，该类能够方便地打印各种数据类型的信息，是一种便捷的输出流。
4.2 PrintStream 类
package com.bdit.test;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
public class Test07_01dayin {
public static void main(String[] args) {
try {
PrintStream ps = new PrintStream(new File("F:\\bdit\\as.txt"));
ps.println(12);
ps.print("a");
ps.print("明天是线程");
ps.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
1887
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
