一、Vector 和 ArrayList

相同点：

1：都是List 的实现的子类。

2：底层都是使用数组实现。

不同点：

1：ArrayList 是一个线程非安全的，效率更高。Vector  是一个线程安全的，效率相对较低。所以在线程安全的情况下优先考虑ArrayList 。

2：ArrayList 相比 Vector 出现的更晚。

3：扩容的规则不同：Vector  %100 扩容。。ArrayList 50% 扩容。

4：Vector  可以使用枚举器  Enumeration 遍历。

二、ArrayList 和 LinkedList

相同点：

1：都属于List 实现的子类。

2：都可以通过序号访问元素。

不同点：

1：ArrayList 底层使用 数组实现。LinkedList 使用双向链表实现。

2：ArrayList 遍历的效率很高。LinkedList 遍历的效率相对较低。

3：ArrayList 根据内容查找，删除元素，插入元素，效率相对较低，因为要移动大量的元素。

三、HashMap 和 HashTable

--WeekHashMap：如果一个对象的引用只被包含在了 WeekHashMap 中，垃圾回收的时候可以被回收掉。

--IdentityHashMap：key 的唯一性 通过 == 比较。实现唯一性，而不是通过key 的equals 来比较内容保证唯一性。

import java.util.Enumeration;

import java.util.Hashtable;

public class TestHashTable {

public static void main(String[] args) {

//Hashtable 是早期的一个 映射关系的容器类。

//早期继承了类 Dictionary 字典类。后来Map 接口出现之后，又实现了Map 接口。

//HashMap 的key 和 value 都可以是null.

//Hashtable 的key 和 value 都不能是null。

//Hashtable 是一个线程安全的容器，HashMap 是一个非安全的，效率更高。

Hashtable table = new Hashtable<>();,>

table.put("cn", "China");

table.put("uk", "United Kingdom");

table.put("uk", "England");

table.put("us", "America");

// table.put("jp", null);

//早期的Hashtable的遍历方式

//得到所有的key 的枚举器 通过key 可以得到value

Enumeration keys = table.keys();

while (keys.hasMoreElements()) {

String key = keys.nextElement();

String value = table.get(key);

System.out.println(key +" --> "+ value);

}

//得到所有的value ，不能获得对应的key

Enumeration elements = table.elements();

while (elements.hasMoreElements()) {

String value = elements.nextElement();

System.out.println(" --> "+ value);

}

System.out.println(table);

}

}

四、Collection 和 Collections

不同点：一个是容器类的顶层接口，一个是用于操作容器的工具类。

java.util.Arrays:一个用于操作数组的工具类。

java.util.Collections：一个用于操作容器的工具类。

里面封装了很多操作容器对象的各种的方法。

static Enumeration  enumeration(Collection c)

返回一个指定collection 上的枚举。

五、数组-容器

1：数组的长度是不能更改的。

所有的容器的容量都是可以根据需求增长，扩容的。

2：数组进行元素的删除和插入操作的时候，效率比较低。需要移动大量的元素。

HashMap 进行元素的删除和插入操作，效率比较高。LinkedList 效率也很高，就是需要先定位元素的位置（效率低）。

3：数组元素的类型只能是一种。

容器中只要是Object类的实例即可放到容器中，作为元素。

4：数组通过内容查找元素的效率是比较低的。

HashMap 通过内容查找元素效率比较高。

5：数组的元素是连续分配的，那么必须在堆内存中找到连续的指定内存空间才能容纳数组的所有的数据。对内存要求稍微多一些。

链表、二叉树、散列表（一部分要求连续），都没有要求元素必须是连续分配的。

6：数组没有提供任何的封装，所有对元素的操作，都是通过自定义方法来实现的。对数组元素的操作比较麻烦。

所有的容器都被封装成了类，提供了各种对元素操作的方法。

六、IO流

I：input  输入：将外部的数据读取到程序的内存中。

O：output 输出：将程序内存中的数据写出到其他的地方。

File 类：不能对文件读写。

需要通过IO 流来实现对文件的读写。

概念：流就是信息的通道。通过该通道可以实现对文件的读写操作。stream

流的分类：

1：按照数据的流向来分：

1：输入流  可以将外部的数据读取内存中的流   InputStream、Reader

2：输出流  将内存中的数据写出到目的地的流   OutputStream、Writer

2：按照流处理的最小的数据单元来分：

1：字节流  流每次处理的数据的最小单元是 1 byte。 InputStream   OutputStream

2：字符流  流每次处理的数据的最小单元是 1个 char Reader   Writer

字节流，什么类型的数据都可以处理。音频，视频，图片，文本。

字符流，只能处理文本数据。别的类型不能处理。处理字符功能更强。

3：按照处理的数据的源头不同来分：

1：节点流 ：直接和数据源相连的流。 FileInputStream FileOutputStream

2：处理流、包装流：以其他的流为数据源的流。 BufferedInputStream  BufferedOutputStream

InputStream：是一个抽象类，是所有的字节输入流的父类。

OutputStream：是一个抽象类，是所有的字节输出流的父类。

