Java-----集合，IO流
文章目录
1.集合（java.util.*）
(1).概述
Ⅰ.集合实际上是一个容器(载体)，可存储多个对象；(数组是最简单的集合)；
Ⅱ.集合中不能存储基本数据类型和java对象，存储的是java对象的内存地址；
Ⅲ.每个不同的集合底层对应不同的数据结构(数组，二叉树，链表，哈希表…)；
(2).集合的分类和结构图
<1>.Collection接口：
超级父接口：java.util.Collection
a.Collection继承结构图：
概述：
①.Collection可存放Object的所有子类对象；
②.由于Collection是接口，无法实例化，new对象应用多态机制创建子类的实现类对象。
b.常用方法
A.向集合中添加一个元素
//向集合中添加一个元素
public boolean add(Object e);
B.获取集合中的元素个数
//获取集合中元素的个数
public int size();
C.清空集合中的元素
//清空集合中的元素
public void clear();
D.判断集合中是否包含某元素
Tips:
该方法中底层调用了equals方法，放在集合中的元素应重写equals方法。
//判断集合中是否包含某元素
public boolean contains(Object e);
E.移除集合中的某元素
//移除集合中的某元素
public boolean remove(Object e);
F.判断集合是否为空
//判断集合是否为空
public boolean isEmpty();
G.将集合转换为数组
//将集合转换为数组
public Object[] toArray();
<2>.Iterator迭代器接口：
a.获取迭代器对象：
Collection c = new ArrayList();
Iterator it = c.iterator();
//iterator()方法是Collection接口的父接口Iterable中的方法
b.迭代器中的方法：
A.判断集合是否可以迭代
//判断集合是否可以迭代
public boolean hasNext();
B.返回迭代的下一个元素
//返回迭代的下一个元素
public Object next();
C.删除当前指向的元素
//删除当前指向的元素
public void remove();
c.使用迭代器需要注意的：
A.对迭代器来说，当集合结构发生改变时，迭代器必须重新获取；
B.采用迭代器的remove()方法删除可自动更新迭代器。
<3>.List接口：存储元素有下标，有序可重复
a.常用方法：
A.在指定位置i处添加元素
//在指定位置i处添加元素
public void add(int index,Object element);
B.根据下标获取元素
//根据下标获取元素
public Object get(int index);
C.获取指定对象第一次出现的索引
//获取指定对象第一次出现的索引
public int indexOf(Object element);
D.获取指定对象最后一次出现的索引
//获取指定对象最后一次出现的索引
public int lastIndexOf(Object element);
E.删除指定位置的元素
//删除指定位置的元素
public void remove(int index);
F.修改指定位置的元素值
//修改指定位置的元素值
public void set(int index,Object Element);
b.ArrayList类详解：
A.初始容量
ArrayList集合底层由数组实现，初始容量为10，也可通过构造方法new ArrayList(int capacity);指定初始化容量。
B.扩容
当存储空间不够时，该集合自动扩容1.5倍。
本质上是位运算符二进制右移一位1010>>1=0101—>5,左移同理。
C.优缺点
优点：检索效率较高，末尾加元素效率较高；
缺点：增删效率较低。
c.LinkedList类详解：
A.链表数据结构
结点Node是链表中的基本单元。
单向链表：
每一个Node中有两个属性：存储的数据和下一个结点的内存地址。
双向链表：
每一个Node中有三个属性：存储的数据，下一个和上一个结点内存地址。
B.优缺点
优点：随机增删元素的效率较高；
缺点：查询效率较低，查找元素需从头开始向下遍历。
d.Vector类详解：
A.初始容量
Vector集合底层由数组实现，初始化容量是10，也可通过构造方法new Vector(int initialCapacity);设置初始化容量。
B.扩容
Vector存储空间用满时，自动扩容2倍。
C.方法特征
Vector集合中的方法都是线程安全的(带有synchronized关键字)。
e.泛型机制：
A.作用
规定集合中存储的元素类型固定，集合中数据类型更统一。
B.语法机制
//规定List方法中仅能存储String类型的数据 例子
//方法一：
List<String> l = new ArrayList<>();
//方法二：
List l = new ArrayList<String>();
//方法三：
List<String> l = new ArrayList();
C.优缺点
优点：
①集合中存储的元素类型统一了；
②从集合中取出的数据是泛型指定类型，无需更多的向下转型。
缺点：
导致集合中的元素类型缺乏多样性。
f.总结集合的迭代与遍历
//创建集合以及添加元素
List<String> l1 = new ArrayList <>();
l1.add(0,"香辣牛肉月饼");
l1.add(1,"莲蓉月饼");
l1.add(2,"五仁月饼");
A.迭代器遍历
//迭代器遍历集合
Iterator <String> it = l1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
B.采用List集合的下标
//下标遍历
for (int i = 0;i < l1.size();i++){
System.out.println(l1.get(i));
}
C.采用增强for进行遍历
//foreach遍历
for (String s:l1){
System.out.println(s);
}
<4>Map接口：元素无下标，无序不可重复
超级父接口：java.util.Map
a.数据存储特点
Map集合以key和value的方式存储数据，即【键值对】方式。
key和value都是引用数据类型，都存对象的内存地址。
Map继承结构图
c.常用方法
A.向Map集合中添加键值对Map<K,V> map = new TreeMap<>();
//向Map集合中添加键值对
public V put(K key,V value);
B.通过key值来获取value值
//通过key值来获取value值
public V get(K key);
C.清空Map集合
//清空Map集合
public void clear();
D.判断Map集合中是否包括某个key或者value
//判断Map集合中是否包括某个key或者value
public boolean containsValue(Object value);
public boolean containsKey(Object key);
E.判断Map集合是否为空
//判断Map集合是否为空
public boolean isEmpty();
F.获取Map集合中所有的Key存储至一个Set集合中
//获取Map集合中所有的Key存储至一个Set集合中
public Set<K> keySet();
G.通过key值删除键值对
//通过key值删除键值对
public V remove(Object key);
H.获取Map集合中键值对的个数
//获取Map集合中键值对的个数
public int size();
I.获取Map中所有的Value存储到一个Collection中
//获取Map中所有的Value存储到一个Collection中
public Collection<V> values();
J.将Map集合转换成Set集合
//将Map集合转换成Set集合
public Set<Map.Entry<K,V>> entrySet();
d.Map集合的遍历方法
//创建集合以及添加元素
TreeMap map = new TreeMap<Integer,String>();
map.put(1,"汉堡包");
map.put(2,"炸薯条");
map.put(3,"香辣鸡翅");
A.获取所有的Key，通过get方法和迭代器遍历
//获取所有的key，再通过get方法得到value值
Set<Integer> set = map.keySet();
Iterator <Integer> it = set.iterator();
while(it.hasNext()){
Integer key = it.next();
System.out.println(key+"="+map.get(key));
}
B.通过entrySet方法将键值对转换为Set集合，再迭代器遍历
//通过entrySet将map转换为set集合，再迭代器遍历
Set<Integer> set = map.entrySet();
Iterator <Integer> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
e.HashMap类详解：
A.哈希表数据结构概述
定义：
哈希表是一个数组和单向链表的结合体，综合了以上二者的优点。
哈希下标：
①.同一个单向链表上的结点哈希值相同，因为其数组下标相同；
②.HashMap集合的key使用时应重写hashCode()和equals()方法。
put(K key,V value)方法实现原理：
①.封装key，value到Node对象中；
②.调用key的hashCode()方法得出Hash值。
③.通过哈希算法将Hash值转换为数组下标。
若下标位置无元素，则将Node添加上去；
若有元素(链表)，将key与链表上每个结点key进行equals()比对:
若返回均为false,则该结点被加至末尾；
若返回存在true,则该结点的value值被覆盖。
get(K key)方法实现原理：
①.调用key的hashCode()得出哈希值；
②.通过哈希算法将哈希值转换为数组下标；
③.通过下标锁定位置。
若下标元素无元素，返回一个null；
若有元素(链表)，拿参数key与单向链表上每个结点进行equals比对：
若返回均为false，则该方法返回null;
若返回存在true,则返回该结点的value值。
B.HashMap集合详解：
初始容量
HashMap集合的初始化容量为16。
也可通过new HashCode(int capacity)进行初始化容量操作，但该集合容量必须是2的整数次幂。
（即当容量达到【16x0.75=12时】，集合自动扩容值32。）
默认加载因子
定义：当集合存储元素容量达到默认加载因子时，集合自动扩容。
HashMap：该集合的默认加载因子为0.75。
存储元素信息
HashMap集合中的【key】值可以为null，【value】值也可以为null。
f.Hashtable类详解：
A.Hashtable类概述：
初始容量
Hashtable集合的初始容量为11；
默认加载因子及扩容量
Hashtable的默认加载因子为0.75，扩容量为【原容量*2+1】。
存储元素信息
①.Hashtable集合中的【key】值和【value】值均不可为null。
②.该集合是线程安全的。
B.properties类详解：
存储数据类型：
key和value类型都应是String类型。
常用方法：
向集合中存入数据
//向集合中存入数据
public synchronized Object setProperty(String key,String value);
得到集合中的元素
//得到集合中的元素
public synchronized String getProperty(String key);
g.TreeSet和TreeMap类详解
A.概述：
①.TreeSet集合底层是个TreeMap集合，TreeMap底层是二叉树数据结构。
②.TreeSet集合中的元素相等于放入了TreeMap集合中的key部分了。
③.Map集合无序不可重复，TreeMap集合可自动排序。
B.排序规则：
①.TreeSet对自定义的类来说，TreeSet不可排序；
②.若给自定义的类添加【排序规则】，即实现Comparable接口和内部的comparedTo()方法，在其中写入【排序规则】即可。
③.TreeMap和TreeSet的排序规则采取二叉树中的【中序遍历】。
C.实现排序的两种方法：
①.实现java.util.Comparable接口，通常用于排序规则不会改变；
②.构建集合对象时传入一个比较器对象comparator接口，通常用于排序规则频繁改变。
方法一测试：
准备工作：准备一个学生类Student,让其实现Comparable接口，并重写comparedTo()方法，排序规则如下书写：
//学生作key时，先让其比较学生的学号，如果学号相等，再比较学生姓名
public int compareTo(Student o) {
if (this.no < o.no){
return -1;
}else if (this.no > o.no){
return 1;
}else{
return this.name.compareTo(o.name);
}
}
书写测试类：
public static void main(String[] args) {
Map<Student,Integer> map = new TreeMap <>();
map.put(new Student("shawn",5),5);
map.put(new Student("Alice",6),6);
map.put(new Student("James",7),7);
map.put(new Student("Jane",8),8);
map.put(new Student("Alice",7),7);
System.out.println(map);
}
测试结果与总结：
{Student{name=‘shawn’, no=5}=5,
Student{name=‘Alice’, no=6}=6,
Student{name=‘Alice’, no=7}=7,
Student{name=‘James’, no=7}=7,
Student{name=‘Jane’, no=8}=8}
总结：由上述结果可知，对于学号no较小的被排在上面，而中间学号no相等时，会比较姓名，从而达成了自定义类的排序功能。
方法二测试：
准备工作：准备一个学生类Student,让其实现Comparable接口，并重写comparedTo()方法，排序规则与上同
测试类书写：
public static void main(String[] args) {
Map<Student,Integer> map = new TreeMap <>(new Comparator <Student>() {
@Override
public int compare(Student o1, Student o2) {
if (o1.getNo()<o2.getNo()){
return -1;
}else if (o1.getNo()>o2.getNo()){
return 1;
}else{
return o1.getName().compareTo(o2.getName());
}
}
});
map.put(new Student("shawn",5),5);
map.put(new Student("Alice",6),6);
map.put(new Student("James",7),7);
map.put(new Student("Jane",8),8);
map.put(new Student("Alice",7),7);
System.out.println(map);
}
输出结果：
(与上同！)
h.集合的工具类Collections：
常用方法：
A.将集合从非线程安全变为线程安全
//将集合从非线程安全变为线程安全
public static List<T> synchronizedList(list l);
B.排序集合中的元素
//排序集合中的元素
public static List<T> sort(List l);
2.IO流(Input/Output Stream)
(1).概述
作用：
通过IO流可完成【硬盘文件的读和写】。
读和写的区分：
·读进入内存为输入【读】；
·写出来内存为输出【写】。
所在包：
java中所有的流均在java.io.*下。
分类：
Ⅰ.
java.io.InputStream:字节输入流；
Ⅱ.java.io.OutputStream:字节输出流；
Ⅲ.java.io.Reader::字符输入流；
Ⅳ.java.io.Writer:字符输出流。
实现的接口：
※ ①所有的【输出流】都实现了java.io.Flushable接口，存在flush()方法，作用是【刷新流】。
※ ②【所有流】都实现了java.io.Closeable接口，存在close()方法，作用是【关闭流】。
(2).文件类流详解：
分类：
Ⅰ.
java.io.FileInputStream
Ⅱ.java.io.FileOutputStream
Ⅲ.java.io.FileReader
Ⅳ.java.io.FileWriter
<1>.FileInputStream类详解：
定义:
【文件字节输出流】，可读取任意格式的文件。
构造方法：
源码：
/*
*@param name:文件名
*/
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}
/*
*@param file:读取的文件对象
*/
public FileInputStream(File file);
read()方法和read(byte[] bytes)方法：
/*
*该方法一次可读取目标文件中的一个字节，效率较低。
*@return 若有读取值返回读到的字节本身，无读取值则取-1
*/
public int read();
为了减少硬盘和内存之间的交互，引入read(byte[] bytes)方法
/*
*该方法一次课读取目标文件的【bytes.length】个字节，效率较高。
*@return 返回读取到的字节数目，无读取值则返回-1
*/
public int read(byte[] b);
※ 使用read(byte[] b)方法时，输出字节本身可以使用String的构造方法
//将byte数组转换为字符串进行输出即可
new String(byte[] bytes,int offset,int readCount);
从而得出读文件的最优解：
Tips:【io测试文本】中存储为【“Hello IOStream!”】
//创建流对象：(让fis对象作用域扩展，能在finally语块中读取到该对象)
FileInputStream fis = null;
try {
//指定要读取的文件
fis = new FileInputStream("io测试文本.txt");
int readCount = 0;
byte[] bytes = new byte[4];
while((readCount = fis.read(bytes)) != -1){
System.out.print(new String(bytes,0,readCount));
}
} catch (IOException e) {
e.printStackTrace();
} finally{
//最后必须关闭流：（加入判断为了防止【空指针异常】）
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
输出结果为：
【Hello IOStream!】
其他方法：available()
//使用该方法一次读完数据
/*
*@return 返回可读取的字节数量
*/
public int available();
skip()
/*
*@param l:bytes数组需要跳过总字节数
*@return 实际跳过的字节数
*/
public long skip(long l);
<2>.FileOutputStream类详解：
定义：
【文件字节输出流】。
构造方法：
/*
*@param name:需要写入的文件名
*@param append:写入的数据是否在原有基础上拼接
*/
new FileOutputStream(String name,boolean append);
write(byte[] bytes)方法：
/*
*向原文件中写入数据
*@param bytes 写入的数据的byte数组
*/
public void wirte(byte[] bytes);
※：添加字符串时可调用String中的getByte(String s)方法将字符串转换为byte数组。
写入数据样例：
//定义输出流
FileOutputStream fos = null;
try {
fos = new FileOutputStream("io测试文本.txt",true);
String str = "我是中国人，我骄傲";
//将字符串转换为byte数组
byte[] bytes = str.getBytes();
fos.write(bytes);
//输出流需刷新流：
fos.flush();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
//结尾需要关闭流
if (fos != null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
<3>.FileReader类简介：
定义：
【文件字符输入流】，仅能读取【普通文本】。
<4>.FileWriter类简介：
定义：
【文件字符输出流】，仅能读取【普通文本】。
<5>.文件拷贝功能实现：
源代码：
package IO流;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy {
public static void main(String[] args) {
//输入流的定义
FileInputStream fis = null;
//输出流的定义
FileOutputStream fos = null;
try {
fis = new FileInputStream("E:\\highlights\\跑跑机器人.mp4");
fos = new FileOutputStream("E:\\泡泡机器人.mp4");
//初始化计数变量readCount和数组byte[]
int readCount = 0;
byte[] bytes = new byte[1024*1024];//一次性拷贝1M文件
//一边写一边读
while((readCount = fis.read(bytes))!= -1){
fos.write(bytes,0,bytes.length);
}
//刷新输出流
fos.flush();
} catch (IOException e) {
e.printStackTrace();
}finally{
//关闭输入和输出流
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
结果：
【E:/highlights/跑跑机器人.mp4】视频文件成功被拷贝到
【E:/泡泡机器人.mp4】，在此过程中同时进行了重命名操作。
(3).缓冲区类流详解：
缓冲区类流有：
Ⅰ.
java.io.BufferedReader
Ⅱ.java.io.BufferedWriter
Ⅲ.java.io.BufferedInputStream
Ⅳ.java.io.BufferedOutputStream
BufferedReader类(BufferedWriter类同理)：
定义：自带缓冲区的字符输入流；
构造方法：
new BufferedReader(Reader reader);
方法：
readLine()方法：
//一次读取文件的一行内容。
public String readLine();
read()方法：
//一次读取一个字符，返回值为ASCII值。
public int read();
read(char[] chars)方法：
//一次读取chars.length个长度，存入chars数组中,返回值为读到的字符数量
public int read(char[] chars);
转换流InputStreamReader:将字节流转换为字符流：
InputStreamReader I = new InputStreamReader(new FileInputStream("io测试文本"));
(4).标准输出流详解：
<1>.PrintStream
所在包：java.io.PrintStream
①.标准的【字节输出流】，默认输出到控制台。
②.该流无需手动关闭。
③.手动改变输出方向：(System类下)
public static void setOut(PrintStream ps);
<2>.PrintWriter
所在包：java.io.PrintWriter
①.标准的【字符输出流】，与上同；
(5).对象类流详解：
概述：
【serialize,deserialize】
①.【(反)序列化】：（反）将内存中的java对象放入硬盘文件中。
②.参与序列化与反序列化的对象，必须实现Serializable接口。
③.在属性前加【transient】关键字，表现该变量不参与(反)序列化。
④.IDEA可自动生成序列化版本号。
⑤.Map集合中的Properties类中的load()方法可将硬盘文件加载到内存中。
public synchronized void load(InputStream inStream);
public synchronized void load(Reader reader);
(6).java.io.File类详解：
概述：
File类不能完成对象的读和写，File是一个路径名的抽象表现形式。
构造方法：
//文件的路径名
new File(String pathname);
方法：
exists()方法：
//判断是否存在目标文件
public boolean exists()
createNewFile()方法：
//在当前目录下创建一个文件
public void createNewFile();
mkdir()方法：
//在当前目录下创建出一个子目录
public void mkdir();
getParent()：
//获取文件父路径
public String getParent();
getAbsolutePath():
//获取文件的绝对路径
public String getAbsolutePath();
listFiles();
//获取当前目录下所有子文件
public File[] listFiles();
(7).拷贝目录程序设计：
/*
*该方法用于目录的拷贝
*@param srcFile:拷贝源文件对象
*@param deskFile:拷贝目标文件对象
*@param src:拷贝源文件地址
*@param desk:拷贝目标文件地址
*/
public static void copy(File srcFile,File deskFile,String src,String desk){
//列出源目录下的所有子目录：
File[] files = srcFile.listFiles();
//遍历files数组拿到所有的子目录与子文件：
//当拿到的是文件时：
if (srcFile.isFile()){
//使用FOS与FIS即可实现拷贝：
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(src);
fos = new FileOutputStream(desk);
int readCount = 0;
byte[] bytes = new byte[1024*1024];//一次传1MB
while((readCount = fis.read(bytes))!=-1){
fos.write(bytes,0,readCount);
}
//输出流刷新：
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//输入输出流关闭：
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return;
}
//当拿到目录时：
for (File file : files){
if (file.isDirectory()){
String srcDir = file.getAbsolutePath();
String deskDir = (deskFile.getAbsolutePath().
endsWith("\\")?deskFile.getAbsolutePath()
:deskFile.getAbsolutePath()+"\\")+srcDir.substring(3);
System.out.println(srcDir);
System.out.println(deskDir);
File newFile = new File(deskDir);
if (newFile.exists()){
newFile.mkdirs();
}
}
// 递归调用
copy(file,deskFile,src,desk);
}
}
}