• 第八节:详细讲解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知识点,有兴趣可以继续关注
  • 相关阅读:
    HDU 2639 Bone Collector II (01背包,第k解)
    POJ 2184 Cow Exhibition 奶牛展(01背包,变形)
    hihoCoder #1165 : 益智游戏 (挑战赛11 B题)
    UVA 562 Dividing coins 分硬币(01背包,简单变形)
    POJ Charm Bracelet 挑饰品 (常规01背包)
    hiho一下 第四十四周 博弈游戏·Nim游戏(直接公式解)
    UVA 624 CD(01背包,要记录路径)
    118 Pascal's Triangle 帕斯卡三角形 杨辉三角形
    117 Populating Next Right Pointers in Each Node II 每个节点的右向指针 II
    116 Populating Next Right Pointers in Each Node 每个节点的右向指针
  • 原文地址:https://www.cnblogs.com/dashucoding/p/11932674.html
Copyright © 2020-2023  润新知