浅谈：java中的异常、集合以及文件File

最新推荐文章于 2022-06-04 20:27:07 发布

ACE1125

最新推荐文章于 2022-06-04 20:27:07 发布

阅读量285

点赞数

分类专栏： java 文章标签：异常集合 Map File List

本文链接：https://blog.csdn.net/h_h_1122/article/details/100831339

版权

java 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

一、Exception 基类/父类

java.io.IOException：当发生某种 I/O 异常时，抛出此异常。此类是失败或中断的 I/O 操作生成的异常的通用类。

构造方法摘要
IOException()
          构造一个 IOException，使用 null 作为其错误详细消息。
IOException(String message)
          构造带指定详细消息的 IOException。
IOException(String message, Throwable cause)
          构造带有指定详细消息和 cause 的 IOException。
IOException(Throwable cause)
          构造一个 IOException，使其具有指定的 cause 以及详细消息 (cause==null ? null : cause.toString())（通常包含类和 cause 的详细消息）。

printStackTrace()方法：java.lang.Throwable.printStackTrace() lang包里面Throwable类里面的方法

Throwable 类是 Java 语言中所有错误或异常的超类，两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。
Throwable
public Throwable()构造一个将 null 作为其详细消息的新 throwable。Cause 尚未进行初始化，可在以后通过调用 initCause(java.lang.Throwable) 来初始化。
调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。
--------------------------------------------------------------------------------
Throwable
public Throwable(String message)构造带指定详细消息的新 throwable。Cause 尚未进行初始化，可在以后通过调用 initCause(java.lang.Throwable) 来初始化。
调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。
参数：
message - 详细消息。保存这个详细消息，以便以后通过 getMessage() 方法对其进行获取。
--------------------------------------------------------------------------------
Throwable
public Throwable(String message,
Throwable cause)构造一个带指定详细消息和 cause 的新 throwable。
注意，与 cause 相关的详细消息不是自动合并到这个 throwable 的详细消息中的。

调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。
参数：
message - 详细消息（保存此消息，以便以后通过 getMessage() 方法获取它）。
cause - 原因（保存此 cause，以便以后通过 getCause() 方法获取它）。（允许 null 值，指出 cause 是不存在的或是未知的。）
从以下版本开始：
1.4
--------------------------------------------------------------------------------
Throwable
public Throwable(Throwable cause)构造一个带指定 cause 和 (cause==null ? null :cause.toString())（它通常包含类和 cause 的详细消息）的详细消息的新 throwable。此构造方法对于那些与其他 throwable（例如，PrivilegedActionException）的包装器相同的 throwable 来说是有用的。
调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。
参数：
cause - 原因（保存此 cause，以便以后通过 getCause() 方法获取它）。（允许 null 值，指出 cause 是不存在的或是未知的。）
try catch
IOException：//java.io.IOException
ArithmeticException ：当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。 // java.lang.Exception
InputMismatchException：//java.util.InputMismatchException 由 Scanner 抛出，表明获取的标记与期望类型的模式不匹配，或者该标记超出期望类型的范围。

InputMismatchException
public InputMismatchException()构造 InputMismatchException，使用 null 作为其错误消息字符串。
--------------------------------------------------------------------------------
InputMismatchException
public InputMismatchException(String s)构造 InputMismatchException，将引用保存到错误消息字符串 s 中，以便将来由 getMessage 方法获取。
参数：
s - 详细消息。

Exception 基类/父类：Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。// java.lang.

构造方法摘要
Exception()
          构造详细消息为 null 的新异常。
Exception(String message)
          构造带指定详细消息的新异常。
Exception(String message, Throwable cause)
          构造带指定详细消息和原因的新异常。
Exception(Throwable cause)
          根据指定的原因和 (cause==null ? null : cause.toString()) 的详细消息构造新异常（它通常包含 cause 的类和详细消息）。

thows 抛出异常

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

二、集合

list集合

特点，有序【存放时的顺序】、可重复、删除找到的第一个数据、线程不安全多线程访问的时候会出问题
还有个特点，查询快，增删改慢，效率高
java.awt.List List 组件为用户提供了一个可滚动的文本项列表。可设置此 list，使其允许用户进行单项或多项选择。
java.util
接口 List<E>
所有超级接口：
Collection<E>, Iterable<E>
List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，超过了 Collection 接口中指定的约定
List包含：ArrayList(){底层数据结构是数组、查询快、增删慢、线程不安全、效率高}、LinkedList(){底层数据结构是链表、查询慢、增删快、线程不安全、效率高}、Vector(){}

