Java的第六周学习报告

作者：钟良堂
一：Java 集合
早在 Java 2 中之前，Java 就提供了特设类。比如：Dictionary, Vector, Stack, 和 Properties 这些类用来存储和操作对象组。
虽然这些类都非常有用，但是它们缺少一个核心的，统一的主题。由于这个原因，使用 Vector 类的方式和使用 Properties 类的方式有着很大不同。
集合框架被设计成要满足以下几个目标。
该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。
该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。
对一个集合的扩展和适应必须是简单的。
为此，整个集合框架就围绕一组标准接口而设计。你可以直接使用这些接口的标准实现，诸如： LinkedList, HashSet, 和 TreeSet 等,除此之外你也可以通过这些接口实现自己的集合。

Java集合框架图
从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

集合框架体系如图所示
Java 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中，所以当使用集合框架的时候需要进行导包。
集合接口:
1：Collection 接口
Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。
Collection 接口存储一组不唯一，无序的对象。
2：List 接口
List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，
类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。
List 接口存储一组不唯一，有序（插入顺序）的对象。
3：Set
Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。
Set 接口存储一组唯一，无序的对象。
4：SortedSet
继承于Set保存有序的集合。
5：Map
Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
6：Map.Entry
描述在一个Map中的一个元素（键/值对）。是一个Map的内部类。
7：SortedMap
继承于 Map，使 Key 保持在升序排列。
8:Enumeration
这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。
Set和List的区别：

Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。
集合实现类（集合类）
Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。

1:AbstractCollection
实现了大部分的集合接口。
2:AbstractList
继承于AbstractCollection 并且实现了大部分List接口。
3:AbstractSequentialList
继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。
4:LinkedList
该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：

List list=Collections.synchronizedList(newLinkedList(...));

LinkedList 查找效率低。
5:ArrayList
该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
6:AbstractSet
继承于AbstractCollection 并且实现了大部分Set接口。
7:HashSet
该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
8:LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9:TreeSet
该类实现了Set接口，可以实现排序等功能。
10:AbstractMap
实现了大部分的Map接口。
11:HashMap
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
12:TreeMap
继承了AbstractMap，并且使用一颗树。
13:WeakHashMap
继承AbstractMap类，使用弱密钥的哈希表。
14:LinkedHashMap
继承于HashMap，使用元素的自然顺序对元素进行排序.
15:IdentityHashMap
继承AbstractMap类，比较文档时使用引用相等。
在前面的教程中已经讨论通过java.util包中定义的类，如下所示：
1:Vector
该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
2:Stack
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
3:Dictionary
Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。
4:Hashtable
Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。
5:Properties
Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
6:BitSet
一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。
集合算法
集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法。
在尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。
集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。

如何使用迭代器
通常情况下，你会希望遍历一个集合中的元素。例如，显示集合中的每个元素。
一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或ListIterator接口。
迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了Iterator，以允许双向遍历列表和修改元素。
遍历 ArrayList
实例

import java.util.*; 
public class Test{ 
public static void main(String[] args) { 
List<String> list=new ArrayList<String>(); 
list.add("Hello"); 
list.add("World"); 
list.add("HAHAHAHA"); //第一种遍历方法使用 For-Each 遍历 
List for (String str : list) { //也可以改写这种形式
for(int i=0;i<list.size();i++) 
System.out.println(str); 
} //第二种遍历，把链表变为数组相关的内容进行遍历 
String[] strArray=new String[list.size()]; 
list.toArray(strArray); 
for(int i=0;i<strArray.length;i++) //这里也可以改写为这种形式
for(String str:strArray) { 
System.out.println(strArray[i]); 
} //第三种遍历 使用迭代器进行相关遍历 
Iterator<String> ite=list.iterator(); 
//判断下一个元素之后有值
while(ite.hasNext()) { 
System.out.println(ite.next()); 
} 
} 
}

解析：
三种方法都是用来遍历ArrayList集合，第三种方法是采用迭代器的方法，该方法可以不用担心在遍历的过程中会超出集合的长度。
遍历 Map
实例

