HashMap和File与IO总结

最新推荐文章于 2024-02-19 15:48:37 发布
最新推荐文章于 2024-02-19 15:48:37 发布
阅读量287 收藏
点赞数
分类专栏： java 文章标签： 数据结构 java HashMap原理 IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhblog/article/details/127447672
版权

HashMap和File与IO

1、Collection
（1）体系结构Iterator Collection 子接口 List 实现类ArrayList、Vector、LinkedList Set HashSet…
Map 实现类 HashMap
（2）常用方法
（3）迭代器

  • 使用增强for，底层就是迭代器 for(类型 变量:要遍历集合或者数组) { }
  • 迭代器原理
  • 首先创建迭代器对象，判断是否有下一个元素，指向下一个元素，获取出来

2、List集合
（1）List特点：有序的，可以重复元素，底层结构数组、链表…
（2）List常用方法：add get size…
（3）List遍历四种方式：普通for、增强for、迭代器、List迭代器
（4）实现类存储结构和扩容机制：ArrayList、Vector、LinkedList

3、Set集合
（1）set特点：没有重复，无序
（2）实现类和方法
（3）Set集合遍历：增强for、迭代器

4、Map集合
（1）Map特点：键值对 key-value
（2）Map集合方法和遍历

  • 添加 put
  • 删除（取出） remove
  • 清空 clear
  • 所有key ketSet
  • 所有value values
一、HashMap底层结构和原理

（1）创建HashMap对象时候，初始化几个值，

  • 主要：table代表数组默认null，负载因子默认0.75，边界值0
    （2）第一次向HashMap添加元素
  • 根据添加数据key计算hash值
  • 判断当前table数组是否为空，第一次肯定是空，数组进行初始化
    – 数组容量 16 ，临界值 12
  • 根据数组初始长度和hash值得到数组某个位置，在位置添加元素（第一次加不存在重复问题）

（3）容量不超过临界值12时候，再次添加数据

  • 根据添加数据key计算hash值
  • 根据数组长度和hash值得到数组某个位置，在位置添加元素
    – 判断数组这个位置上面是否存在元素，如果不存在，添加
    – 如果位置存在元素，
    — 判断位置元素key是否一样，如果key相同，替换，如果key不一样，链表存储

（4）容量超过临界值12，添加数据

  • 根据添加数据key计算hash值
  • 根据数组长度和hash值得到数组某个位置，在位置添加元素
    – 判断数组这个位置上面是否存在元素，如果不存在，添加
    – 如果位置存在元素，
    — 判断位置元素key是否一样，如果key相同，替换，如果key不一样，链表存储
    – 判断数组容量是否超过临界值，如果超过进行扩容
    — 把数组大小2倍，临界值2倍
    — 把数组元素重新编排

（5）在jdk1.8优化

  • 如果数组容量64，链表节点8，把链表转换树形结构

二、Map集合补充
1、Hashtable解决线程安全问题，任何非 null 对象都可以用作键或值。
HashMap是线程不安全的，并允许使用 null 值和 null 键。
2、LinkedHashMap是HashMap子类
3、TreeMap

三、File文件操作
1、什么是File
File类是java.io包下代表与平台无关的文件和目录，也就是说如果希望在程序中操作文件和目录都可以通过File类来完成，
File类能新建、删除、重命名文件和目录。

2、常用方法

public class FileDemo1 {