List //java.awt.List：做图形界面用的
public List()
throws HeadlessException创建新的滚动列表。默认情况下，有四个可视行，并且不允许进行多项选择。注意，这是 List(0, false) 的一种便捷方法。还要注意，列表中的可视行数一旦创建就不能更改。

抛出：
HeadlessException - 如果为 GraphicsEnvironment.isHeadless()，则返回 true。
另请参见：
GraphicsEnvironment.isHeadless()
--------------------------------------------------------------------------------
List
public List(int rows)
     throws HeadlessException创建一个用指定可视行数初始化的新滚动列表。默认情况下，不允许进行多项选择。注意，这是 List(rows, false) 的一种便捷方法。还要注意，列表中的可视行数一旦创建就不能更改。
参数：
rows - 要显示的项数。
抛出：
HeadlessException - 如果为 GraphicsEnvironment.isHeadless()，则返回 true。
从以下版本开始：
JDK1.1
另请参见：
GraphicsEnvironment.isHeadless()
--------------------------------------------------------------------------------
List
public List(int rows,
            boolean multipleMode)
     throws HeadlessException创建一个初始化为显示指定行数的新滚动列表。注意，如果指定了零行，则会按默认的四行创建列表。还要注意，列表中的可视行数一旦创建就不能更改。如果 multipleMode 的值为 true，则用户可从列表中选择多项。如果为 false，则一次只能选择一项。

参数：
rows - 要显示的项数。
multipleMode - 如果为 true，则允许进行多项选择；否则，一次只能选择一项。
抛出：
HeadlessException - 如果为 GraphicsEnvironment.isHeadless()，则返回 true。
另请参见：
GraphicsEnvironment.isHeadless()
方法详细信息
addNotify
public void addNotify()创建列表的同位体。同位体允许我们在不更改列表功能的情况下修改其外观。
覆盖：
类 Component 中的 addNotify

Map(双列集合)

A:Map集合的数据结构仅仅针对键有效，与值无关。
B:存储的是键值对形式的元素，键唯一，值可重复。

HashMap
     底层数据结构是哈希表。线程不安全，效率高
     哈希表依赖两个方法：hashCode()和equals()
     执行顺序：
               首先判断hashCode()值是否相同
               是：继续执行equals(),看其返回值
               是true:说明元素重复，不添加
               是false:就直接添加到集合

               最终：
                  自动生成hashCode()和equals()即可

LinkedHashMap
      底层数据结构由链表和哈希表组成。
      由链表保证元素有序。
      由哈希表保证元素唯一。

Hashtable
           底层数据结构是哈希表。线程不安全，效率高
               哈希表依赖两个方法：hashCode()和equals()
               执行顺序：
                           首先判断hashCode()值是否相同
                           是：继续执行equals(),看其返回值
                           是true:说明元素重复，不添加
                           是false:就直接添加到集合

                           最终：
                              自动生成hashCode()和equals()即可

TreeMap
       底层数据结构是红黑树。(是一种自平衡的二叉树)
       如何保证元素唯一性呢?
       根据比较的返回值是否是0来决定
       如何保证元素的排序呢?
       两种方式
       自然排序(元素具备比较性)
       让元素所属的类实现Comparable接口
       比较器排序(集合具备比较性)
       让集合接收一个Comparator的实现类对象

底层使用双线链表结构，数据结构
查询慢，增删快
线程不安全的，效率高

List list = new LinkedList();

Vector向量集合
线程安全
查询速度快，增删慢

set:无序不重复

特点：唯一
set.iterator 获取
特点，无序、不可重复
// HashSet 底层数据结构是哈希表。
// 哈希表依赖两个方法：hashCode()和equals()

LinkedHashSet
       // 底层数据结构由链表和哈希表组成。
       // 由链表保证元素有序。
       // 由哈希表保证元素唯一。

TreeSet
       // 底层数据结构是红黑树。(是一种自平衡的二叉树)
       // 如何保证元素唯一性呢?
       // 根据比较的返回值是否是0来决定
       // 如何保证元素的排序呢?
       // 两种方式
       // 自然排序(元素具备比较性)
       // 让元素所属的类实现Comparable接口
       // 比较器排序(集合具备比较性)
       // 让集合接收一个Comparator的实现类对象
       // 因为treeset是需要对数据进行比较的
       // 所以通常是同一种数据类型

