黑马程序员java学习第六节
作者：互联网
黑马程序员JAVA学习第六节
（视频链接黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili）
本节主要内容是Map 集合，Collections 集合工具类，File 类，递归，字符流，字节流，对应视频257-.302
Map 集合
1.Map 集合概述
interface Map<K,V> K：键的类型；V：值的类型 2.Map 集合的特点
1）键值对映射关系
2） 一个键对应一个值
3）键不能重复，值可以重复
4）元素存取无序
创建Map集合的对象：多态的方式，具体的实现类HashMap
3.map的基本使用
//创建集合对象
Map<String,String> map = new HashMap<String,String>();
//V put(K key, V value) 将指定的值与该映射中的指定键相关联
map.put("itheima001","林青霞");
map.put("itheima002","张曼玉");
map.put("itheima002","刘艳");//实现对前面存储元素的替换
System.out.println(map);
4.Map集合的基本功能
5.Map集合的获取功能
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("张无忌", "赵敏");
//V get(Object key):根据键获取值
System.out.println(map.get("张无忌"));
System.out.println(map.get("张三丰"));
//Set<K> keySet():获取所有键的集合
Set<String> keySet = map.keySet();
for(String key : keySet) {
System.out.println(key);
}
//Collection<V> values():获取所有值的集合
Collection<String> values = map.values();
for(String value : values) {
System.out.println(value);
}6.Map集合的遍历(方式1)
遍历思路
我们刚才存储的元素都是成对出现的，所以我们把 Map看成是一个夫妻对的集合
1）把所有的丈夫给集中起来 （用keySet()方法实现）
2）遍历丈夫的集合，获取到每一个丈夫（用增强for实现）
3）根据丈夫去找对应的妻子（用get（Object key）方法实现）
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("张无忌", "赵敏");
map.put("郭靖", "黄蓉");
//获取所有键的集合。用keySet()方法实现
Set<String> keySet = map.keySet();
//遍历键的集合，获取到每一个键。用增强for实现
for (String key : keySet) {
//根据键去找值。用get(Object key)方法实现
String value = map.get(key);
System.out.println(key + "," + value);
}7.Map集合的遍历(方式2)
遍历思路
我们刚才存储的元素都是成对出现的，所以我们把 Map看成是一个夫妻对的集合
1）获取所有结婚证的集合（获取所有键值对对象的集合 Set<Map.Entry<K,V>> entrySet() ：获取所有键值对对象的集合）
2）遍历结婚证的集合，得到每一个结婚证（遍历键值对对象的集合，得到每一个键值对对象，用增强 for实现，得到每一个Map.Entry）
3）根据结婚证获取丈夫和妻子（根据键值对对象获取键和值，用 getKey()得到键，用 getValue()得到值）
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
map.put("张无忌", "赵敏");
//获取所有键值对对象的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry<String, String> me : entrySet) {
//根据键值对对象获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "," + value);
}Collections 集合工具类
1.Collections概述和使用
Collections 类的作用：是针对集合操作的工具类
2.Collections 类常用方法
//创建集合对象
List<Integer> list = new ArrayList<Integer>();
//添加元素
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);
//public static <T extends Comparable<? super T>> void sort(List<T>list)：将指定的列表按升序排序
Collections.sort(list);
//public static void reverse(List<?> list)：反转指定列表中元素的顺序
Collections.reverse(list);
//public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
Collections.shuffle(list);
System.out.println(list);File 类
1.File 类介绍
1）它是文件和目录路径名的抽象表示
2）文件和目录是可以通过 File封装成对象的
3）对于 File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的
2.构造方法：
//File(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File f1 = new File("E:\\itcast\\java.txt");
System.out.println(f1);
//File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的File实例。
File f2 = new File("E:\\itcast","java.txt");
System.out.println(f2);
//File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
File f3 = new File("E:\\itcast");
File f4 = new File(f3,"java.txt");
System.out.println(f4);3.File类创建功能
//需求1：我要在E:\\itcast目录下创建一个文件java.txt
File f1 = new File("E:\\itcast\\java.txt");
System.out.println(f1.createNewFile());//如果·文件不存在就创建返回true，如果存在返回false
//需求2：我要在E:\\itcast目录下创建一个目录JavaSE
File f2 = new File("E:\\itcast\\JavaSE");
System.out.println(f2.mkdir());//与上一个方法相似
//需求3：我要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
System.out.println(f3.mkdirs());
//需求4：我要在E:\\itcast目录下创建一个文件javase.txt
File f4 = new File("E:\\itcast\\javase.txt");
// System.out.println(f4.mkdir());
System.out.println(f4.createNewFile());4.File类判断和获取功能
获取功能：
//创建一个File对象
File f = new File("myFile\\java.txt");
System.out.println(f.isDirectory());
System.out.println(f.isFile());
System.out.println(f.exists());
System.out.println(f.getAbsolutePath());
System.out.println(f.getPath());
System.out.println(f.getName());
System.out.println("--------");
File f2 = new File("E:\\itcast");
String[] strArray = f2.list();
for(String str : strArray) {
System.out.println(str);
}
System.out.println("--------");
File[] fileArray = f2.listFiles();
for(File file : fileArray) {
// System.out.println(file);
// System.out.println(file.getName());
if(file.isFile()) {
System.out.println(file.getName());
}5.File类删除功能
public boolean delete() 删除由此抽象路径名表示的文件或目录
如果要删除的目录下有内容不能直接删除，需要先删除内容
绝对路径和相对路径的区别
绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如： E:\itcast\java.txt
相对路径：必须使用取自其他路径名的信息进行解释。例如： myFile\java.tx
递归
1.递归的介绍
以编程的角度来看，递归指的是方法定义中调用方法本身的现象，把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
2.递归的注意事项
递归一定要有出口。否则内存溢出
递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出
//定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
public static void getAllFilePath(File srcFile) {
//获取给定的File目录下所有的文件或者目录的File数组
File[] fileArray = srcFile.listFiles();
//遍历该File数组，得到每一个File对象
if(fileArray != null) {
for(File file : fileArray) {
//判断该File对象是否是目录
if(file.isDirectory()) {
//是：递归调用
getAllFilePath(file);
} else {
//不是：获取绝对路径输出在控制台
System.out.println(file.getAbsolutePath());
}
}
}
}IO 流
1.IO 流介绍
IO ：输入/输出(Input/Output)
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
IO 流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载
2.IO 流的分类
按照数据的流向：输入流：读数据 输出流：写数据
按照数据类型来分：字节流：字节输入流，字节输出流
字符流：字符输入流，字符输出流
3.IO 流的使用场景
1）如果操作的是纯文本文件，优先使用字符流
2）如果操作的是图片、视频、音频等二进制文件。优先使用字节流
3）如果不确定文件类型，优先使用字节流。字节流是万能的流
3.字节流抽象基类
InputStream ：这个抽象类是表示字节输入流的所有类的超类
OutputStream ：这个抽象类是表示字节输出流的所有类的超类
子类名特点：子类名称都是以其父类名作为子类名的后缀
4.字节输出流
FileOutputStream(String name) ：创建文件输出流以指定的名称写入文件
5.使用字节输出流写数据的步骤
1）创建字节输出流对象 (调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
2）调用字节输出流对象的写数据方法
3）释放资源 (关闭此文件输出流并释放与此流相关联的任何系统资源)
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
fos.write(97);
//最后都要释放资源
fos.close();6.字节流写数据的三种方式
//方法1
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
//new File(name)
// 方法2
//FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));
//方法3
// File file = new File("myByteStream\\fos.txt");
// FileOutputStream fos2 = new FileOutputStream(file); 上一句相当于
//写字节 void write(int b)：将指定的字节写入此文件输出流
// fos.write(97);
//写数组 void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
byte[] bys = {97, 98, 99, 100, 101};
byte[] getBytes()：返回字符串对应的字节数组
byte[] bys = "abcde".getBytes();
fos.write(bys);
//写部分数组 void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从
偏移量off开始写入此文件输出流
fos.write(bys,0,bys.length);
fos.write(bys,1,3);
//释放资源
fos.close();7.字节流写数据如何实现换行
windows:\r\n
linux:\n
mac:\r
8.字节流写数据如何实现追加写入
public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为 true ，则字节将写入文件的末尾而不是开头
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);
//写数据
for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
fos.write("\r\n".getBytes());
}
//释放资源
fos.close();9.字节流写数据加异常处理
try {
可能出现异常的代码;
}catch(异常类名 变量名){
异常的处理代码;
}finally{
执行所有清除操作;
}
try {
fos = new FileOutputStream("myByteStream\\fos.txt");
fos.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}10.字节流读数据(一次读一个字节数据)
//创建字节输入流对象
//FileInputStream(String name)
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
int by;
/*
fis.read()：读数据
by=fis.read()：把读取到的数据赋值给by
by != -1：判断读取到的数据是否是-1
*/
while ((by=fis.read())!=-1) {
System.out.print((char)by);
}11.字节流复制文本文件
//根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");
//根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\\窗里窗
外.txt");
//读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}
//释放资源
fos.close();
fis.close();
}12.字节流读数据(一次读一个字节数组数据)
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
byte[] bys = new byte[1024]; //1024及其整数倍
int len;
while ((len=fis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
//释放资源
fis.close();13.字节缓冲流
lBufferOutputStream ：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写
入字节，而不必为写入的每个字节导致底层系统的调用.(提高效率)
lBufferedInputStream ：创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过
字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节.(提高效率)
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));
//写数据
bos.write("hello\r\n".getBytes());
bos.write("world\r\n".getBytes());
//释放资源
bos.close();
//字节缓冲输入流：BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new
FileInputStream("myByteStream\\bos.txt"));
//一次读取一个字节数据
// int by;
// while ((by=bis.read())!=-1) {
// System.out.print((char)by);
// }
//一次读取一个字节数组数据
byte[] bys = new byte[1024];
int len;
while ((len=bis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
bis.close();14.字节流复制视频
字节缓冲流一次读写一个字节数组速度最快。
public static void method3() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new
FileInputStream("E:\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new
FileOutputStream("myByteStream\\字节流复制图片.avi"));
int by;
while ((by=bis.read())!=-1) {
bos.write(by);
}
bos.close();
bis.close();
}字符流
1.字符流的介绍
由于字节流操作中文不是特别的方便，所以Java就提供字符流
字符流 = 字节流 + 编码表
2.中文的字节存储方式
用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接
成中文，汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数
3.编码表
字符集是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等
l计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等。采用何种规则编码就要采用对应规则解码，否则会出现乱码。
4.字符串中的编码解码方法
//定义一个字符串
String s = "中国";
//byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
//byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
System.out.println(Arrays.toString(bys));
//String ss = new String(bys);
//String ss = new String(bys,"UTF-8");
String ss = new String(bys,"GBK");
System.out.println(ss);5.字符流中的编码解码问题
字符流中和编码解码问题相关的两个类
InputStreamReader ：是从字节流到字符流的桥梁，它读取字节，并使用指定的编码将其解码为字符，它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
OutputStreamWriter ：是从字符流到字节流的桥梁，是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节，它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
构造方法：
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"),"GBK");
osw.write("中国");
osw.close();
InputStreamReader isr = new InputStreamReader(new
FileInputStream("myCharStream\\osw.txt"),"GBK");
//一次读取一个字符数据
int ch;
while ((ch=isr.read())!=-1) {
System.out.print((char)ch);
}
isr.close();6.字符流写数据的5种方式
OutputStreamWriter osw = new OutputStreamWriter(new
FileOutputStream("myCharStream\\osw.txt"));
//void write(int c)：写一个字符
// osw.write(97);
//void writ(char[] cbuf)：写入一个字符数组
char[] chs = {'a', 'b', 'c', 'd', 'e'};
// osw.write(chs);
//void write(char[] cbuf, int off, int len)：写入字符数组的一部分
// osw.write(chs, 0, chs.length);
//void write(String str)：写一个字符串
// osw.write("abcde");
//void write(String str, int off, int len)：写一个字符串的一部分
// osw.write("abcde", 0, "abcde".length());
//释放资源
osw.close();7. 字符流读数据的2种方式
int read() 一次读一个字符数据
int read(char[] cbuf) 一次读一个字符数组数据
InputStreamReader isr = new InputStreamReader(new
FileInputStream("myCharStream\\ConversionStreamDemo.java"));
//int read()：一次读一个字符数据
// int ch;
// while ((ch=isr.read())!=-1) {
// System.out.print((char)ch);
// }
//int read(char[] cbuf)：一次读一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len = isr.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
//释放资源
isr.close();8.字符流复制java文件
//根据数据源创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new
FileInputStream("myCharStream\\ConversionStreamDemo.java"));
//根据目的地创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new
FileOutputStream("myCharStream\\Copy.java"));
//读写数据，复制文件
//一次读写一个字符数据
// int ch;
// while ((ch=isr.read())!=-1) {
// osw.write(ch);
// }
//一次读写一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len=isr.read(chs))!=-1) {
osw.write(chs,0,len);
}
//释放资源
osw.close();
isr.close();9.字符流复制Java文件改进版（使用便捷流对象）
便捷流对象不能涉及编码和解码问题
//根据数据源创建字符输入流对象
FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
//根据目的地创建字符输出流对象
FileWriter fw = new FileWriter("myCharStream\\Copy.java");
//读写数据，复制文件
// int ch;
// while ((ch=fr.read())!=-1) {
// fw.write(ch);
// }
char[] chs = new char[1024];
int len;
while ((len=fr.read(chs))!=-1) {
fw.write(chs,0,len);
}
//释放资源
fw.close();
fr.close();10.字符缓冲流
BufferedWriter ：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可
以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
BufferedReader ：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓
冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途
//BufferedWriter(Writer out)
BufferedWriter bw = new BufferedWriter(new
FileWriter("myCharStream\\bw.txt"));
bw.write("hello\r\n");
bw.write("world\r\n");
bw.close();
//BufferedReader(Reader in)
BufferedReader br = new BufferedReader(new
FileReader("myCharStream\\bw.txt"));
//一次读取一个字符数据
// int ch;
// while ((ch=br.read())!=-1) {
// System.out.print((char)ch);
// }
//一次读取一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len=br.read(chs))!=-1) {
System.out.print(new String(chs,0,len));
}
br.close();
}11.字符缓冲流特有功能（最常用***************************************）
//创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new
FileWriter("myCharStream\\bw.txt"));
//写数据
for (int i = 0; i < 10; i++) {
bw.write("hello" + i);
//bw.write("\r\n");
bw.newLine();//在windows系统里相当于 bw.write("\r\n");
bw.flush();
}
//释放资源
bw.close();
//创建字符缓冲输入流
BufferedReader br = new BufferedReader(new
FileReader("myCharStream\\bw.txt"));
String line;
while ((line=br.readLine())!=null) {//一行一行的读取，只读内容不读换行符号
System.out.println(line);
}
br.close();12.IO流小结
标签：字符,java,字节,System,程序员,File,new,第六节,out 来源： https://blog.csdn.net/weixin_51181574/article/details/117417254