    public static void main(String[] args) throws IOException {
        // 文件路径名
//        String pathname = "D:\\aaa.txt";
//        File file1 = new File(pathname);

        // 文件路径名
        String pathname2 = "E:\\0224\\bbb.txt";
        File file = new File(pathname2);
        //1 查看是否存在文件
        boolean exists = file.exists();
        //System.out.println(exists);

        //2 获取文件路径和文件名称
//        System.out.println("文件构造路径:"+file.getPath());
//        System.out.println("文件名称:"+file.getName());

        //3 public boolean isDirectory()` ：此File表示的是否为目录。
        //- `public boolean isFile()` ：此File表示的是否为文件。
//        System.out.println(file.isDirectory());
//        System.out.println(file.isFile());

        //相对路径
        //    ./  当前目录下
        //  ../   上层目录   ../../

        //- public boolean createNewFile()` ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
        //- `public boolean delete()` ：删除由此File表示的文件或目录。  只能删除空目录。
        //- `public boolean mkdir()` ：创建由此File表示的目录。单层目录
        //- `public boolean mkdirs()` ：创建由此File表示的目录，包括任何必需但不存在的父目录。 多层目录

        File  f = new File("E:\\aaa.txt");
//        System.out.println(f.exists());
        boolean newFile = f.createNewFile();
//        System.out.println(newFile);
//        System.out.println(f.exists());

        File f1 = new File("E:\\atguigu0224");
//        System.out.println(f1.exists());
        boolean mkdir = f1.mkdir();
//        System.out.println(mkdir);
//        System.out.println(f1.exists());

        File f2 = new File("E:\\wwww\\abcd");
        boolean mkdir1 = f2.mkdir();
       // System.out.println(mkdir1);

        boolean mkdirs = f2.mkdirs();
       // System.out.println(mkdirs);

        boolean f1delete = f1.delete();
       // System.out.println(f1delete);

        boolean f2delete = f2.delete();
       // System.out.println(f2delete);

        File dir = new File("E:\\wwww");

        //获取当前目录下的文件以及文件夹的名称。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files = dir.listFiles();
        for (File file1 : files) {
            System.out.println(file1);
        }
    }
}

3、递归操作

package com.atguigu.io;

import java.io.File;
import java.io.IOException;

public class FileDemo2 {

    public static void main(String[] args) throws IOException {
        File file = new File("E:\\wwww");
        listSubFiles(file);
    }

    //递归遍历所有目录
    public static void listSubFiles(File dir) {
        //判断
        if(dir !=null && dir.isDirectory()) {
            //获取dir里面内容
            File[] files = dir.listFiles();
            //files是否为空
            if(files != null) {
                //遍历
                for(File file:files) {
                    //递归调研
                    listSubFiles(file);
                }
            }
        }
        System.out.println(dir);
    }
}

四、IO
1、什么是io
（1）针对文件内容操作，Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。
输入也叫做读取数据，输出也叫做作写出数据。

2、IO流分类
根据数据的流向分为：输入流和输出流**。
- 输入流 ：把数据从其他设备上读取到内存中的流。
- 以InputStream,Reader结尾
- 输出流：把数据从内存 中写出到其他设备上的流。
- 以OutputStream、Writer结尾

根据数据的类型分为：字节流和字符流。

  • 字节流 ：以字节为单位，读写数据的流。比如读取图片
    • 以InputStream和OutputStream结尾
  • 字符流 ：以字符为单位，读写数据的流。比如读取文本
    • 以Reader和Writer结尾

3、字节流-输出流（重点）
（1）字节输出流 OutputStream 向文件写入内容
（2）OutputStream有很多方法：write close
OutputStream子类 FileOutputStream，专门针对文件操作

（3）演示使用输出流写文件简单操作 asc码

    public static void main(String[] args) throws Exception {
        //创建操作文件输出流对象
        OutputStream outputStream = new FileOutputStream("E:\\0224\\atguigu.txt");
        //OutputStream outputStream = new FileOutputStream(new File("E:\\0224\\atguigu.txt"));

        //向文件写入内容
        outputStream.write(97);
        outputStream.write(98);
        outputStream.write(99);

        //关闭输出流
        outputStream.close();
    }

（4）字节数组写内容

    @Test
    public void outFile01() throws Exception {
        //创建操作文件输出流对象
        OutputStream out = new FileOutputStream("E:\\0224\\a.txt");
        //写内容
        byte[] b = "尚硅谷".getBytes();
        out.write(b);
        //关闭
        out.close();
    }

（5）指定位置字符写到文件

    @Test
    public void outFile02() throws Exception {
        //创建操作文件输出流对象
        OutputStream out = new FileOutputStream("E:\\0224\\b.txt");
        //写内容
        byte[] b = "abcde".getBytes();
        //write 第一个参数开始位置 索引
        //      第二个参数 从开始位置取几个字符
        out.write(b,2,2);
        //关闭
        out.close();
    }

4、字节流-输入流（重点）
（1）字节输入流 InputStream，读文件，常用方法：close read
（2）InputStream子类 FileInputStream，专门进行文件读取操作