public class LearnList {
public static void main(String[] args) {

List list = new ArrayList();
System.out.println("length-->" + list.size());

       System.out.println("==========================");
       // 添加数据
       list.add("张三丰");
       list.add(false);
       list.add("你吃了没");
       list.add(false);
       list.add(90.85f);
       list.add(false);
       System.out.println("==========================");

       System.out.println("length-->" + list.size());
       // 查询所有
       for (Object object : list) {
           System.out.println(object);
       }

       // 移除数据
       // 内部涉及到数组的元素的查找，和数组元素的移位
       // System.arraycopy(elementData, index+1, elementData, index,
       // numMoved);
       list.remove(false);

System.out.println("删除了false");
System.out.println("==========================");

       for (Object object : list) {
           System.out.println(object);
       }

System.out.println("==========================");

// 获取数据
System.out.println("length-->" + list.size());

Object obj = list.get(0);
System.out.println(obj);

}
}

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

三、文件

File类的使用：
JAVA.io.File类用于表示文件（目录）
File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问
File类的常用API：
1.创建File对象：File file=new File(String path);注意：File.seperater();获取系统分隔符，如：”\“.
2.boolean file.exists();是否存在.
3.file.mkdir();或者file.mkdirs();创建目录或多级目录。
4.file.isDirectory()或者file.isFile()判断是否是目录或者是否是文件。
5.file.delete();删除文件或目录。
6.file.createNewFile();创建新文件。
7.file.getName()获取文件名称或目录绝对路径。
8.file.getAbsolutePath()获取绝对路径。
9.file.getParent();获取父级绝对路径。
10.file.getSize();获取文件大小。
11.file.getFormat();获取文件格式名。

流一定是类，但类不一定是流
流是抽象类不能new对象
在 JAVA 中一个字符占两个字节：一个字节8bit

java.io包：通过数据流、序列化和文件系统提供系统输入和输出。
File类：文件和目录路径名的抽象表示形式。此类呈现分层路径名的一个抽象的、与系统无关的视图。

用户界面和操作系统使用与系统相关的路径名字符串来命名文件和目录。
抽象路径名有两个组件：
1.一个可选的与系统有关的前缀字符串，比如盘符，"/" 表示 UNIX 中的根目录，"\\\\" 表示 Microsoft Windows UNC 路径名。
2.零个或更多字符串名称的序列。
路径名字符串与抽象路径名之间的转换与系统有关。

file.separator：抽象路径名转换为路径名字符串时，引入分隔符
public static final String separator
与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。此字符串只包含一个字符，即 separatorChar。
public static final char separatorChar
与系统有关的默认名称分隔符。此字段被初始化为包含系统属性 file.separator 值的第一个字符。在 UNIX 系统上，此字段的值为 '/'；在 Microsoft Windows 系统上，它为 '\\'。

getMessage()方法：//java.lang.Throwable.getMessage()
getMessage
public String getMessage()返回此 throwable 的详细消息字符串。

返回：
此 Throwable 实例（可以为 null）的详细消息字符串。

1.printStackTrace()方法：无参//java.lang.Throwable.printStackTrace()
                                   将此 throwable 及其追踪输出至标准错误流。
                                    此方法将此 Throwable 对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。
2.printStackTrace()方法：有参
                                   public void printStackTrace(PrintStream s)将此 throwable 及其追踪输出到指定的输出流。
                                   参数：
                                   s - 用于输出的 PrintStream
                                   --------------------------------------------------------------------------------
3.printStackTrace
                                   public void printStackTrace(PrintWriter s)将此 throwable 及其追踪输出到指定的 PrintWriter。
                                   参数：
                                   s - 用于输出的 PrintWriter
                                   从以下版本开始：
                                   JDK1.1
                                   --------------------------------------------------------------------------------

