JavaSE基础07(集合,IO流)

  • 集合collection
  1. 数组存放数据的弊端:
    1. 数组定义后长度不可变;
    2. 定义数组的类型不能变，数据只能存放指定类型的对象;
  2. 解决数组存放的弊端方法:
    1. 摒弃小数组，换一个更大的来存放(动态数组扩容);
    2. 数组定义成Object，可以存放所有的类型;
    3. 集合扩容 在原来的基础上+>>1;
  3. System.arraycopy(Object src,int srcPos,Object dre,int destPos,int length);
  4. 数组的复制参数: (原数组 原数组开始复制的位置 目标数组  从哪个位置开始粘贴到目标数组  复制数组的个数);

  5.  

  • ArrayList
  1. ArrayList list=new ArrayList();    首先创建ArrayList对象;
  2. list.add() ,往集合里添加元素或 list.add(要添入的位置,添入数组);
  3. list.set(要修改的位置,修改的值); 修改数据
  4. list.remove(要删除元素的下标)或list.remove(要删除的元素);
  5. list.get(下标值)查数据;
  6. 有序集合,进出数据是一样的;
  7. 扩容:默认容量是10, 当已经达到了最大值的大小,扩容原来的1.5倍;
  • 遍历集合方法
    • 迭代器 
              ArrayList list=init();//init()方法返回的ArrayList
        //迭代器 用于遍历集合的每一个元素
        Iterator it=list.iterator();
        //是否有下一个数据
        while (it.hasNext()){
            //获取下一个数据
            Object obj=it.next();
            System.out.print(obj+",");
        }

    •  把集合放在数组里,然后遍历数组;

              Object[] arr=list.toArray();//把集合放在Object数组里
        System.out.println(Arrays.toString(arr));//打印数组

       

  • LinkedList
  1. LinkedList是双向链表;
  2. 查找ArrayList更优;
  3. 插入和删除LinkedList更优;
  • Set集合
  1. 无序集合,不能存在重复的数据;
  2. 使用equals方法验证数据是否相等;
  3. Set的底层就是Map;
  4. 遍历set集合; 
            for(Object obj:set) {//把每一个都赋给obj
            System.out.println(obj);
        }
  5. 验证set里面有没有这个元素     返回的是布尔值; 
            boolean b =set.contains("张三");//验证set里面有没有这个元素  返回布尔类型
        System.out.println(b);
  • HashSet
  1. 可以存储null值,只能存储一个;
  2. 主要用于安全验证上;
  • TreeSet
  1. 排序集合,但是也是无序集合;
  2. 不可以存储null值,null不可以比较;
  3. 存的数据都是可比较的,尽量存同类数据;
  4. 数据结构是红黑树;
  • Hashtable
  1. 是一个线程安全的键值对集合  不能存key和value都不能是null值;
  • Map集合(有键值对)
  • HashTable  (线程安全) 效率慢：锁的颗粒度大
  • concurrentHashMap （线程安全）效率较快：锁的颗粒度较小
  • HashMap （线程不安全）
  • 存储过程
  1. HashMap使用数组+链表以及红黑树的方式存储数据;
  2. HashMap的数组默认长度16,需要根据key算出节点存放的下标位置index;
  3. 判断index位置已经有对象:如果没有,直接把要存放的key和value放到这个位置上;
  4. 如果已经有元素存在,就在这个链表上查找和要存储的key相同的节点;
  5. 如果没有找到,就把key和value组成节点放到链表最后;
  6. 如果找到,就替换;
  • 扩容机制
  1. HashMap的初始容量是16;
  2. 扩容阈值是0.75;
  3. 何时扩容:
    1. HashMap中存储的数据个数超过数组长度*0.75,就要扩容;
    2. 如果单个链表的长度超过8,但是数组的长度没有超过64,就扩容;
  4. 何时树化:
    1. 单链长度超过8,数组长度超过64(包含)才进行树化;
    2. 哪个链超过了阈值就哪个链树化;
    3. 如果树化后的节点数小于6,就退树化,变成链表;
  5. 用数组和链表存储数值;
  6. 要用时要实例化Map对象; Map map = new HashMap();
  7. 添加数据 map.put(key,value);
  8. 删除数据 map.remove(key);  Object obj1=map.get(2001); 返回删除值; 
    boolean b=map.remove(2001, "张三");//防止误删
  9. Map中的key不能重复,如果重复就把原来的值替换了;
  10. map的遍历
    1. 获取所有的key 
             Set keys=map.keySet();
       for(Object item:keys) {
           System.out.println(item+"="+map.get(item));//get获取集合的value
           
       }
    2. 获取所有的value 
             Collection con=map.values();
       for(Object val:con) {
           System.out.println(val);
       }
  • 泛型

  1. 在定义类方法时,声明一个泛型,比如<E>开代表任意的一个类型;

  2. 在类中声明的泛型,在整个类中都可以直接使用;
  3. 保证数据类型安全  避免出现ClassCastException;
  4. 方法泛型的 类型:
    1.     E obj;
    public E getObj(E e) {
        return obj;
    }
    2. public static <R> R getInstace(R r) {
        return r;
    }
  5. 泛型的使用: 
    public static <R> R getInstace(R r) {
        return r;
    }
    public static void main(String[] args) {
//        ArrayList
        getInstace(12);
        List<Integer> list =new ArrayList<Integer>();//规范使用Integer类型,不然添加不进去,保证数据类型安全,在编译时起到作用
        for(int i=0;i<100;i++) {
            int item=(int)(Math.random()*80+10);
            list.add(item);
        }
//        list.add("123");
        int sum=0;
        for(Object obj:list) {
            Integer i =(Integer)obj;
            sum+=i;
        }System.out.println(list);
        System.out.println(sum);
    }
  • IO流
  • 文件
  1. File  新建文件File file=new File("文件路径 ");
  2. 判断文件是否存在 
    boolean b=file.exists();//判断文件是否存在
        if(b==true) {
            System.out.println("文件存在");
        }else {
            System.out.println("文件不存在");
        }
  3. 创建文件夹 
            File file1=new File("D:\\hello");
        boolean b1=file1.mkdir();//只能创建一级文件夹   mkdirs()可以创建多级文件夹
        if(b1) {
            System.out.println("创建成功");
        }else {
            System.out.println("创建失败");
        }
  4. 创建文件 
    try {
            boolean b1=file.createNewFile();
            
        } catch (IOException e) {
            System.out.println("创建文件中断");
            e.printStackTrace();
        }
  5. 删除文件或文件夹 
    file.delete();// 删除文件或删除文件夹
    //递归删除
        if(file.isDirectory()){//判断file是不是文件夹
            File[] arr=file.listFiles();//把文件夹下的目录赋给文件夹数组
            for(File f:arr){//遍历数组,把每个元素赋给f
                delete(f);//把f再传入delete方法,一直到文件夹下不包括文件
            }
        }
        file.delete();//当遇到空元素跳出if
    }

  6. 获取文件夹的文件

  • IO流
  1. 创建流对象 FileReader();
  2. 字节流:
    1. InputStream is;  //字节输入流;
    2. OutputStream od;  //字节输出流;
    3. 字符流只能读取文本文件,或文本内容 txt html java propertis css js xml yml ;
  3. 字符流:
    1. Reader r;  //字符输入流;
    2. Writer w;  //字符输出流;
    3. 字节流可以读取任何数据 word jpeg 图片 音频 视频文件;
  4. 读取文件中的数据 
            File src=new File("c:\\java\\java.txt");//源文件
        //输入流
        FileReader fr=null;
        try {
            fr=new FileReader(src);//创建流对象
            char[] arr=new char[64];//读取数据的容器
            int length=fr.read(arr);//读取一次数据  读到的数据放到arr数组中
            System.out.println(Arrays.toString(arr));
            String str =new String(arr,0,length);//将读取到的数据转成字符串
            System.out.println(str);
  5. 最后要关流,在finally中 
    try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
  6. 读取文件中的大量数据(while循环); 
            File file=new File("c:\\java\\java.txt");
        FileReader fr=null;
        try {
            fr=new FileReader(file);
            int length=0;//每次读取数据的个数
            char[] arr=new char[18];
            while((length=fr.read(arr))!=-1) {
                String str=new String(arr,0,length);
                System.out.println(str);
            }
  7. 把数据写入到文件中; 
            String str="作者是李白";
    //将str内容写出到d:\java\easy.txt文件中
    //声明文件对象
    File file =new File("d:\\java2\\java.txt");
    //使用文件字符输入流 ,将内容写出
    FileWriter fw=null;
    try{
        fw=new FileWriter(file,true);//true是否追加
        fw.write(str);//把str写入fw
    }catch(Exception e) {
        e.printStackTrace();
    }finally {
        //关闭流
  8. 文件复制,(先读取再写入) ,(读入用于读入数据和将数据读取到容器的次数),(length用于判断是否读完和为写入数据提供参数); 
    //复制文件
    public static void main(String[] args) {
        File src=new File("c:\\java\\java.txt");
        File dest=new File("d:\\java2\\java.txt");
        //将src的内容复制到dest中
        char[] arr=new char[64];//使用arr存放每次读取的内容
        int length=0;//每次读取数据的个数
        FileReader fr=null;
        FileWriter fw=null;
        try {
            //将src中的内容读入程序 输入流
            fr=new FileReader(src);
            //将读到的内容写进dest文件  输出流
            fw=new FileWriter(dest);
            //每次读取的数据长度赋值给length 读取完毕返回-1
            while((length = fr.read(arr))!=-1) {
                fw.write(arr,0,length);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {// 关流  先关读流再关写流
  9. 图片的复制,(用到字节流,容器用byte[ ]); 
    //    InputStream is;//字节输入流
//    OutputStream os;//字节输出流
    public static void main(String[] args) {
        File src=new File("c:\\java\\123.jpeg");
        File dest=new File("d:\\java2\\3.jpeg");
        byte[] b=new byte[64];
        int length=0;
        FileInputStream is=null;
        FileOutputStream os=null;
        try {
            is=new FileInputStream(src);
            os=new FileOutputStream(dest);
            while((length=is.read(b))!=-1) {
                os.write(b,0,length);
            }
        }catch(Exception e) {
            e.printStackTrace();
        }finally {
  10. 缓冲读入文件(先在缓冲区多行读入,再用while循环把每一行数据复制给String str ,判断条件是str是否为null) 
            File file =new File("c:\\java\\java.txt");
        FileReader fr=null;
        BufferedReader br=null;
//        BufferedInputStream
        try {
            fr=new FileReader(file);
            br=new BufferedReader(fr);//缓冲区
            String str=null;
            while(true) {
                str=br.readLine();
                if(str==null) {
                    break;
                }
                System.out.println(str);
            }//捕获异常 再关流
  11. 缓冲写出文件,(先把数据写到缓冲区,当缓冲区写满时或读到最后刷新到文件上); 
            BufferedWriter bw=null;
        FileWriter fw=null;
        File file =new File("d:\\java2\\java.txt");
        try {
            fw=new FileWriter(file);
            bw=new BufferedWriter(fw);
            bw.write(str);
            //缓冲输出流,执行完毕之后需要执行flush方法
            bw.flush();
        }catch(Exception e){
            e.printStackTrace();
            
        }finally {  //关流 先关bw流再关fw流

  12. 序列化,(将对象转换成有效序列(二进制)的过程) Student必须实现序列化接口 (文件输出流,序列化流,oos.writeObject(stu)) 

    Student stu=new Student(12,"张三","男");
        String filename="d:\\java2\\obj.txt";
        FileOutputStream fos=null;
        ObjectOutputStream oos=null;
        try {
            fos=new FileOutputStream(filename);
            oos=new ObjectOutputStream(fos);
            oos.writeObject(stu);
        }catch(Exception e){
            e.printStackTrace();
        }finally {//关流  先关oos流再关fos流
          Student implements Serializable //Student必须实现序列化接口
  13. 反序列化, (反序列化:将有效序列转化成对象的过程),和序列化对应的是Object obj=ois.readObject(); 然后再判断Object是不是Student,如果是再强制转换; 
            String filename="d:\\java2\\obj.txt";
        FileInputStream fis=null;
        ObjectInputStream ois=null;
        try {
            fis =new FileInputStream(filename);
            ois=new ObjectInputStream(fis);
            Object obj=ois.readObject();
            if(obj instanceof Student){
                Student student=(Student)obj;
                System.out.println(student);
        }//捕获异常 再关流

     

 

 

posted @ 2023-10-16 20:00  卡皮巴拉  阅读(19)  评论(0)    收藏  举报