（3）调用read方法读取文件内容

    public static void main(String[] args) throws Exception {
        //创建操作文件输入流对象
        InputStream inputStream = new FileInputStream("E:\\0224\\b.txt");
        //读取文件内容
        int read = inputStream.read();
        System.out.println((char) read);
        //关闭
        inputStream.close();
    }

（4）循环读取文件内容

    @Test
    public void readFile01() throws Exception {
        //创建操作文件输入流对象
        InputStream inputStream = new FileInputStream("E:\\0224\\b.txt");
        //定义变量
        int b;
        //循环判断读取
        while((b = inputStream.read())!=-1) {
            System.out.println((char)b);
        }
        //关闭
        inputStream.close();
    }

（5）字节数组读取文件内容

    @Test
    public void readFile02() throws Exception {
        //创建操作文件输入流对象
        InputStream inputStream = new FileInputStream("E:\\0224\\b.txt");
        //定义变量
        int len;
        //字节数组
        byte[] b = new byte[1024];
        //循环读取
        while((len = inputStream.read(b))!=-1) {
            System.out.println(new String(b));
        }
        //关闭
        inputStream.close();
    }

5、字节输入流和输出综合例子

    public static void main(String[] args) throws Exception {
        //E:\01.jpg
        //1 创建输入流读取文件
        InputStream in = new FileInputStream("E:\\01.jpg");
        //2 创建输出流
        OutputStream out = new FileOutputStream("E:\\0224\\001.jpg");
        //3 流对接：把输入流内容放到输出流里面
        int len;
        byte[] b = new byte[1024];
        while((len=in.read(b))!=-1) {
            //把读到内容直接写到文件
            out.write(b,0,len);
        }
        //4 关闭
        out.close();
        in.close();
    }

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

（2）字符输入流 Reader，子类 FileReader

public class ReaderDemo {

    public static void main(String[] args) throws Exception {
        Reader reader = new FileReader("E:\\0224\\b.txt");
        //字符数组读取
        char[] cbuf = new char[1024];
        int len;
        while((len=reader.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
        reader.close();
    }
}

（3）字符输出流 Writer，子类 FileWriter

7、其他流
（1）缓冲流
缓存：提高读速度
缓冲：提高写速度

  • 字节输入流 InputStream – BufferedInputStream

  • 字节输出流 OutputStream – BufferedOutputStream

  • 字符输入流 Reader – BufferedReader

  • 字符输出流 Writer – BufferedWriter


    //缓冲流实现
    @Test
    public void test02() throws Exception {
        // 记录开始时间
        long start = System.currentTimeMillis();
        // 创建流对象
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("E:\\01.mp4"));
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("F:\\01.mp4"));
        // 读写数据
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }

        fos.close();
        fis.close();

        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
    }

（2）转换流

    public static void main(String[] args) throws Exception {
        // 定义文件路径,文件为gbk编码
        String FileName = "E:\\aaa.txt";
        // 创建流对象,默认UTF8编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
        // 创建流对象,指定GBK编码
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
        // 定义变量,保存字符
        int read;
        // 使用默认编码字符流读取,乱码
        while ((read = isr.read()) != -1) {
            System.out.print((char)read);
        }
        isr.close();

        // 使用指定编码字符流读取,正常解析
        while ((read = isr2.read()) != -1) {
            System.out.print((char)read);// 大家好
        }
        isr2.close();
    }
