Java.String类和IO流
String类
获取方法
int length();
获取字符串长度 ""
char charAt(int index);
获取String字符串中指定下标位置的char类型字符，如果index超出有效范围
异常：StringIndexOutOfBoundsException
int indexOf(char ch);
int indexOf(String str);
int indexOf(char ch, int fromIndex);
int indexOf(String str, int fromIndex);
这些方法都是获取指定元素所在的下标位置，元素可以是char类型字符，也可以是字符串。这里找出的是指定元素在字符串中第一次出现的位置，当然可以通过一定的约束，从哪个位置开始找fromIndex
int lastIndexOf(char ch);
int lastIndexOf(String str);
int lastIndexOf(char ch, int fromIndex);
int lastIndexOf(String str, int fromIndex);
这些方法都是获取指定元素所在的下标位置，元素可以是char类型字符，也可以是字符串。这里找出的是指定元素在字符串中最后一次出现的位置，当然可以通过一定的约束，从哪个位置开始找fromIndex
判断方法
boolean endsWith(String str);
判断当前字符串是不是以指定字符串结尾
boolean isEmpty();
判断字符串是否为空 ""空串 JDK1.6之后 null不能读取，不能写入，不能调用方法
boolean equals(Object obj);
继承重写Object类内的方法，完成字符串要求的比较方式
boolean equalsIgnoreCase(String str);
不区分大小写比较
boolean contains(String str);
判断指定字符串是否存在
转换方法
String(char[] arr);
使用字符数组中内容创建一个字符串对象
String(char[] arr, int offset, int length);
String(char[] arr, int off, int len);
String(char[] arr, int off, int cou);
String(char[] arg0, int arg1, int arg2);
使用字符数组中内容创建一个字符串对象，offset是从char类型数组中指定下标位置开始获取数据，获取的数据长度是length
static String valueOf(char[] arr);
通过类名调用的静态方法，实际执行的是
String(char[] arr);
static String valueOf(char[] arr, int offset, int length);
通过类名调用的静态方法，实际执行的是
String(char[] arr, int offset, int length);
char[] toCharArray();
返回当前字符串对应的字符数组
其他方法
String replace(char oldChar, char newChar)
替换，替换不会修改原始的字符串，会创建一个新字符串返回，并且替换效果是所有的对应 的oldChar全部替换成newChar ???
String[] split(String regex)
按照指定的字符串切割当前字符串[00:00:15]XXXXXXX
String substring(int beginIndex);
从指定位置开始，截取子字符串，到字符串末尾
String substring(int beginIndex, int endIndex)
从指定位置开始beginIndex，到endIndex结束，要头不要尾
String toUpperCase() 转大写
字符串小写转大写
String toLowerCase() 转小写
字符串大写转小写
String trim() 去除空格
去除字符串两边的无用空格
IO流
什么是IO流
这里的输入输出的参照物是内存，即相对内存来说的输入输出，输入就是从硬盘中读取数据到内存，输出就是把内存中的数据写入硬盘。
I：input输入流 read数据
O：output输出流 write写入数据
从硬盘中读取数据到内存 input
从内存中保存数据到硬盘 output
文件操作为例
1GB完整的文件拷贝过程，要远远高于1GB散文件的拷贝过程。
- 打开文件，关闭文件消耗资源较少
- 1GB散文件就需要不断的打开，关闭资源操作时间的消耗和打开文件，关闭文件或者说打开硬盘，关闭硬盘有直接关系。
看视频，缓冲
使用缓冲可以让用户体验提高，相对来说较为平和的观看体验。
网页第一次访问时，加载时间较慢，第二次打开，速度很快。
IO流基类：
InputStream 输入流基类 read
OutputStream 输出流基类 write
IO流分类
流向分类：输入 输出
文件操作处理单元分类：字节流和字符流
FileInputStream 文件操作输入字节流
FileOutputStream 文件操作输出字节流
FileReader 文件操作输入字符流
FileWriter 文件操作输出字符流
文件操作字节流
文件操作输入字节流
FileInputStream 文件操作输入字节流
Constructor 构造方法：
FileInputStream(File file);
这里是根据提供的File类对象创建对应的文件操作输入字节流。
FileInputStream(String pathName);
这里是根据提供的String类型文件路径，创建对应的文件操作输入字节流。
都会抛出异常：
FileNotFoundException 文件未找到异常。
Method 成员方法：
int read();
从文件中读取一个字节数据返回到方法外。
虽然返回值是一个int类型，但是在整个int类型当中存储的数据是一个byte类型，有且只有低8位数据有效。
int read(byte[] buf);
读取文件的内容是存储在byte类型数组中，返回值是读取到的字节个数
int read(byte[] buf, int offset, int count);
读取文件的内容是存储在byte类型数组中，要求从byte数组offset位置开始，到count长度结束，返回值是读取到的字节个数。
以上三个方法如果读取到文件末尾，返回值都是 -1 EOF End Of File
而且以上方法都要异常抛出 IOException IO异常
使用演示
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/*
* 文件操作输入字节流
* 1. 确认读取哪一个文件
* 2. 创建对应文件的FileInputStream
* 3. 读取数据
* 4. 关闭资源 【重点】
*/
public class Demo1 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
readTest1();
long end = System.currentTimeMillis();
System.out.println("Time : " + (end - start));
}
public static void readTest2() {
// 1. 确定操作文件
File file = new File("C:\\aaa\\1.txt");
// 2. 字节输入流读取文件对象
FileInputStream fileInputStream = null;
try {
// 3. 根据File类对象创建对应的字节输入流
fileInputStream = new FileInputStream(file);
// 4. 准备一个8KB字节缓冲数组
byte[] buf = new byte[1024 * 8];
int length = -1;
// 5. 读取数据
while ((length = fileInputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, length));
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 在finally代码块中关闭资源
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/*
* low!!!
*/
public static void readTest1() {
// 1. 确定操作文件
File file = new File("C:\\aaa\\1.txt");
// 2. 字节输入流读取文件对象
FileInputStream fileInputStream = null;
try {
// 3. 根据File类对象创建对应的字节输入流
fileInputStream = new FileInputStream(file);
// 4. 读取文件
int content = -1;
while ((content = fileInputStream.read()) != -1) {
System.out.println((char)content);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 用于处理代码中使用到资源，无法发生什么样的错误，finally中的代码一定会执行
// 这里发现fileInputStream不是null，证明已经打开了文件资源，关闭资源，捕获异常
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
文件读取使用缓冲和非缓冲差距
内存的运作速度看做是火箭，硬盘就是一个自行车
以上代码中，使用缓冲之后，从硬盘中一口气读取8KB数据存储在内存中，供程序使用。
8KB
固态硬盘，4KB对齐。固态硬盘中每一个扇区都是4KB。
缓冲这里是要求CPU读取两个4KB数据，对于CPU而言没有太多压力。
如果是一个字节一个字节读取，CPU取出4KB数据，结果有4095无效。
文件操作输出字节流
FileOutputStream 文件操作输出字节流
Constructor 构造方法：
FileOutputStream(File file);
根据File类对象创建对应的文件输出字节流对象
FileOutputStream(String pathName);
根据String类型文件路径创建对应的文件输出字节流对象
以上两个构造方法，创建的FileOutputStream是删除写/清空写操作，会将原文件中的内容全部删除之后，写入数据。
FileOutputStream(File file, boolean append);
根据File类对象创建对应的文件输出字节流对象。创建对象时给予append参数为true，表示追加写。
FileOutputStream(String pathName, boolean append);
根据String类型文件路径创建对应的文件输出字节流对象，创建对象时给予append参数为true，表示追加写。
FileOutputStream构造方法是拥有创建文件的内容，如果文件存在，不创建，文件不存在且路径正确，创建对应文件。
否则抛出异常 FileNotFoundException
Method 成员方法：
void write(int b);
写入一个字节数据到当前文件中，参数是int类型，但是有且只会操作对应的低八位数据
void write(byte[] buf);
写入字节数组中的内容到文件中
void write(byte[] buf, int offset, int length);
写入字节数组中的内容到文件中，从指定的offset开始，到指定长度length
以上方法会抛出异常：IOException
使用演示
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 文件操作输出字节流
* 1. 确定文件
* 2. 创建FileOutputStream
* 3. 写入数据到文件中
* 4. 关闭资源
*/
public class Demo2 {
public static void main(String[] args) {
writeTest2();
}
public static void writeTest2() {
// 1. 确定文件
File file = new File("C:/aaa/中国加油.txt");
// 2. 文件操作字节输出流对象
FileOutputStream fileOutputStream = null;
try {
// 3. 创建FileOutputStream
fileOutputStream = new FileOutputStream(file);
// 4. 准备byte类型数组
byte[] bytes = "武汉加油！中国加油！".getBytes();
byte[] arr = {65, 66, 67, 68, 69, 70, 71};
fileOutputStream.write(bytes);
fileOutputStream.write(arr, 2, 3);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 关闭资源
if (fileOutputStream != null) {
try {
fileOutputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public static void wrietTest1() {
// 1. 确定文件
File file = new File("C:/aaa/武汉加油.txt");
// 2. 文件操作字节输出流对象
FileOutputStream fileOutputStream = null;
try {
// 3. 创建FileOutputStream
fileOutputStream = new FileOutputStream(file, true);
// 4. 写入数据
fileOutputStream.write('D');
fileOutputStream.write('D');
fileOutputStream.write('D');
fileOutputStream.write('D');
fileOutputStream.write('D');
fileOutputStream.write('D');
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 关闭资源
if (fileOutputStream != null) {
try {
fileOutputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
文件操作字符流
字符流特征
字符流 = 字节流 + 解码过程
字节组合操作 ==> 对应当前环境编码集的一个字符
如果字符找不到，该数据无效，需要被删除。
如果是字符内容操作，效率还可以。
如果是非字符操作，凶多吉少…
字符流操作文件
个人建议，该文件可以使用notepad 记事本打开无乱码，可以使用字符流操作。
视频文件，图片文件，特定格式的文件，都无法使用字符操作。
文件操作输入字符流
FileReader 文件操作输入字符流
Constructor 构造方法：
FileReader(File file)
根据File类对象创建对应的FileReader字符流输入对象
FileReader(String pathName)
根据String类型文件路径创建对应的FileReader字符流输入对象
如果文件不存在，抛出异常FileNotFoundException
Method 成员方法
int read();
读取文件中的一个字符数据，通过返回值返回，返回值类型是int类型，但是在int类型中有且只有低16位数据有效
int read(char[] arr);
读取文件中的数据保存到字符数组中，返回值类型是读取到的字符个数
int read(char[] arr, int off, int len);
读取文件中的数据保存到字符数组中，要求从数组中下标offset开始，到len结束，返回值类型是读取到的字符个数。
以上方法，如果读取到文件默认，返回值为-1 EOF End Of File
如果读取操作工作中，出现问题，抛出异常IOException
文件操作输出字符流
FileWriter文件操作输出字符流
Constructor 构造方法：
FileWriter(File file);
根据File类对象创建对应文件的文件操作输出字符流
FileWriter(String pathName);
根据String类型文件路径创建对应文件的文件操作输出字符流
FileWriter(File file, boolean append);
根据File类对象创建对应文件的文件操作输出字符流，并要求为追加写
FileWriter(String pathName, boolean append);
根据String类型文件路径创建对应文件的文件操作输出字符流，并要求为追加写。
如果创建FileWrite对象时，这里文件不存在，路径合法，这里会创建对应的操作文件。如果路径不合法，抛出异常：FileNotFoundException
Method 成员方法：
void write(int ch);
写入一个char类型数据到文件中
void write(char[] arr);
写入一个char类型数组到文件中
void write(char[] arr, int offset, int length);
写入一个char类型数组到文件中，要求从offset下标位置开始读取数组数据，长度为length 。
如果写入数据操作过程中，发生问题，这里会有一个 IOException
使用演示
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/*
* 文件操作字符输出流
*/
public class Demo1 {
public static void main(String[] args) {
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(new
File("D:/aaa/5.txt"), true);
char[] charArray = "现在美国全国缺少口罩2.7亿".toCharArray();
fileWriter.write(charArray);
fileWriter.write("韩国目前疫情情况不容乐观");
fileWriter.write("\r\n");
fileWriter.write(charArray, 0, 5);
fileWriter.write("韩国目前疫情情况不容乐观", 0, 5);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
private static void writeTest1() {
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(new File("D:/aaa/4.txt"), true);
fileWriter.write('武');
fileWriter.write('汉');
fileWriter.write('加');
fileWriter.write('油');
fileWriter.write('，');
fileWriter.write('中');
fileWriter.write('国');
fileWriter.write('加');
fileWriter.write('油');
fileWriter.write(',');
fileWriter.write('世');
fileWriter.write('界');
fileWriter.write('加');
fileWriter.write('油');
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
字符流文件拷贝
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
* 使用文件操作字符流量拷贝非文本文件问题
* 【要求】
* 禁止使用字符流操作非文本文件，记事本打开乱码文件都不可以
*/
public class Demo2 {
public static void main(String[] args) {
FileReader fileReader = null;
FileWriter fileWriter = null;
try {
fileReader = new FileReader(new File("D:/aaa/logo桌面.jpg"));
fileWriter = new FileWriter(new File("D:/aaa/temp.jpg"));
char[] buf = new char[1024 * 4];
int length = -1;
while ((length = fileReader.read(buf)) != -1) {
fileWriter.write(buf, 0, length);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (fileReader != null) {
try {
fileReader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}