import java.util.*; 
public class Test{ 
public static void main(String[] args) { 
Map<String, String> map = new HashMap<String, String>(); 
map.put("1", "value1"); 
map.put("2", "value2"); 
map.put("3", "value3"); //第一种：普遍使用，二次取值 
System.out.println("通过Map.keySet遍历key和value："); 
for (String key : map.keySet()) { 
System.out.println("key= "+ key + " and value= " + map.get(key)); 
} //第二种 
System.out.println("通过Map.entrySet使用iterator遍历key和value："); 
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); 
while (it.hasNext()) { 
Map.Entry<String, String> entry = it.next(); 
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue()); 
} //第三种：推荐，尤其是容量大时 
System.out.println("通过Map.entrySet遍历key和value"); 
for (Map.Entry<String, String> entry : map.entrySet()) { 
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue()); 
} //第四种 
System.out.println("通过Map.values()遍历所有的value，但不能遍历key"); 
for (String v : map.values()) { 
System.out.println("value= " + v); 
} 
} 
}

如何使用比较器
TreeSet和TreeMap的按照排序顺序来存储元素. 然而，这是通过比较器来精确定义按照什么样的排序顺序。
这个接口可以让我们以不同的方式来排序一个集合。
总结
Java集合框架为程序员提供了预先包装的数据结构和算法来操纵他们。
集合是一个对象，可容纳其他对象的引用。集合接口声明对每一种类型的集合可以执行的操作。
集合框架的类和接口均在java.util包中。
任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。
二：Java 泛型
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？
答案是可以使用 Java 泛型。
使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。
泛型方法
你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。
下面是定义泛型方法的规则：
所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的）。
每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。
实例

public class GenericMethodTest { // 泛型方法 printArray 
public static < E > void printArray( E[] inputArray ) { // 输出数组元素 
for ( E element : inputArray ){ 
System.out.printf( "%s ", element ); 
} 
System.out.println(); 
} 
public static void main( String args[] ) { // 创建不同类型数组： Integer, Double 和 Character 
Integer[] intArray = { 1, 2, 3, 4, 5 }; 
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 }; 
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' }; 
System.out.println( "整型数组元素为:" ); 
printArray( intArray ); // 传递一个整型数组 
System.out.println( "\n双精度型数组元素为:" ); 
printArray( doubleArray ); // 传递一个双精度型数组 
System.out.println( "\n字符型数组元素为:" ); 
printArray( charArray ); // 传递一个字符型数组 
} 
}

编译以上代码，运行结果如下所示：

整型数组元素为:1 2 3 4 5 
双精度型数组元素为:1.1 2.2 3.3 4.4 
字符型数组元素为:
H E L L O

有界的类型参数:
可能有时候，你会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。
要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。
实例
下面的例子演示了"extends"如何使用在一般意义上的意思"extends"（类）或者"implements"（接口）。该例子中的泛型方法返回三个可比较对象的最大值。

public class MaximumTest { // 比较三个值并返回最大值 
public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
 T max = x; // 假设x是初始最大值 
 if ( y.compareTo( max ) > 0 ){ 
 max = y; //y 更大 
 } 
 if ( z.compareTo( max ) > 0 ){ 
 max = z; // 现在 z 更大 
 } 
 return max; // 返回最大对象 
 } 
 public static void main( String args[] ) { 
 System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n", 3, 4, 5, maximum( 3, 4, 5 ) ); 
 System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n", 6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) ); 
 System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear", "apple", "orange", maximum( "pear", "apple", "orange" ) ); 
 } 
 }

编译以上代码，运行结果如下所示：

3, 4 和 5 中最大的数为 5
6.6, 8.8 和 7.7 中最大的数为 8.8
pear, apple 和 orange 中最大的数为 pear

泛型类
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
实例
如下实例演示了我们如何定义一个泛型类:

public class Box<T> { 
private T t; 
public void add(T t) { 
this.t = t; 
} 
public T get() { 
return t; 
} 
public static void main(String[] args) { 
Box<Integer> integerBox = new Box<Integer>(); 
Box<String> stringBox = new Box<String>(); 
integerBox.add(new Integer(10)); 
stringBox.add(new String("ABCD")); 
System.out.printf("整型值为 :%d\n\n", integerBox.get()); 
System.out.printf("字符串为 :%s\n", stringBox.get()); 
} 
}

