• 第八节:详细讲解Java中的异常处理情况与I/O流的介绍以及类集合框架


    前言

    大家好,我是 Vic,今天给大家带来详细讲解Java中的异常处理情况与I/O流的介绍以及类集合框架的概述,希望你们喜欢

    JAVA 异常

    try...catch...finally结构的使用方法

    class Test{
    public static void main(String args[]){
     
     try{ 
      int i = 1 / 0;
      }
      catch(Exception e){
       e.printStackTrace();
      }
      finally{
       System.out.println("finally");
      }
      System.out.println(5);
     }
    }
    
    class Test{
    public static void main(String args[]){
     try{
      Thread.sleep(1000);
     }
     catch(Exception e){
      e.printStackTrace();
     }
    }
    }
    

    throw和throws的作用区别:

    class Person{
    private int age;
    
    public void setAge(int age) throws Exception{
     if(age<0){
      RuntimeException e = new RuntimeException("年龄不能小于0");
      throw e;
     }
     this.age = age;
     }
    }
    
    class Test{
    public static void main(String args[]){
     Person person = new Person();
     try{
      person.setAge(-1);
     }
     catch(Exception e){
      System.out.println(e);
     }
    }
    }
    

    Error和Exception的区别

    • Error是Throwable的子类用于标记严重错误
    • Exception是Throwable的子类,指示合理的程序想去catch的条件,非严重错误。

    try/catch的执行过程

    如果出现异常,系统则会抛出一个异常,进行捕捉(catch操作),或在最后(finally)来进行处理。

    throw和throws的区别

    throws 出现在方法声明上,throw出现在方法体内。

    异常分类

    异常分类:可查异常,运行时异常和错误

    说说IO

    //第一种:输入流输出流
    //第二种:字节流字符流
    //第三种:节点流处理流
    //FileInputStream
    class Test{
     public static void main(String args[]){
      FileInputStream fis = null;
      try{
      fis = new FileInputStream("e:/read.txt");
      byte[] buffer = new byte[100];
      fis.read(buffer,0,buffer.length);
      for(int i = 0;i<buffer.length;i++){
       System.out.println(buffer[i]);
      }
    }
     catch(Exception e){
     System.out.println(e);
      }
     }
    }
    
    class Test{
     public static void main(String args[]){
      FileInputStream fis = null;
      FileOutputStream fos = null;
     try{
      fis = new FileInputStream("e:/read.txt");
      fos = new FileOutputStream("e:/write.txt");
      byte[] buffer = new byte[100];
      int temp = fis.read(buffer,0,buffer.length);
      fos.write(buffer,0,temp);
      }
       catch(Exception e){
        System.out.println(e);
       }
      }
    }
    
    class Test{
     public static void main(String args[]){
      FileInputStream fis = null;
      FileOutputStream fos = null;
      try{
       fis = new FileInputStream("e:/read.txt");
       fos = new FileOutputStream("e:/write.txt");
      byte[] buffer = new byte[1024];
      while(true){
       int temp = fis.read(buffer,o,buffer.length);
       if(temp = -1){
        break;
       }
       fos.write(buffer,0,temp);
      }
      }catch(Exception e){
       System.out.println(e);
     }finally{
      try{
      fis.close();
      fos.close();
     }catch(Excepiton e){
     System.out.println(e);
      }
     }
    }
    }  
    
    //字符流
    public class TextChar
     public static void main(String args[]){
      FileReader fr = null;
      FileWriter fw = null;
      try{
      fr = new FileReader("e:/read.txt");
      fw = new FileWriter("e:/write.txt");
       
       char[] buffer = new char[100];
       int temp = fr.read(buffer,0,buffer.length);
       fw.write(buffer,0,temp); 
       }
       catch(Exception e){
        System.out.println(e);
       }finally{
         try{
           fr.close();
           fw.close();
           }
       catch(Excepiton e){
        System.out.println(e); 
       }
      }
    }
    
    //FileReader和BufferedReader
    class Test{
     public static void main(String args[]){
      FileReader fileReader = null;
      BufferedReader bufferedReader = null;
    try{
      fileReader = new FileReader("e:/read.txt");
      bufferedReader = new BufferedReader(fileReader);
      String line = null;
       while(true){
       line = bufferedReader.readLine();
       if(line == null){ 
         break;
       }
       System.out.println(line);
      }
      }catch(Exception e){
      System.out.println(e); 
     }
      finally{
       try{
         bufferedReader.close(); 
         fileReader.close();
        }
        catch(Exception e){
         System.out.println(e);
        }
       }
      }
    }
    
    public class Test{
     public static void main(String[] args) throws Exception{
      //字节流
     FileInputStream in = new FileInputStream("c:/read.txt");
     FileOutStream out = new FileOutputStream("c:/write.txt");
     byte[] buffer = new byte[1024];
      int len;
      while( (len = in.read(buffer)) != -1){
      out.write(buffer,0,len);
      }
      in.close();
      out.close();
      //字符流
      BufferedReader bf = new BufferedReader(new FileReader("c:/read.txt");
      BufferedWriter bw = new BufferedWriter(new FileWriter("c:/write.txt");
     String str;
     while( (str=bf.readLine()) != null ){
      bw.write(str);
      bw.newLine();
     }
     bf.close();
     bw.close();
      }
    }
    
    • 字节流: InputStream字节输入流,OutputStream字节输出流
    • 字符流 : Reader字符输入流 ,Writer字符输出流
    • 数据流: DataInputStream 数据输入流 ,DataOutputStream 数据输出流

    集合框架

    一组类和接口,位于java.util包,主要用于存储和管理对象,主要分为三大类---集合,列表和映射。

    什么是集合(Set)
    集合中对象是没有顺序的,并且没有重复对象;

    什么是列表(List)
    集合中对象可以有重复的对象,可以按照顺序取,也可以指定取。

    什么是映射(Map)
    每一个元素包含一个键对象和一个值对象,键不可以重复,值可以重复。

    类集框架主体结构

    interface
    Iterator Collection
    ListIterator List Set Map
    LinkeList ArrayList HashSet SortedSet HashMap SortedMap
    LinkedHashSet TreeSet LinkedHashMap TreeMap
    Comparable Comparator Collections Arrays
    
    //arrayList默认10,可无限长,关于泛型
    
    public class Test{
    public static void main(String args[]){
    
     //ArrayList arrayList = new ArrayList();
     ArrayList<String> arrayList = new ArrayList<String>();
    
     arrayList.add("a");
     arrayList.add("b");
     arrayList.add("c");
    
     //String s = arrayList.get(1);
     //System.out.println(s);
    
      for(int i=0;i<3;i++){
       String s = arrayList.get(i);
       System.out.println(s);
      }
    
     }
    }
    
    优化
    
    public class Test{
    public static void main(String args[]){
     ArrayList<String> arrayList = new ArrayList<String>();
     
     arrayList.add("a");
     arrayList.add("b");
     arrayList.add("c");
     arrayList.add("d");
     
     for(int i = 0; i<arrayList.size();i++){
      String s = arrayList.get(i);
      System.out.println(s);
     }
    }
    }
    

    类集框架

    集合 无序 不可重复
    列表 有序 可重复
    映射

    Set继承了Collection

    public class Test{
     public static void main(String args[]){
    
      //HashSet<String> hashSet = new HashSet<String>();
      //Set<String> set = new HashSet<String>();
      
     //别管就是转,方便
      Set<String> set = new HashSet<String>();
      set.add("a");
      set.add("b");
      set.add("c");
      set.add("d");
    
      int i = set.size();
     
      System.out.println(i);
    
     }
    }
    
    不可以重复
    
    public class Test{
     public static void main(String args[]){
    
      //HashSet<String> hashSet = new HashSet<String>();
      //Set<String> set = new HashSet<String>();
      
     //别管就是转,方便
      Set<String> set = new HashSet<String>();
    
      boolean b1 = set.isEmpty();
      System.out.println(b1);
    
      set.add("a");
      set.add("b");
      set.add("c");
      set.add("d");
      set.add("c");
       
      boolean b2 = set.isEmpty();
      System.out.println(b2);
      
      int i = set.size();
      
      System.out.println("clear之前的长度"+i);
    
      set.clear();
      
      int j = set.size();
    
      System.out.println(j);
    
     }
    }
    
    取数据,迭代  iterate器 (Iterator)
    
    public class Test{
    public static void main(String args[]){
     //HashSet<String> hashSet = new HashSet<String>();
     //Set<String> set = hashSet;
     //Iterator <-- Collection <-- Set <-- HashSet
     //hasNext() next()
    
     Set<String> set = new HashSet<String>();
     
     set.add("a");
     set.add("b");
     set.add("c");
     set.add("d");
     set.add("c");
    
     Iterator<String> it = set.iterator();
    
      boolean b1 = it.hasNext();
      if(b1){
       String s = it.next();
       System.out.println(s);
      }
    
      boolean b2 = it.hasNext();
      if(b2){
       String s = it.next();
       System.out.println(s);
      }
    
     }
    }
    
    迭代器的使用
    it.hasNext();
    还有没有下一个元素,如果这个游标后面有元素就返回true,否则,false;
    
    it.next();
    返回游标所指位置的下一个元素,取出,用hasNext()看有没有,next取
    
    优化
    public class Test{
    public stattic void main(String args[]){
     Set<String> set = new HashSet<String>();
     
     set.add("a");
     set.add("b");
     set.add("c");
     set.add("d");
     set.add("c");
    
     Iterator<String> it = set.iterator();
    
     while(it.hasNext()){
      String s = it.next();
      System.out.println(s);
    }
    }
    }
    

    什么是映射(Map)
    每一个元素包含一个键对象和一个值对象,键不可以重复,值可以重复。

    public class Test{
    public static void main(String args[]){
     HashMap<String,String> hasMap = new HashMap<String,String>();
     Map<String,String> map = hasMap;
    
     map.put("1","a");
     map.put("2","b");
     map.put("3","c");
     map.put("4","d");
    
     int i = map.size();
     System.out.println(i);
    }
    }
    
    public class Test{
    public static void main(String args[]){
     HashMap<String,String> hasMap = new HashMap<String,String>();
     Map<String,String> map = hasMap;
    
     map.put("1","a");
     map.put("2","b");
     map.put("3","c");
     map.put("4","d");
     map.put("3","e");
    
     int i = map.size();
     System.out.println(i);
     
     String s = map.get("3");
     System.out.println(ss);
    }
    }
    
    public class TestCollection {
        public static void main(String[] args) {
            List<Hero> heros = new ArrayList<Hero>();
            for (int i = 0; i < 5; i++) {
                heros.add(new Hero("hero name " + i));
            }
            for (int i = 0; i < heros.size(); i++) {
                Hero h = heros.get(i);
                System.out.println(h);
            }
        }
    }
    

    总结

    • 本文讲了详细讲解Java中的异常处理情况与I/O流的介绍以及类集合框架,如果您还有更好地理解,欢迎沟通
    • 定位:分享 Android&Java知识点,有兴趣可以继续关注
  • 相关阅读:
    Saltstack module acl 详解
    Saltstack python client
    Saltstack简单使用
    P5488 差分与前缀和 NTT Lucas定理 多项式
    CF613D Kingdom and its Cities 虚树 树形dp 贪心
    7.1 NOI模拟赛 凸包套凸包 floyd 计算几何
    luogu P5633 最小度限制生成树 wqs二分
    7.1 NOI模拟赛 dp floyd
    springboot和springcloud
    springboot集成mybatis
  • 原文地址:https://www.cnblogs.com/dashucoding/p/11932675.html
Copyright © 2020-2023  润新知