代码部分：
                （1）定义一个文件，创建一个文件，处理异常（该文件在本地磁盘可删）
                                       public static void main(String[] args){
                                           File file=new File("E:/java.text");//定义为文件夹或文件
                                           try {
                                               file.createNewFile();//定义文件
                                           } catch (IOException e) {

                                               System.out.println("创建失败！"+e.getMessage());
                                               //e.printStackTrace();//打印栈里面
                                           }

                （2）输入输出字节流的代码：

                                                   public static void main(String[] args) {

                                                           File file=new File("E:/java.txt");//声明创建文件
                                                           try {
                                                               file.createNewFile();//创建文件

                                                               //写入
                                                               OutputStream OS=new FileOutputStream(file);//文件输出流[OutputStream]写入数据
                                                               String data="hard work!";//字符串
                                                               byte[] data1=data.getBytes();//字符串转换成字节流
                                                               OS.write(data1);//写入的是字节流
                                                               OS.close();//关闭字节流流出

                                                               //读出
                                                               InputStream IS=new FileInputStream(file);
                                                   //           long len= file.length();
                                                   //           int len2=(int)len;
                                                   //           byte len3=(byte)len2;
                                                   //           byte a[] =new byte[len3];
                                                               //简写
                                                               byte a[]=new byte[(int)file.length()];
                                                               IS.read(a);//读出字节流
                                                               //IS.close();
                                                               String str=new String(a);
                                                               System.out.println(str);
                                                           } catch (IOException e) {
                                                               System.out.println("创建成功！OK"+e.getMessage());
                                                               //e.printStackTrace();
                                                           }catch (Exception e) {
                                                               System.out.println("写入成功！"+e.getMessage());
                                                           }
                                                           //InputStream input=new FileInputStream(file);

                                                       }
                                                   }
                   （3）导入IO.jar架包简化代码：

                   （4）文件输入输出流相关：
                                                                   public static void main(String[] args){


                                                                           //创建文件对象
                                                                           File file = new File("E:/File.java");
                                                                           try {
                                                                               file.createNewFile();
                                                                           } catch (IOException e) {
                                                                               System.out.println("创建成功！"+e.getMessage());
                                                                               //e.printStackTrace();
                                                                           }
                                                                           System.out.println("文件名称:" + file.getName());
                                                                           System.out.println("文件是否存在：" + file.exists());
                                                                           System.out.println("文件的相对路径：" + file.getPath());
                                                                           System.out.println("文件的绝对路径：" + file.getAbsolutePath());
                                                                           System.out.println("是否为可执行文件：" + file.canExecute());
                                                                           System.out.println("文件可以读取：" + file.canRead());
                                                                           System.out.println("文件可以写入：" + file.canWrite());
                                                                           System.out.println("文件上级路径：" + file.getParent());
                                                                           System.out.println("文件大小：" + file.length() + "B");
                                                                           System.out.println("文件最后修改时间：" + new Date(file.lastModified()));
                                                                           System.out.println("是否文件类型：" + file.isFile());
                                                                           System.out.println("是否为文件夹：" + file.isDirectory());

                                                                       }
                   （5）文件输入输出流的研究代码：
                                                                           import java.io.File;
                                                                              import java.io.IOException;

                                                                              public class FileDemo {

                                                                                  /**
                                                                                   * @param args
                                                                                   */
                                                                                  public static void main(String[] args) {
                                                                                     // 了解构造函数的情况查帮助ALT+/
                                                                                     File file = new File("E:\\javaio\\imooc");
                                                                                     // 判断文件/文件夹是否存在
                                                                                    // System.out.println(file.exists());
                                                                                     if (!file.exists())
                                                                                         file.mkdir(); // file.mkdirs()如果文件不存在，直接创建文件夹
                                                                                     // mkdir创建的一级目录，如果需要创建多级目录可以使用mkdirs()
                                                                                     else
                                                                                         file.delete();

                                                                                     // 是否是一个目录如果是目录返回true,如果不是目录or目录不存在返回的是false
                                                                                     System.out.println(file.isDirectory());
                                                                                    // 是否是一个文件
                                                                                     System.out.println(file.isFile());

                                                                                     // File file2 = new File("e:\\javaio\\日记1.txt");
                                                                                     File file2 = new File("e:\\javaio", "日记1.txt");
                                                                                     if (!file2.exists())
                                                                                         try {
                                                                                             file2.createNewFile();
                                                                                         } catch (IOException e) {
                                                                                             // TODO Auto-generated catch block
                                                                                             e.printStackTrace();
                                                                                         }
                                                                                     else
                                                                                         file2.delete();
                                                                                     // 常用的File对象的API
                                                                                     System.out.println(file);// file.toString()的内容
                                                                                     System.out.println(file.getAbsolutePath());
                                                                                     System.out.println(file.getName());
                                                                                     System.out.println(file2.getName());
                                                                                     System.out.println(file.getParent());
                                                                                     System.out.println(file2.getParent());
                                                                                     System.out.println(file.getParentFile().getAbsolutePath());
                                                                                 }

                                                                           }

ACE1125

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
浅谈：java中的异常、集合以及文件File

目录一、Exception 基类/父类二、集合 list集合 Map(双列集合) set:无序不重复三、文件一、Exception 基类/父类java.io.IOException：当发生某种 I/O 异常时，抛出此异常。此类是失败或中断的 I/O 操作生成的异常的通用类。构造方法摘要IOException(...
复制链接

扫一扫