编译以上代码，运行结果如下所示：

整型值为 :10
字符串为 :ABCD

类型通配符
1、类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List,List 等所有List<具体类型实参>的父类。
实例

import java.util.*; 
public class GenericTest { 
public static void main(String[] args) { 
List<String> name = new ArrayList<String>(); 
List<Integer> age = new ArrayList<Integer>(); 
List<Number> number = new ArrayList<Number>(); 
name.add("icon"); 
age.add(18); 
number.add(314); 
getData(name); 
getData(age); 
getData(number); 
} 
public static void getData(List<?> data) { 
System.out.println("data :" + data.get(0)); 
} 
}

输出结果为：

data :icon
data :18
data :314

解析：因为getData()方法的参数是List类型的，所以name，age，number都可以作为这个方法的实参，这就是通配符的作用
2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。

import java.util.*; 
public class GenericTest { 
public static void main(String[] args) { 
List<String> name = new ArrayList<String>(); 
List<Integer> age = new ArrayList<Integer>(); 
List<Number> number = new ArrayList<Number>(); 
name.add("icon"); 
age.add(18); 
number.add(314); 
getUperNumber(name);//1 
getUperNumber(age);//2 
getUperNumber(number);//3 
} 
public static void getData(List<?> data) { 
System.out.println("data :" + data.get(0)); 
} 
public static void getUperNumber(List<? extends Number> data) { 
System.out.println("data :" + data.get(0)); 
}
}

输出结果：

data :18
data :314

解析：在(1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错
3、类型通配符下限通过形如 List<? super Number>来定义，表示类型只能接受Number及其三层父类类型，如 Object 类型的实例。

三：JavaIO流
1：什么是IO流：
IO流从字面上看很难，但其实只是一种数据的流动，按照流动的方向，以内存为基准，分为输入（input）和输出（output），即流向内存是输入流，流出内存的输出流。
2：IO流的分类：
根据数据的流向分为：输入流和输出流。
输入流：把数据从其他设备上读取到内存中的流。
输出流：把数据从内存中写出到其他设备上的流。
根据数据的类型分为：字节流和字符流。
字节流：以字节为单位，读写数据的流。
字符流：以字符为单位，读写数据的流。
3：字节流：
什么是字节？什么是字节流？
一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
字节输出流【OutputStream】：
java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, intlen) ：从指定的字节数组写入 len字节，从偏移量 oﬀ开始输出到此输出流。
public abstract voidwrite(int b) ：将指定的字节输出流。
提醒：close方法，当完成流的操作时，必须调用此方法，释放系统资源。
FileOutputStream类：
OutputStream 有很多子类，我们从简单的一个子类开始。
java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。
构造方法：
public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name) ：创建文件输出流以指定的名称写入文件。
字节输出流的使用步骤：
1.创建一个publicFileOutputStream对象，构造方法中传递写入数据的目的地
2.调用publicFileOutputStream对象中的方法write，把数据写入文件中
3.释放资源
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {
	public static void main(String[] args) {
		// 使用File对象创建流对象
		File file = new File("a.txt");
		FileOutputStream fos = new FileOutputStream(file);
		
		// 使用文件名称创建流对象
		FileOutputStream fos = new FileOutputStream("b.txt");
	}
}

1.写出字节数据：

public class FOSWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileOutputStream fos = new FileOutputStream("fos.txt");
		// 写出数据
		fos.write(97); // 写出第1个字节
		fos.write(98); // 写出第2个字节
		fos.write(99); // 写出第3个字节
		// 关闭资源
		fos.close();
	}
}

输出结果：

abc

提醒：
虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
流操作完毕后，必须释放系统资源，调用close方法，千万记得。
2.写出字节数组： write(byte[] b) ，每次可以写出数组中的数据，代码使用演示：

