回顾

  1. 输入流
  2.     字节输入流：FileInputStream
  3.         read()
  4.         本身没有缓冲，需要加缓冲流BufferedInputStream
  5.     字符输入流：FileReader
  6.         本身没有缓冲，需要加缓冲流BufferedReader
  7. 输入流
  8.     字节输出流:FileOutputStream
  9.         write()
  10.         本身没有缓冲，需要加缓冲流BufferedOutputStream
  11.     字符输出流：FileWriter
  12.         本身没有缓冲，需要加缓冲流BufferWriter

1.IO流

1.1字符输入流

字符输入流：FileReader

  1.     阅读字符文件（txt）的便利类。图片、音频、视频属于字节不能使用字符流
  3.     字符流本质还是字节流，只不过需要一个解码的过程。

FileReader案例

  1. package com.qfedu.test1IOliu;
  3. import java.io.BufferedReader;
  4. import java.io.File;
  5. import java.io.FileReader;
  6. import java.io.IOException;
  8. //字符输入流案例 FileReader
  9. public class Demo1 {
  10.     public static void main(String[] args) throws IOException {
  11.         //输入流就是磁盘读取到内存
  12.         //1.创建文件对象，要被读取的文件对象
  13.         File file = new File("E:/aaa/3.txt");
  14.         //2.创建字符输入流
  15.         FileReader fr = new FileReader(file);
  16.         //3.添加缓冲
  17.         BufferedReader br = new BufferedReader(fr);
  18.         //4.字符数组
  19.         char[] ch = new char[1024 * 4];
  21.         int length = -1;
  22.         while((length = br.read(ch)) != -1) {
  23.             System.out.println(length);
  24.         }
  25.         //字符数组是可以在控制台打印的
  26.         System.out.println(ch);
  27.         br.close();
  28.         fr.close();
  29.     }
  30. }

1.2字符输出流

2.常用类

2.1StringBuffer

线程安全的，可变字符串序列

String是不可变的，不改变内存地址

addend：拼接

insert：在指定位置添加

reverse：字符串反转（倒叙）

  1. package com.qfedu.test2changyongclass;
  3. public class Demo1 {
  4.     public static void main(String[] args) {
  5.         String string = "哈哈";
  6.         String string1 = string + "呵呵";
  7.         System.out.println(string1);
  9.         StringBuffer sb = new StringBuffer("start");
  10.         System.out.println(sb);
  11.         sb.append("啊？");//这样拼接 内存地址不变
  12.         System.out.println(sb);
  13.         sb.insert(2, "啥");//在指定位置插入字符串
  14.         System.out.println(sb);
  16.         StringBuffer sb1 = sb.reverse();//字符串反转
  17.         System.out.println(sb1);
  18.     }
  19. }

2.2枚举（enum）

java中的枚举是一个特殊的类，一般表示一组常量（final static int WEEK）,比如一年有12个月，四个季节

java中定义枚举类使用关键字 enum，常量之间用逗号“，”隔开

  1. package com.qfedu.test3enum;
  3. public enum Coler {
  4.     //下面写常量，而且常量都是大写的
  5.     RED,GREEN,BULE
  6.     //代表的就是三种颜色，没必要赋值
  7. }

2.2.1使用实例：

  1. package com.qfedu.test3enum;
  3. //枚举使用的案例
  4. enum Color2{
  5.     RED,GREEN,BULE
  6. }
  7. public class Demo2 {
  8.     public static void main(String[] args) {
  9.         Color2 color2 = Color2.RED;//枚举类.常量
  10.         System.out.println(color2);
  11.     }
  12. }

2.2.2枚举在swich case中的使用【重点】

  1. package com.qfedu.test3enum;
  3. //枚举在swich case中的使用
  4. enum Color3{
  5.     RED,GREEN,BLUE
  6. }
  7. public class Demo3 {
  8.     public static void main(String[] args) {
  9.         Color3 color3 = Color3.BLUE;
  10.         switch (color3) {
  11.         case RED:
  12.             System.out.println("红色");
  13.             break;
  14.         case GREEN:
  15.             System.out.println("绿色");
  16.             break;
  17.         case BLUE:
  18.             System.out.println("蓝色");
  19.             break;
  21.         default:
  22.             System.out.println("没有这个颜色");
  23.             break;
  24.         }
  25.     }
  26. }

2.2.3枚举下面的方法

  1. values();    //返回枚举中所有的值 返回一个数组
  2. ordial();    //可以找到每个枚举的常量索引
  3. valueof();    //返回指定字符串的枚举常量
  1. package com.qfedu.test3enum;
  3. enum Color4{
  4.     RED,GREEN,BULE
  5. }
  6. public class Demo4 {
  7.     public static void main(String[] args) {
  8.         //返回枚举中所有的值 返回一个数组
  9.         Color4[] color4s = Color4.values();
  10.         for (Color4 color4 : color4s) {
  11.             System.out.println(color4);
  12.             //可以找到每个枚举的常量索引
  13.             System.out.println("索引" + color4.ordinal());
  14.         }
  15.         System.out.println("----------");
  16.         //返回指定字符串的枚举常量
  17.         System.out.println(Color4.valueOf("RED"));
  18.         System.out.println(Color4.valueOf("YELLOW"));//没有就会报错
  19.     }
  21. }

2.2.4 枚举高级用法

枚举和普通类一样，可以有自己的常量，方法，构造方法等，构造方法只能是private修饰的，外部类不能使用！！！！枚举可以有普通方法，也可以有抽象方法。

枚举中的抽象方法，必须去用常量重写方法

  1. package com.qfedu.test3enum;
  3. //枚举高级使用
  4. enum Color5{
  5.     RED {
  6.         @Override
  7.         public void eat() {
  8.             // TODO Auto-generated method stub
  9.             System.out.println("红色");
  10.         }
  11.     },GREEN {
  12.         @Override
  13.         public void eat() {
  14.             // TODO Auto-generated method stub
  15.             System.out.println("绿色");
  16.         }
  17.     },BULE {
  18.         @Override
  19.         public void eat() {
  20.             // TODO Auto-generated method stub
  21.             System.out.println("蓝色");
  22.         }
  23.     };
  24.     final static int age = 7;
  25.     private Color5() {//构造方法 外部使用不了
  27.     }
  28.     //正常方法
  29.     public void colorInfo() {
  30.         System.out.println("颜色的表示形式");
  31.     }
  32.     //抽象方法
  33.     public abstract void eat();
  35. }
  36. public class Demo5 {
  37.     public static void main(String[] args) {
  38.         for (Color5 c5 : Color5.values()) {
  39.             c5.eat();
  40.         }
  41.         System.out.println("------");
  42.         Color5.BULE.eat();
  43.         System.out.println(Color5.age);
  44.     }
  46. }