Reader：是一个抽象类，是所有的字符输入流的父类

Writer：是一个抽象类，使所有的字符输出流的父类。

七、FileInputStream和FileOutputStream

和IO 相关的类 都在  java.io.*;

FileInputStream: 是InputStream 的子类。

文件字节输入节点流。可以用来将文件中的内容，读取到内存中来。

FileOutputStream： OutputStream 的子类。

文件字节输出节点流。

作用：对文件进行写入数据的。

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

public class FileInputOutStreamTest {

public static void main(String[] args) {

testFileInputStream2();

}

//将指定的文件的内容全部读取到内容中，并打印到控制台。

static void testFileInputStream(){

//创建文件对象

File file = new File("res/my_letter.txt");

try {

//创建流对象，在程序内存和 数据源之间建立了信息的通道。

FileInputStream fis = new FileInputStream(file);

//流对象提供了那些功能来读取数据源的信息。

//从数据源读取一个字节的数据，并返回  返回类型是 int。

//read 方法每次被调用，都会导致 流中记录读取位置的游标后移一个字节。

//读取下一个字节的数据。 如果流中不能在读取到数据（读取到了文件or 流的末尾返回-1）

int value = fis.read();

while(value != -1){//没有到达数据的末尾

System.out.print((char)value);

value = fis.read();

}

} catch (Exception e) {

e.printStackTrace();

}

}

//将指定的文件的内容全部读取到内容中，并打印到控制台。

static void testFileInputStream1(){

//创建文件对象

File file = new File("res/my_letter.txt");

try {

//创建流对象，在程序内存和 数据源之间建立了信息的通道。

FileInputStream fis = new FileInputStream(file);

//流对象提供了那些功能来读取数据源的信息。

byte[] buf = new byte[10];

//每次通过流从数据源最多可以读取buf.length个字节的数据。 

//被读取的字节数据保存到 数组中。返回的是本次读取到的有效的字节数。

//如果读取到了文件的末尾，返回 -1;

int count = fis.read(buf);

while(count != -1){

//是用字节数组生成字符串对象

String str = new String(buf,0,count);

System.out.print(str);

count = fis.read(buf);

}

//读取数据放到指定数组的区间中。

// fis.read(b, off, len)

} catch (Exception e) {

e.printStackTrace();

}

}

//测试其他的方法

static void testFileInputStream2(){

//创建文件对象

File file = new File("res/my_letter.txt");

FileInputStream fis = null;

try {

//创建流对象，在程序内存和 数据源之间建立了信息的通道。

fis = new FileInputStream(file);

//TODO

// int count = 0;

// while((count = fis.read(buf))!= -1){

// String str = new String(buf,0,count);

// System.out.print(str);

// }

//跳过指定的字节数

fis.skip(10);

//得到文件的长度，创建足够大的数据

long len = file.length();

byte[] buf = new byte[(int)len];

fis.read(buf);

String str = new String(buf);

System.out.println(str);

// 得到的文件中可以读取到的有效的字节数据个数

fis.available();

} catch (Exception e) {

e.printStackTrace();

}finally {

//要确保程序可以正常的关闭流对象。如果不关闭，那么垃圾回收器都不能正常回收掉。

if(fis != null){

try {

fis.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//对指定的文件写入指定的内容

static void testFileOutputStream(){

//

FileOutputStream fos = null;

try {

//创建流对象，当下面的语句执行的时候，会先将目的地的数据清空，然后再写入。

fos = new FileOutputStream("./res/2.txt",true);//true ,尾部添加，默认为false。

String str = "我女儿喜欢看海底小纵队，她是里面的皮医生！我呢，是呱唧！\n";

//将字符串转换为字节数组

byte[] buf = str.getBytes();

//通过流对象去写出指定内容

//将buf 中的全部的字节数据写出到目的地

fos.write(buf);

//fos.write(int) 将参数 int 的对应的字节数据写出去，每次写出一个字节。把参数的后八位写出去。

} catch (Exception e) {

e.printStackTrace();

}finally {

if(fos != null){

try {

fos.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//使用文件输入输出流来实现文件的复制。。如果文件不存在，那么使用FileOutputStream 往外写，那么会创建一个文件。

static void copyFile()throws Exception{

// 使用 文件输入流，读取字节数据，然后将读取到的字节数据，再尾部追加到指定的文件中。

FileInputStream fis = new FileInputStream("c:/dear.jpg");

FileOutputStream fos = new FileOutputStream("c:/dear_copy.jpg",true);

byte[] buf = new byte[1000];

int count = fis.read(buf);

while(count != -1){

//读取多少数据，写出去多少数据

fos.write(buf,0,count);

count = fis.read(buf);

}

fis.close();

fos.close();

}

}

 

八、read 和 write

问：为什么read 读取的是一个字节，返回的却是 int?

答：为了避免读取到的字节数据是八个二进制的1 的数据（-1）。如果读取到了一个 字节数据  是 -1 ，那么和 流的末尾的条件冲突。

即使读取到了8个 二进制的1，也需要转换为int 类型。

使用int 的低八位保存读取到的一个字节数据。

11111111111111111111111111111111

000000000000000000000000 1111 1111 === 255

使用按位与&0xff 来实现需求---使用int 的低八位保存读取到的 一个字节数据。

 

wirte(int value) 只将 value 的低八位写出去。使用（byte）value强转直接将value 的高24位全部砍掉了。

 

九、字符集

1：美国标准信息交换码：ASCII。

单字节的字符集,一共128个字符，只用到了一个字节数据的低7位。最高位是0.  每一个字符都对应着一个唯一的整数。

A<--->65  0<---->48  a<--->97

2: gb2312：是中国早期的一个字符集。兼容了ASCII。用一个字节的数据表示 ASCII 部分的字符。

中文简体，需要两个字节的数据才能表示一个中文字符。

3：gbk：兼容了gb2312. 增加了各个少数民族的符号，繁体中文。

中文简体，需要两个字节的数据才能表示一个中文字符。

4：utf-8：兼容了ASCII。三个字节代表一个中文。

5：Unicode：四个字节的。

 

十、FileReader和FileWriter以及flush

FileReader： 是 Reader 的子类。是用来读取字符的。

FileReader可以每次实现从底层的字节数据中读取一个或者多个字节数据，来保证这些字节数据是一个或者几个完整的字符。要依赖于某个字符集（平台默认的GBK）。从底层读取的是字节数据（整数）去默认的字符集中 找该整数对应的字符。

所有的字符流工作的时候都要依赖于某个字符集。

 

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.Arrays;

public class TestFileReaderWriter {

public static void main(String[] args) {

// testFileReader();

copyTextFile();

}

//从指定的文件中，读取全部的字符

static void testFileReader(){

FileReader fr = null;

try {

//创建字符输入流对象

fr = new FileReader("./res/1.txt");

int value = fr.read();

while(value != -1){

System.out.print((char)value);

value = fr.read();

}

} catch (Exception e) {

e.printStackTrace();

}finally {

if(fr != null){

try {

fr.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//使用文件字符输入输出流实现文本的复制

static void copyTextFile(){

FileReader fr = null;

FileWriter fw = null;

try {

fr = new FileReader("./res/my_letter.txt");

fw = new FileWriter("./res/my_letter_todear.txt");

// int value = 0;

// while((value = fr.read())!= -1){

// //将value 写出去

// fw.write(value);

// }

char[] buf = new char[10];

int count = 0;

while((count = fr.read(buf)) != -1){

System.out.println(Arrays.toString(buf));

//这个write 方法，并没有直接将字符数据写出到 目的文件中，

//写到了一个缓冲区中。为了减少直接对磁盘的IO 提高效率

//解决方案：1 把流正常关闭，关闭流的时候，所有的相关的缓冲区中的数据都将会被刷新到目的地。

//2:将缓冲区的数据，刷新出去。

fw.write(buf, 0, count);

}

//将缓冲区的数据，刷新出去到目的地。

fw.flush();

} catch (Exception e) {

e.printStackTrace();

}finally {

if(fr != null){

try {

fr.close();

} catch (IOException e) {

e.printStackTrace();

}

}

if(fw != null){

try {

fw.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

}

十一、BufferedInputStream和BufferedOutputStream

带缓冲区的字节输入输出流。为了提高读写的效率。

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class BufferedInputOutputStreamTest {

public static void main(String[] args) {

long time = System.currentTimeMillis();

copyFile();

long cost = System.currentTimeMillis()-time;

System.out.println("buffered cost = "+cost);

time = System.currentTimeMillis();

try {

copyFile1();

} catch (Exception e) {

e.printStackTrace();

}

cost = System.currentTimeMillis()-time;

System.out.println("cost = "+cost);

}

//带缓冲区实现文件复制

static void copyFile(){

BufferedInputStream bis = null;

BufferedOutputStream bos = null;

try {

//这是一个包装流，以其他的流为数据源读取数据。为了提高效率的

bis = new BufferedInputStream(new FileInputStream("c:/dear.jpg"));

bos = new BufferedOutputStream(new FileOutputStream("c:/nan.jpg"));

byte[] buf = new byte[100];

int count = bis.read(buf);

while(count != -1){

bos.write(buf, 0, count);

count = bis.read(buf);

}

} catch (Exception e) {

e.printStackTrace();

}finally {

if(bis != null){

try {

bis.close();

} catch (IOException e) {

e.printStackTrace();

}

}

if(bos != null){

try {

bos.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//使用文件输入输出流来实现文件的复制。。如果文件不存在，那么使用FileOutputStream 往外写，那么会创建一个文件。

static void copyFile1()throws Exception{

// 使用 文件输入流，读取字节数据，然后将读取到的字节数据，再尾部追加到指定的文件中。

FileInputStream fis = new FileInputStream("c:/dear.jpg");

FileOutputStream fos = new FileOutputStream("c:/dear_copy.jpg",true);

byte[] buf = new byte[1000];

int count = fis.read(buf);

while(count != -1){

//读取多少数据，写出去多少数据

fos.write(buf,0,count);

count = fis.read(buf);

}

fis.close();

fos.close();

}

}