public class FOSWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileOutputStream fos = new FileOutputStream("fos.txt");
		// 字符串转换为字节数组
		byte[] b = "程序员".getBytes();
		// 写出字节数组数据
		fos.write(b);
		// 关闭资源
		fos.close();
	}
}

输出结果：

程序员

提醒：
如果写的第一个字节是正数：那么显示的到时候会查询ASCII表
如果写的第一个字节是负数：那第一个字节会和第二个字节组成一个中文，查询系统默认码表(GBK)
.写出指定长度字节数组： write(byte[] b, int off, int len) ,每次写出从oﬀ 索引开始，len个字节，代码使用演示：

public class FOSWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileOutputStream fos = new FileOutputStream("fos.txt");
		// 字符串转换为字节数组
		byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
		fos.write(b,2,2);
		// 关闭资源
		fos.close();
	}
}

输出结果：

cd

数据追加续写：
经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？
public FileOutputStream(File file, boolean append) ：创建文件输出流以写入由指定的File对象表示的文件。
public FileOutputStream(String name, boolean append) ：创建文件输出流以指定的名称写入文件。
这两个构造方法，参数中都需要传入一个boolean类型的值， true 表示追加数据，不会覆盖原文件； false 表示清空原有数据，创建一个新文件覆盖源文件。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileOutputStream fos = new FileOutputStream("fos.txt"，true);
		// 字符串转换为字节数组
		byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
		fos.write(b);
		// 关闭资源
		fos.close();
	}
}

文件操作前：cd
文件操作后：cdabcde
写出换行：
Windows系统里，换行符号是 \r\n 。以指定是否追加续写了，代码使用演示：

public class FOSWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileOutputStream fos = new FileOutputStream("fos.txt");
		// 定义字节数组
		byte[] words = {97,98,99,100,101};
		// 遍历数组
		for (int i = 0; i < words.length; i++) {
			// 写出一个字节
			fos.write(words[i]);
			// 写出一个换行, 换行符号转成数组写出
			fos.write("\r\n".getBytes());
		}
		// 关闭资源
		fos.close();
	}
}

输出结果：

a b c d e

提醒：
回车符 \r 和换行符 \n ：
回车符：回到一行的开头（return）。
换行符：下一行（newline）
系统中的换行：
Windows系统里，每行结尾是回车+换行，即 \r\n ；
Unix系统里，每行结尾只有换行，即 \n ；
Mac系统里，每行结尾是回车，即 \r 。从 Mac OS X开始与Linux统一。
字节输入流【InputStream]
java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read() ：从输入流读取数据的下一个字节。
public int read(byte[] b) ：从输入流中读取一些字节数，并将它们存储到字节数组 b中。
FileInputStream类
java.io.FileInputStream 类是文件输入流，从文件中读取字节
作用：把硬盘中的数据读取到内存中使用。
构造方法：
FileInputStream(File file) ：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的 File对象 ﬁle命名
FileInputStream(String name) ：
通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出 FileNotFoundException 。
字节输入流使用步骤：
1.创建FileInputStream对象，构造方法绑定要读取的数据源
2.使用FileInputStream对象中的方法read，读取文件
3.释放资源

public class FileInputStreamConstructor throws IOException{
	public static void main(String[] args) {
		// 使用File对象创建流对象
		File file = new File("a.txt");
		FileInputStream fos = new FileInputStream(file);
		
		// 使用文件名称创建流对象
		FileInputStream fos = new FileInputStream("b.txt");
	}
}

读取字节数据：
读取字节： read 方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1。
代码使用演示：

public class FISRead {
	public static void main(String[] args) throws IOException{
		// 使用文件名称创建流对象
		FileInputStream fis = new FileInputStream("read.txt");
		// 读取数据，返回一个字节
		int read = fis.read();
		System.out.println((char) read);
		read = fis.read();
		System.out.println((char) read);
		read = fis.read();
		System.out.println((char) read);
		read = fis.read();
		System.out.println((char) read);
		read = fis.read();
		System.out.println((char) read);
		// 读取到末尾,返回‐1
		read = fis.read();
		System.out.println( read);
		// 关闭资源
		fis.close();
	}
}