yhblog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
File、HashMap线程不安全、IO流、封装的感想、数据类型 转换、异常
06-04
以结构图记录自己的记录自己面对的感触
Javase进阶5：文件与IO
weixin_43498449的博客
05-20 194
1. File文件操作 1.1 什么是File File类是java.io包下代表与平台无关的文件和目录，也就是说如果希望在程序中操作文件和目录都可以通过File类来完成， File类能新建、删除、重命名文件和目录。 1.2 常用方法 public class FileDemo1 { public static void main(String[] args) throws IOException { // 文件路径名 // String path
JAVA基础初探（十二）Map接口及其常用实现类(HashMap)、File类详解（概述、创建、删除、重命名、文件属性读取/设置、遍历文件夹）
浅然的专栏
02-02 456
该篇博客目录 1、Map接口及其常用实现类(HashMap、Hashtable) 2、File类(概述、创建、删除、重命名、文件属性读取/设置、遍历文件夹) 一、Map接口及其常用实现类(HashMap、Hashtable) 1、Map接口保存形式(键值对) key—>value的方式保存，所以既需要保存key也需要保存value 2、Map常用实现类
File文件与Map集合的综合练习
m0_51021388的博客
07-18 292
1. File类的list功能递归遍历filedir 2. 遍历文件使用文件过滤器获得目录中有几种不同的文件格式以及文件的个数 结果存储到map集合中 {java:4,txt:2,doc:8} 3.根据map 集合的 key 创建目录 例如java 目录 并把文件移动到对应的目录中 复制(字节流进行文件复制) 4. 定义一个方法 把map 集合中文件和文件记录数据写入到一个文件中 要求按照从高到低写入到文件 对map 集合的value 进行排序 ...
java dir.exists_Java Directory.fileExists方法代碼示例
weixin_36472741的博客
03-04 220
import org.apache.lucene.store.Directory; //導入方法依賴的package包/類@Overridepublic TermVectorsReader vectorsReader(Directory directory, SegmentInfo segmentInfo, FieldInfos fieldInfos, IOContext context) thr...
Java文件操作和IO
澄白易的博客
06-05 672
我们先来认识狭义上的文件(file)。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时， 往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概 念，就类似办公桌上的一份份真实的文件一般。 文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据 而存在，我们把这部分信息可以视为文件的元信息。随着文件越来越多，对文件的系统管理也被提上了日程，如何进行文件的组织呢，一种合乎自然 的想法出现了，就是按照层级结构进行组织 —— 也就是
Java 基础核心总结 +经典算法大全.rar
11-08
节点流和处理流 Java IO 的核心类 File Java IO 流对象 字节流对象InputStream OutputStream 字符流对象Reader Writer 字节流与字符流的转换新潮的 NIO 缓冲区(Buffer)通道(Channel) 示例:文件拷贝案例 BIO 和 NIO ...
java 面试题 总结
09-16
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的...
java基础案例与开发详解案例源码全
04-04
13.1 java.io.File类328 13.1.1 文件和目录是什么？328 13.1.2 Java对文件和目录的操作328 13.2 JavaIO原理332 13.3 流类结构333 13.3.1 InputStream和OutputStream333 13.3.2 Reader和Writer334 13.4 文件流336 ...
java基础核心总结归纳---参考手册--心得手册-学习资料-总结经验
12-20
基础 IO 类和相关⽅法 25 InputStream 25 OutputStream 25 Reader 类 26 Writer 类 26 InputStream 及其⼦类 27 OutputStream 及其⼦类 27 Reader 及其⼦类 28 Writer 及其⼦类 28 注解 28 关于 null 的⼏种处理⽅式...
javaIo与流 读写文件
12-17
1、在读写文件时必须的 2、File类 3、流 4、读写文件 运用FileInputStream和FileOutputStream类读写文本文件 运用BufferedReader和BufferedWriter类读写文本文件 运用DataInputStream和DataOutputStream类读写二进制 文件
python dict hashmap_20200805_容器类HashMap(相当于python字典)以及IO流（读写操作）
weixin_39894104的博客
12-18 173
1、作业题参考一.新建一个类ArrayListDemo，使用今天上课讲解api完成下面需求。1、定义老师类Teacher，私有属性：name，age，提供空参有参构造，提供get/set方法2、创建老师对象t1，name：张三，age：253、创建老师对象t2，name：李四，age：354、创建老师对象t3，name：老王，age：195、创建老师对象t4，name：赵六，age：296、创建A...
【Java】文件操作和IO
m0_72670269的博客
08-31 352
抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。同时，随着文件越来越多，对文件的系统管理也被提上了日程，如何进行文件的组织呢，一种合乎自然的想法出现了，注意：当完成流的操作时，必须调用close()方法，释放系统资源，否则会造成内存泄漏。注意：当完成流的操作时，必须调用close()方法，释放系统资源，否则会造成内存泄漏。说明：close()方法，当完成流的操作时，必须调用此方法，释放系统资源。
java dir.exists_java – file.exists()在文件存在时返回false
weixin_35711852的博客
02-13 1195
在我正在处理的Android应用程序中,用户应该能够在SD卡上创建一个新的CSV文件,使用他们在EditText中输入的文本命名.问题是在使用目录和文件名实例化文件后,file.exists()返回false,即使该文件确实存在于该位置.我使用Android文件浏览器和Windows资源管理器浏览了SD卡,文件确实存在.这是检查文件是否已经存在的正确方法,如果是,我错过了什么,以便它存在时返回tr...
用DirectoryExists和FileExists判断指定路径下是否存在指定的文件夹或文件
菜鸟小扎
03-03 3万+
用DirectoryExists和FileExists判断指定路径下是否存在指定的文件夹或文件
java判断指定路径文件夹是否存在,若不存在则创建新的文件夹
热门推荐
菜猿子的博客
07-12 6万+
//dirPath  :文件夹磁盘路径 private static void isChartPathExist(String dirPath) {        File file = new File(dirPath);        if (!file.exists()) {            file.mkdirs();        }    }...
Java文件IO操作及案例
trong_ 的烂笔头
02-03 3380
详细介绍常用的文件IO操作, 即针对文件系统的操作和文件内容的读写, 介绍一些IO操作的代码案例.
java dir.exists_Java SmbFile.exists方法代码示例
weixin_42361175的博客
02-16 406
import jcifs.smb.SmbFile; //导入方法依赖的package包/类@BeforeClassvoid beforeClass() throws IOException {Properties properties = new Properties();InputStream propertiesInput = new FileInputStream(PROPERTIES);t...
【Java】文件类 和 I/O流详解
最新发布
weixin_65837702的博客
02-19 1382
什么是文件？文件是计算机中存储数据的一种方式，它可以用来保存各种类型的信息，如文本、图像、音频和视频等。文件通常由文件名和扩展名组成，扩展名（后缀名）表示文件的类型或格式。在Windows系统中不同的文件后缀通常代表着不同的文件类型和默认打开方式，如 docx为WPS中word文档的后缀，jpg或png为常见的图片文件后缀，exe通过代表一个可执行程序等；但是Unix、Linux等操作系统上则没有这样精确的分类。文件的分类：文件总体上可以分为文本文件（ASCII码文件）和二进制文件。
hashmap写入文件
01-15
要将多个HashMap写入文件并能够单个存取，可以使用Java的序列化和反序列化机制来实现。首先，将多个HashMap对象存储到一个List中，然后将整个List对象进行序列化并写入文件。当需要单个存取时，可以将整个List对象从文件中反序列化出来，并根据需要获取其中的HashMap对象。 以下是一个示例代码： ```java import java.io.*; import java.util.*; public class HashMapFileIO { public static void main(String[] args) { List<HashMap<String, Integer>> hashMapList = new ArrayList<>(); // 添加多个HashMap对象到List中 HashMap<String, Integer> hashMap1 = new HashMap<>(); hashMap1.put("key1", 1); hashMap1.put("key2", 2); hashMapList.add(hashMap1); HashMap<String, Integer> hashMap2 = new HashMap<>(); hashMap2.put("key3", 3); hashMap2.put("key4", 4); hashMapList.add(hashMap2); // 将List对象序列化并写入文件 try { FileOutputStream fileOut = new FileOutputStream("hashmap.ser"); ObjectOutputStream out = new ObjectOutputStream(fileOut); out.writeObject(hashMapList); out.close(); fileOut.close(); System.out.println("HashMap写入文件成功！"); } catch (IOException e) { e.printStackTrace(); } // 从文件中读取并反序列化List对象 List<HashMap<String, Integer>> readHashMapList = null; try { FileInputStream fileIn = new FileInputStream("hashmap.ser"); ObjectInputStream in = new ObjectInputStream(fileIn); readHashMapList = (List<HashMap<String, Integer>>) in.readObject(); in.close(); fileIn.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } // 单个存取HashMap对象 if (readHashMapList != null) { HashMap<String, Integer> hashMap = readHashMapList.get(0); System.out.println("从文件中读取的HashMap对象："); System.out.println(hashMap); } } } ``` 运行以上代码，将会在当前目录下生成一个名为"hashmap.ser"的文件，其中存储了多个HashMap对象。通过反序列化，可以将这些HashMap对象读取出来，并进行单个存取。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yhblog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值