输出结果：

a
b
c
d
e
‐1

循环改进读取方式，代码使用演示：

public class FISRead {
	public static void main(String[] args) throws IOException{
		
		// 使用文件名称创建流对象
		FileInputStream fis = new FileInputStream("read.txt");
		// 定义变量，保存数据
		int b ；
		// 循环读取
		while ((b = fis.read())!=‐1) {
			System.out.println((char)b);
		}
		// 关闭资源
		fis.close();
	}
}

输出结果：

a
b
c
d
e

提醒：
虽然读取了一个字节，但是会自动提升为int类型。
流操作完毕后，必须释放系统资源，调用close方法。
使用字节数组读取： read(byte[] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1 。
代码使用演示：

public class FISRead {
	public static void main(String[] args) throws IOException{
		// 使用文件名称创建流对象.
		FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
		// 定义变量，作为有效个数
		int len ；
		// 定义字节数组，作为装字节数据的容器
		byte[] b = new byte[2];
		// 循环读取
		while (( len= fis.read(b))!=‐1) {
		// 每次读取后,把数组变成字符串打印
			System.out.println(new String(b));
		}
		// 关闭资源
		fis.close();
	}
}

输出结果：

ab
cd
ed

错误数据 d ，是由于后一次读取时，只读取一个字节 e ，数组中，上次读取的数据没有被完全替换，所以要通过 len ，获取有效的字节，
代码使用演示：

public class FISRead {
	public static void main(String[] args) throws IOException{
		// 使用文件名称创建流对象.
		FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
		// 定义变量，作为有效个数
		int len ；
		// 定义字节数组，作为装字节数据的容器
		byte[] b = new byte[2];
		// 循环读取
		while (( len= fis.read(b))!=‐1) {
			// 每次读取后,把数组的有效字节部分，变成字符串打印
			System.out.println(new String(b，0，len));// len 每次读取的有效字节个数
		}
		// 关闭资源
		fis.close();
	}
}

输出结果：

ab
cd
e

int read(byte[] b)：
byte 的作用：
起到缓冲作用，存储每次读到的字节
数组的长度一般定义为1024(1kb)或1024的整数倍
返回值 int 的作用：
每次读取的有效字符个数

字节流练习：图片复制

 package ZLTWORK;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TEST {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("E:/钟良堂/TEST.png");
		FileOutputStream fos = new FileOutputStream("E:/Program Files (x86)/test.png");
		byte[] bys = new byte[1024];
		int len;
		while((len=fis.read(bys))!=-1) {
			fos.write(bys,0,len);
		}
		fis.close();
		fos.close();
	}
}

4:字符流
当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

字符输入流【Reader】：
java.io.Reader 抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
public void close() ：关闭此流并释放与此流相关联的任何系统资源。
public int read() ：从输入流读取一个字符。
public int read(char[] cbuf) ：从输入流中读取一些字符，并将它们存储到字符数组cbuf中。
FileReader类
java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法：
FileReader(File file) ：创建一个新的 FileReader ，给定要读取的File对象。
FileReader(String fileName) ：创建一个新的 FileReader ，给定要读取的文件的名称。
当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

public class FileReaderConstructor throws IOException{
	public static void main(String[] args) {
		// 使用File对象创建流对象
		File file = new File("a.txt");
		FileReader fr = new FileReader(file);
		
		// 使用文件名称创建流对象
		FileReader fr = new FileReader("b.txt");
	}
}

读取字符数据：
读取字符： read 方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回 -1 ，循环读取，代码使用演示：

public class FRRead {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileReader fr = new FileReader("read.txt");
		// 定义变量，保存数据
		int b ；
		// 循环读取
		while ((b = fr.read())!=‐1) {
			System.out.println((char)b);
		}
		// 关闭资源
		fr.close();
	}
}

输出结果：

程
序
员

使用字符数组读取： read(char[] cbuf) ，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1 ，代码使用演示：

public class FRRead {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileReader fr = new FileReader("read.txt");
		// 定义变量，保存有效字符个数
		int len ；
		// 定义字符数组，作为装字符数据的容器
		char[] cbuf = new char[2];
		// 循环读取
		while ((len = fr.read(cbuf))!=‐1) {
			System.out.println(new String(cbuf));
		}
		// 关闭资源
		fr.close();
	}
}

输出结果：

程序
员序

获取有效的字符改进，代码使用演示：

public class FISRead {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileReader fr = new FileReader("read.txt");
		// 定义变量，保存有效字符个数
		int len ；
		// 定义字符数组，作为装字符数据的容器
		char[] cbuf = new char[2];
		// 循环读取
		while ((len = fr.read(cbuf))!=‐1) {
			System.out.println(new String(cbuf,0,len));
		}
		// 关闭资源
		fr.close();
	}
}

输出结果：

程序
员

字符输出流【Writer】：
java.io.Writer 抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法
void write(int c) 写入单个字符。
void write(char[] cbuf) 写入字符数组。
abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分,oﬀ数组的开始索引,len写的字符个数。
void write(String str) 写入字符串。
void write(String str, int off,int len) 写入字符串的某一部分,oﬀ字符串的开始索引,len写的字符个数。
void flush() 刷新该流的缓冲。
void close() 关闭此流，但要先刷新它。
FileWriter类
java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法：
FileWriter(File file) ：创建一个新的 FileWriter，给定要读取的File对象
FileWriter(String fileName) ：创建一个新的 FileWriter，给定要读取的文件的名称。
当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。
字符输出流的使用步骤：
1：创建FileWriter对象，构造方法中要绑定写入数据的目的地
2：使用FileWriter中的方法write，把数据存到缓冲区中(字符转换为字节的过程)
3：使用 FileWriter中的方法flush，把内存中的数据刷新到文件中
4：释放资源(会先把内存缓存区中的数据刷新到文件中)
构造举例，代码如下：

public class FileWriterConstructor {
	public static void main(String[] args) throws IOException {
		// 使用File对象创建流对象
		File file = new File("a.txt");
		FileWriter fw = new FileWriter(file);
		
		// 使用文件名称创建流对象
		FileWriter fw = new FileWriter("b.txt");
	}
}

基本写出数据：
写出字符： write(int b) 方法，每次可以写出一个字符数据，代码使用演示：

public class FWWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileWriter fw = new FileWriter("fw.txt");
		// 写出数据
		fw.write(97); // 写出第1个字符
		fw.write('b'); // 写出第2个字符
		fw.write('C'); // 写出第3个字符
		fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
		/*
		【注意】关闭资源时,与FileOutputStream不同。
		如果不关闭,数据只是保存到缓冲区，并未保存到文件。
		*/
		// fw.close();
	}
}

输出结果：

abC田

写出其他数据：
写出字符数组： write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：

public class FWWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileWriter fw = new FileWriter("fw.txt");
		
		// 字符串转换为字节数组
		char[] chars = "我是程序员".toCharArray();
		
		// 写出字符数组
		fw.write(chars); // 我是程序员
		
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
		fw.write(b,2,2); // 程序
		
		// 关闭资源
		fos.close();
	}
}

写出字符串： write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码使用演示：

public class FWWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象
		FileWriter fw = new FileWriter("fw.txt");
		// 字符串
		String msg = "我是程序员";
		
		// 写出字符数组
		fw.write(msg); //我是程序员
		
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
		fw.write(msg,2,2); // 程序
		
		// 关闭资源
		fos.close();
	}
}

续写和换行：操作类似于FileOutputStream。

public class FWWrite {
	public static void main(String[] args) throws IOException {
		// 使用文件名称创建流对象，可以续写数据
		FileWriter fw = new FileWriter("fw.txt"，true);
		// 写出字符串
		fw.write("我是");
		// 写出换行
		fw.write("\r\n");
		// 写出字符串
		fw.write("程序员");
		// 关闭资源
		fw.close();
	}
}

输出结果:

我是
程序员

钟良堂的Java学习笔记

发布了7 篇原创文章 · 获赞 6 · 访问量 2154

私信关注

Java的第六周学习报告

猜你喜欢