异常

1.概念

• 程序发生了不正常的情况

2.throwable类型

1.编译时异常Error

• 一般指语法错误，根据编译器提示改正

2.运行时异常Exception

• 受检异常

   编译器提出对异常的处理
   常见受检异常
   	ClassNotFoundException
   	IOException
   	SQLException
   	FileNotFoundException
  

• 非受检异常

   代码不需要强制进行捕获处理
   常见非受检异常
   	RuntimeException
   	NullPointerException
   	IndexOutOfBoundsException
   	ArrayIndexOutBoundsException
   	StringIndexOutOfBoundsException
  

3.所有异常的父类是Throwable类

• Throwable -> Exception/Error

3.try{}catch(){}

1.格式

try{
	一行也可以多行
}catch(异常类型 变量名){
	提示语句
}

• try:监控有可能异常的代码块
  try块中一旦发现异常直接跳出try块
• catch:捕获指定异常类型对象
• getMessage() 输出错误
• printStackTrace() 获取红色报错信息
• try{}catch{}会增加额外的开销

4.finally

• 无论try/catch发生什么 finally块一定会执行

• 必须执行的代码块 如：关闭资源（先要判断该资源是否为空）

• 应用情景
  当异常发生时，程序可能会意外中断，有些被占用的资源得不到清理

• 注意
  1.finally必须和try块一起使用，不能单独存在
  2.finally也可以在return后执行

5.throws

• 在方法中不对检查异常进行处理(catch块)此时就必须抛出方法外，交给主调函数处理(try-catch)

   主调函数：调用此函数的方法
  

• 格式：throws 异常类名

• 注意
  必须跟在方法的括号后
  尽量不要再main方法上抛出异常
  将异常抛出方法之外

6.throw

• 在方法中手动抛出异常
• 格式：throw 异常对象
• 注意
  必须对异常进行处理
  处理方式一：try-catch
  处理方式二：throws抛出异常

7.用户自定义异常

8.异常类的继承结构体系

• 异常的基类为Exception，所有异常都必须直接或者间接继承它

• Exception被大多数异常继承

• 大多数异常没有重写方法

9.常见异常类型

• Exception 异常结构层次的根类

• RuntimeException 许多Java.lang异常的基类

• ArithmeticException 算数异常

• IllegalArgumentException 方法接收到非法参数

• ArrayIndexOutOfBoundsException 数组下标越界

• NullPointerException 访问空引用

• ClassNotFoundException 不能加载所需的类

• ClassCastException 类型转换异常

• NumberFormatException 字符串转数字失败或数字格式化异常

• IOException I/O异常的根类

• FileNotFoundException 找不到文件

• EOFEException 文件结束

10.JDBC编程的异常类型

• SQLException
• SQLWarning

java.lang

注意：基础包–所以无需显示导包

1.包装类

1.概述

• 为了对基本数据类型进行更多更方便的操作，Java针对每种基本类型提供了对应的类类型

2.boolean–Boolean
3.byte–Byte
4.char–Character

• 构造方法

   public Character(char value)
  

• 成员方法

   public static boolean isUpperCase(char ch)
   	判断给定的字符是否是大写字符
   public static boolean isLowerCase(char ch)
   	判断给定的字符是否是小写字符
   public static boolean isDigit(char ch)
   	判断给定的字符是否是数字字符
   public static char toUpperCase(char ch)
   	将给定的字符转换为大写字符
   public static char toLowerCase(char ch)
   	将给定的字符转换为小写字符
  

5.short–Short
6.int–Integer

Integer a3 = 100;//自动装箱：基本数据类型转换成包装类对象 int i =
a3;//自动拆箱：将包装类对象拆成一个基本数据类型

• 字段摘要

   public static final int MAX_VALUE
   	获取int类型最大值
   public static final int MIN_VALUE
   	获取int类型最小值
  

• 构造方法

   public Integer(int value)
   public Integer(String s)
   	注意：这个字符串必须由数字字符组成
  

• 成员方法

   进制转换
   	基本进制转换
   		public static String toBinaryString(int i)
   		public static String toOctalString(int i)
   		public static String toHexString(int i)
   	十到其他进制
   		public static String toString(int i,int radix)
   	其他到十进制
   		public static int parseInt(String s,int radix)
   类型转换
   	public static int parseInt(String s)
   		将字符串类型转换成整形
   保存值
   	public static Integer valueOf(String s)
   		返回保存指定的 String 的值的 Integer 对象
   	public static Integer valueOf(String s,int radix)
   		返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值
   	public static Integer valueOf(int i)
   		返回一个表示指定的 int 值的 Integer 实例
  

7.long–Long
8.float–Float
9.double–Double

2.自动拆装箱

• 自动装箱：将基本类型转换成包装类型

• 自动拆箱：将包装类型转换成基本类型

Integer i = new Integer(100);
Integer i = 100;(自动装箱)不会报错
i += 100；(自动拆箱)也不会报错
注意：i不等于null,否则报错(空指针异常)建议加入if语句判断

3.String类

字符串：可看成是字符数组

1.String API

• 字符串字面值"abc"也可以看成是一个字符串对象

• 字符串是常量，一旦赋值就不能改变（注意理解）

   String s = "hello";
   s += "world";  //+=字符串拼接
   问：s的结果是多少？
   结果：helloworld
   
   String s = "hello";
   	在栈中有String s
   	在方法区中字符串常量池寻找"hello"，若有则直接返回，若没有则创建一个"hello"
   	方法区中"hello"的地址给栈中String s
   s += "world";
   	由于s的值不能被改变，在方法区中找"world",没有则新创建一个"world"，但此无意义
   	在方法区又创建一个新空间，将helloworld拼接起来，又将此空间的地址值付给String s
  

• 值不能变而不是引用

2.构造方法

  public String()
	无参构造
  public String(byte[] bytes)
	将字节数组转成字符串
  public String(byte[] bytes,int offset,int length)
	将字节数组的一部分转成字符串
  public String(char[] value)
	将字符数组转成字符串
  public String(char[] value,int offset,int count)
	将字符数组的一部分转成字符串
  public String(String original)
	将字符串常量值转成字符串

3.方法

• 判断功能

  boolean equals(Object obj)
   比较字符串内容是否相同，区分大小写
  boolean equalsIgnoreCase(String str)
   比较字符串内容是否相同，忽略大小写
  boolean contains(String str)
   判断大字符串中是否包含小字符串，注意字符串是一个整体
  boolean startsWith(String str)
   判断字符串是否以某个指定的字符串开头
  boolean endsWith(String str)
   判断字符串是否以某个指定的字符串结尾
  boolean isEmpty()
   判断字符串是否为空
  

注意
1.字符串内容为空：指对象存在但无内容

String s = “”; s可以调用对象

2.字符串对象为空：指对象都不存在

String s = null; s不可调用

• 获取功能

  int length()
   获取字符串长度
  char charAt(int index)
   获取指定索引位置的字符
   第一个元素的索引是0
  int indexOf(int ch)
   获取指定字符在此字符串中第一次出现的索引
   为什么是int类型而不是char类型？'a'和97都可以代表a
  int indexOf(String str)
   获取指定字符串在此字符串中第一次出现的索引
  int indexOf(int ch,int fromIndex)
   获取指定字符在此字符串中从指定位置后第一次出现的索引
  int indexOf(String str,int fromIndex)
   获取指定字符串在此字符串中从指定位置后第一次出现的索引
  String substring(int start)
   从指定位置开始截取字符串，默认到末尾
  String substring(int start,int end)
   从指定位置开始到指定位置结束截取字符串 包左不包右
  

• 转换功能

  byte[] getBytes()
   将字符串转换为字节数字
  char[] toCharArray()
   将字符串转换为字符数组
  static String valueOf(char[] chs)
   将字符数组转成字符串
  static String valueOf(int i)
   将int类型的数据转成字符串
    注意：String类的valueOf方法可以将任意类型的数据转成字符串
  String toLowerCase()
   将字符串转成小写
  String toUppweCase()
   将字符串转成大写
  String concat(String str)
   将字符串拼接  +其实也可以拼接
  

• 其他功能

  替换功能
    String replace(char old,char new)
    String replace(String old,String new)
  去除字符串两端的空格
    String trim()
  按字典顺序比较两字符串
    int compareTo(String str)
   	区分大小写
    int compareToIgnoreCase(String str)
   	不区分大小写
   一个个字符按顺序比较，若相同接着比下一个，若完全相同返回0；若不同则不同的字符相减，返回相减后的值
  

4.StringBuffer类

1.作用：解决对字符串每次拼接都要建立一个String类耗时废空间的问题

• 不能直接将String类型的值赋给StringBuffer

2.线程安全

• 安全 ——同步

  我在操作时，别人不能操作（银行取钱）
  数据安全

• 不安全 ——不同步
  效率高，新闻，论坛之类的

3.StringBuffer与String的区别

• StringBuffer:线程安全的可变字符串，即长度内容可变

• String:长度内容不可变

4.构造方法

public StringBuffer()
	无参构造方法
public StringBuffer(int capacity)
	指定容量的字符串缓冲区对象
public StringBuffer(String str)
	指定字符串内容的字符串缓冲区对象

5.方法功能

• 添加功能

   public Stringbuffer append(String str)
   	字符串缓冲区是为了提高字符串的操作效率 
   	将任意的类型添加到字符串缓冲区里，并返回字符串缓冲区本身
   public Stringbuffer insert(int offset,String str)
   	在指定位置将任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身
  

• 删除功能

   public StringBuffer deleteCharAt(int index)
   	删除指定位置的字符（一个），并返回本身
   public StringBuffer delete(int start,int end)
   	删除从指定位置开始到指定位置结束的内容，并返回本身
   	包左不包右
  

• 替换功能

   public StringBuffer replace(int start,int end,String str)
   	从指定位置开始到指定位置结束间的字符串被str替换
   	包左不包右
  

• 反转功能

   public StringBuffer reverse()
   	输入abc,输出cba
  

• 截取功能

   public String substring(int start)
   public String substring(int start,int end)
   注意返回值类型是String类型,即不改变创建的StringBuffer对象的内容
  

6.面试题

• String,StringBuffer,StringBuilder的区别

   String是内容不可变的，StringBuffer,StrignBuilder都是内容可变的
   StringBuffer是同步的，数据安全，效率低；StringBuilder不同步，数据不安全，效率高
  

• StringBuffer和数组的区别

   StringBuffer的数据最终是一个字符串数据
   数组可以放置多种数据，但必须是同一数据类型
   在不考虑多线程的情况下StringBuilder应用更加广泛
  

5.StringBuilder类

• 线程不安全

6.类间转换

1.String与StringBuffer间的转换

• 为什么要转换

  A–B 为了使用B的功能
  B–A 结果是A类型所以转回来

• 不能将字符串的值直接付给StringBuffer
  StringBuffer s = “hello”; 错

• 实现转换

  S–SB
  方式一：通过构造方法
  Sreing s = “hello”
  StringBuffer sb = new StringBuffer(s)
  方式二：通过append()方法
  Sreing s = “hello”
  StringBuffer sb = new StringBuffer()
  sb.append(s)

  SB–S
  方式一：通过构造方法
  StringBuffer buffer = new StringBuffer(“java”)
  String str = new String(buffer)
  方式二：通过toString()方法
  StringBuffer buffer = new StringBuffer(“java”)
  String str = buffer.toString()

2.String与int间的转换

• i–S

  方式一
  int number = 100;
  String s = “” + number;
  方式二
  int number = 100;
  String s = String.valueOf(number);
  方式三：int–Integer–String
  int number = 100;
  Integer i = new Integer(number);
  String s = i.toString();
  方式四
  int number = 100;
  String s = Integer.toString(number);

• S–i

  方式一：String–Integer–int
  String s = “100”;
  Integer i = new Integer(s);
  int x = i.intValue();
  方式二
  String s = “100”;
  int y = Integer.parseInt(s);

7.Object类

1.说明

• 所有的类都直接或间接的继承自Object类

• Object类的构造方法只有一个，且是无参构造

• 注意其中方法的使用

• native本地的 不通过Java实现

2.要掌握的方法

public String toString()
	返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示
	这个表示是没有意义的，所以一般子类都会重写该方法
public boolean equals(Object obj)
	作用：比较两个对象是否相同，默认情况下，比较的是地址值是否相同，而String类型比较的是字符串内容是否相同
	但比较地址值是没有意义的，所以一般子类会重写该方法
	当此方法被重写时，hashCode也有必要重写
public int hashCode()
	返回对象的哈希值，不是实际地址值，但可以理解为地址值
	注意：哈希值是根据哈希算法计算出来的一个值，该值与地址有关

• 同一个对象没必要总创建 —— 这时需要重写hashCode() equals()

3.要了解的方法

public final Class getClass()
	返回对象的字节码文件对象
protected void finalize()
	作用：用于垃圾回收，在不确定的时间
protected Objectclone()
	可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的

4.注意

• 直接输出一个对象名称，其实默认调用了该对象的toString()方法

• ==与equals()的区别

   ==
    基本类型：比较的是值是否相同
    引用类型：比较的是地址值是否相同
   equals()
    只能比较引用类型，默认情况下比较的是地址值是否相同，但可根据自己的需要重写该方法
  

8.Math类

1.概述：包含基本数学运算的方法

2.成员变量

public static final double PI
public static final double E

3.成员方法

public static int abs(int a)
	绝对值
public static double cell(double a)
	向上取整
public static double floor(double a)
	向下取整,小数部分取0
public static int max(int a,int b)
	最大值
public static int min(int a,int b)
	最小值
public static double pow(double a,double b)
	a的b次幂
public static double random()
	随机数[0.0,1.0）
public static int round(float a)
	四舍五入
public static int round(double a)
	四舍五入
public static double sqrt(double a)
	正平方根

9.Class类

1.概念：Class类实例表示正在运行的Java应用程序中类和接口

2.无公共构造方法

• Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的
• 每一个在运行的类都会有一个Class实例的存在，该实例由虚拟机获取

3.获取XXXXX

• 获取某类的Class实例
  方法一：反射 Class.forName()
  方法二：对象名.getClass()
  方法三：类名.class

• 获取到继承关系 getSuperClass()

• 获取所有公共字段getFields()

• 获取所有字段（包括私有）getDeclaredFields()

• 获取所有方法getDeclaredMethods()

4.创建对象

• newInstance()

5.激活

• invoke()

10.System类

1.概述：包含一些有用的类字段和方法，不能被实例化
2.成员方法

public static void gc()
	运行垃圾回收器
public static void exit(int atatus)
	终止当前正在运行的虚拟机
	参数用作状态码
		非0表示异常终止
		0表示正常
public static long currentTimeMillis()
	返回以毫秒为单位的当前时间
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
	从指定源数组中复制一个数组，复制从指定位置开始，到目标数组的指定位置结束

java.util

注意：工具包–必须要导包

1.Random类

1.概述：用于产生随机数

2.构造方法

public Random()
	没给种子，用的是默认的种子，是当前种子的毫秒值，即每次的种子不同
public Random(long seed)
	给出指定的种子

3.成员方法

public int nextInt()
	返回的是int范围内的随机数
public int nextInt(int n)
	返回的是[0,n)范围内的随机数

2.Scanner类

1.基本格式

public boolean hasNextXXX()
	判断是否还有下一个输入项 XXX代表类型
	若需要判断是否包容下一个字符串可省XXX
public XXX nextXXX()
	获取下一个输入项 XXX含义上同
为使程序更加严谨，用此法，但平常的写法也可

• 默认情况下Scanner使用空格 回车等作为分隔符

2.常用方法

public int nextint()
	获取int值
public String nextine()
	获取字符串

3.注意

• 使用同一sc获取值时，若先获取一个int在获取一个String则String类型则会被int输入完后的回车键所替代

• 解决办法

   创建两个不同的sc
   (推荐)将所有的数据都按字符串获取，然后需要什么类型在强制类型转换即可
  

3.Date类

1.概述：表示特定的瞬间，精确到毫秒

2.构造方法

public Date()
	根据当前的默认毫秒值创建日期对象
public Date(long date)
	根据给定的毫秒值创建日期对象
	应用场景：文件最后修改时间获取的是毫秒数 需要通过构造函数创建日期对象

3.成员方法

public long getTime()
	获取时间，以毫秒为单位
public void setTime(long time)
	设置时间

4.将一个毫秒值转换为Date

1.构造方法
2.setTime(long time)

4.DateFormat类

1.概述：进行日期和字符串的格式化和解析，但是抽象类，所以使用具体子类SimpleDateFormat

2.SimpleDateFormat的构造方法

SimpleDateFormat()
	默认模式
	线程不安全
SimpleDateFormat(String pattern)
	给定模式
	SimpleDateFormat("yyyy-MM-dd hh:mm:ss E")

3.SimpleDateFormat的方法

format(Date date)
	将一个 Date 格式化为日期/时间字符串
parse(String s)
	解析字符串的文本，生成 Date
	进行解析时，字符串格式必须和SimpleDateFormat(String pattern)中的模式相匹配

5.Calendar类

1.概述：为特定瞬间和一组形如YEAR DAY_OF_MONTH等日历字段之间的转换提供方法

2.Calendar c = Calendar.getInstance();//不可以直接new，必须调用此方法创建实例对象

3.成员方法

public void set(int field,int value)
	field - 给定的日历字段
	value - 给定日历字段所要设置的值
public int get(int field)
	返回给定日历字段的值
	日历类中每个日历字段都是静态成员变量，并且是int类型
public void add(int field,int amount)
	为给定的日历字段添加或减去指定的时间量
		c.add(Calendar.YEAR, 2);
		c.add(Calendar.YEAR, -4);

6.Arrays类

1.概述：针对数组进行操作的工具类

2.成员方法

public static String toString(int[] a)
	将数组转成字符串
	搭配输出语句可输出数组元素
	转换后变成字符串变成[元素1,元素2,...]的样子
public static void sort(int[] a)
	对数组排序
	按首字母ASCLL码
public static void sort(Object[] a)
	对对象数组进行排序
	数组中的所有元素都必须实现 Comparable 接口
	Students []s = new Students[5];
    Arrays.sort(s);//数组中的所有元素都必须实现 Comparable 接口

Students implements Comparable{
	重写compareTo方法
}

public static int binarySearch(int[] a,int key)
	二分查找
public static <T> List <T> asList(T...s)
	将数组转成集合

7.泛型

1.概念：将类型明确工作推迟到创建对象或者调用方法时的特殊类型

2.格式：<引用数据类型> – 就是

3.好处

• 将运行时期的问题提前到了编译期间

• 避免了强制类型转换

• 优化了程序设计，解决黄色警告线问题

4.应用

• 泛型类

   格式：public class 类名<泛型类型1,...>
   注意：泛型类型必须是引用类型
  

• 泛型方法

   格式：public <泛型类型> 返回类型 方法名(泛型类型1,...)
  

• 泛型接口

   格式：public interface 接口名<泛型类型1,...>
  

5.泛型高级之通配符

• <?>

   任意类型 若未明确则就是Object以及任意的Java类
  

• <? extends E>

   向下限定 E及其子类
  

• <? super E>

   向上限定 E及其父类
  

8.Collection集合

1.概念：集合存在的意义和数组差不多

2.数组和集合的差别

• 长度区别

   数组长度固定
   集合长度可变
  

• 内容不同

   数组存的是同一类型的元素
   集合可以存的不同类型的元素
  

• 存的元素的数据类型不同

   数组可以存基本数据类型，也可存引用数据类型
   集合只能存引用数据类型
  

3.Collection功能概述

• 先创建对象

   Collection A = new ArrayList()
   注意直接输出语句一个A，可以将集合中的元素都输出
  

• 添加功能

   boolean add(Object obj)
   	添加一个元素
   boolean addAll(Collection c)
   	添加一个集合的所有元素
  

• 删除功能

   void clean()
   	移除所有元素
   boolean remove(Object o)
   	移除一个元素
   boolean removeAll(Collection c)
   	移除一个集合的元素，只要有一个被移除了就是移除
  

• 判断功能

   boolean contains(Object o)
   	判断集合中是否包含指定元素
   boolean containsAll(Collection c)
   	判断集合中是否包含指定的集合元素，只有包含所有的元素才叫包含
   boolean isEmpty()
   	判断集合是否为空
  

• 获取功能（迭代器）

   Iterator<E> iterator()
   	集合的专用的遍历方式
   	迭代器是依赖集合而存在的，要先创建集合再使用迭代器
   	方法
   		Object next()
   			获取元素，并移动到下一个元素，即下一次再使用它获取元素时获取的就是下一个元素了
   			不要多次使用it.next()方法
   		hasNext()
  

• 长度功能

   int size()
   	元素的个数
   面试题
   	数组有没有length()方法？
   	字符串有没有length()方法？
   	集合有没有length()方法？
  

• 交集功能

   boolean retainAll(Collection c)
   	取你有我也要的元素被保存到调该方法的对象中即.的左边
   	假设有两个集合AB，A对B做交集即A.retainAll(B)，最终的结果保存在A中，B不变
   	返回值表示的是A是否发生过改变
  

• 将集合转换为数组

   Object[] toArray()
   	形式：Object[] obj = A.toArray()
   	可将集合转成数组再实现遍历
   	注意
  

• 集合类中 Collection 是集合最顶层的接口

4.使用集合的步骤

• 创建集合对象

• 创建元素对象

• 将元素添加到集合

• 遍历集合

   通过集合对象获取迭代器对象
   通过迭代器对象hasNext()方法判断是否有元素
   通过迭代器对象的next()方法获取元素并移动到下一个位置
  

5.Collection的儿子–List&Set

• List
  1.List集合的特点：有序（存储和取出的元素一致）+ 可重复
  2.List特有功能

（1） 添加功能 void add(int index,Object element)
在指定位置添加元素,在index后加上该元素
注意index不要越界
（2）获取功能 Object get(int index)
获取指定位置的元素
（3）列表迭代器 ListIterator listIterator()
List集合特有的迭代器
（4）删除功能 Object remove(int index)
根据索引删除元素,返回被删除的元素
（5）修改功能 Object set(int index,Object element)
根据索引修改元素，返回被修改的元素

3.ListIterator接口的成员方法

（1）boolean hasPrevious()
判断是否有元素
（2）Object previous()
获取上一个元素
（3）注意：ListIterator可以实现逆向遍历，但必须先正向遍历，才可逆向遍历，所以一般无意义不不使用，但它的方法比Iterator多，且Iterator不可以实现逆序，列表迭代器，但一般不使用该迭代器

• Set
  1.Set集合的特点
  无序（存储和取出的元素不一致）
  虽然无序，但他有他自己的顺序，注意输出顺序正好与其输出顺序一致的情况
  唯一(不可重复)

6.List的儿子

• ArrayList

（1）底层结构是对象数组，查询快，增删慢
（2）线程不安全（不同步），效率高
（3）1.5倍扩容
（4）方法
add(T t)
get(int index)
remove(int index)
isEmpty()
clear()
size()

• Vector

（1）底层结构是数组，查询快，增删慢
（2）线程安全（同步），效率低
（3）2倍扩容
（4）特有功能
添加功能
public void addElement(Object obj)——add()替代
获取功能
public Object elementAt(int index)——get()替代
public Enumeration elements()——Iterator iterator()替代
boolean hasMoreElements()——hasNext()替代
Object nextElement()——next()替代

• LinkedList

（1） 底层结构是双链表，查询慢，增删快
（2）线程不安全，效率高
（3） 特有功能
添加功能
public void addFirst(Object e)
public void addLast(Object e)
获取功能
public Object getFirst()
public Object getLast()
删除功能
public Object removeFirst()
public Object removeLast()

7.Set的儿子——HashSet类

• 无序
• 遍历输出不可以使用for循环(无序)，但增强for循环可以
• 创建一个数组存储元素，元素除元素总数的余数是几就存储到索引为几的数组中
• 哈希冲突

概念：该地址上已有东西，又有一个要存进来
拉链法 完全避免哈希冲突 冲突后直接存储在该数组已有元素的后面，建立一个单链表

8.静态导入

格式：import static 包名.类名.方法名

可直接导到方法级别

• 注意

   方法必须是静态的
   若有多个同名静态方法，则不知道使用谁
  

9.可变参数

• 使用：在定义方法却不知道该定义多少个参数时

格式：修饰符 返回值类型 方法名(数据类型…变量名){}

• 注意

   此变量其实是数组
   若一个方法有可变参，并且有多个参数，那可变参放在最后一位
  

9.Map<k,v>键值对

键不能重复，一个键(k)对应一个值，值(v)可以重复
1.子类HashMap

• 线程不安全

• put(K,V)

(1)size()
(2)获取所有键值：Set set = map.keySet();
(3)获取所有值：Collection col = map.values();
(4)获取键值对映射的Set视图集合：Set<Map.Entry<Integer, Student>> entrys =
map.entrySet()

for(Map.Entry<Integer, Student> m:map.entrySet()){
 	System.out.println(m.getKey()+" "+m.getValue()); 
} 

允许一次性插入键和值

• 其键值都可以为null
• 子类依靠hashCode(),equals()找出重复元素

2.子类HashTable

• 线程安全
• Hashtable.keySet() 降序
• Properties

load() 从文件输入流中加载配置信息
store() 保存到文件输出流中
getProperty()
setProperty(key,value) 添加键值

• 键值都不可以为null

3.子类TreeMap

• TreeMap.keySet() 升序
• 默认排序

java.io

数据永久存储

1.File类

File 类的实例是不可变的；也就是说，一旦创建，File 对象表示的抽象路径名将永不改变

1.字段

• 路径分隔符；

   pathSeparator
   pathSeparatorChar
  

• 名称分隔符\

   separator
   separatorChar
  

2.构造函数

File(String parent,String child)
File(File parent,String child)
File(String name)

3.方法

获取
	获得文件名称
		getName()
	获得路径名称
		getPath()
	获得绝对路径名称
		getAbsolutePath()
	返回父路径
		getParent()
	父对象
		getParentFile().getName()
判断文件状态
	不存在
		exists()
	存在
		文件
			isFile()
		文件夹
			isDirectory()
其他
	文件字节数
		length()
	创建文件
		注意：不存在才创建
		createNewFile()

File src=new File("D:/java/workspace/D1/io.txt");
boolean flag= src.createNewFile();

	删除已存在的文件
		delete()
创建目录
	mkdir()
		若上级目录不存在则创建失败
	mkdirs()
		若上级目录不存在则一同创建
列出
	列出下级名称
		list()
			bin
	列出下级File对象
		listFile()
			D:\java\workspace\D1\bin
	列出所有盘符
		(static)listRoots()
			D:\
	字符串数组接收

dir=new File("D:/java/workspace/D1");
String [] subNames=dir.list();

2.字节流

1.概念：以字节(8位)为单位从流(stream)读取或写入数据，通常用来处理二进制文件

2.InputStream字节输入流

• 抽象类
• 作用：将数据一个字节一个字节的读取到内存
• 常用方法

（1） available() 返回输入流中可读取的字节数量的估值
（2）close() 关闭此输入流并释放与此流相关的系统资源
（3）(abstract)read() 从当前位置输入流中读取下一个字节的数据
（4） read() 从输入流中读取数据的下一个字节
（5） read(byte []b) 从当前位置输入流读取 b.length字节数据并将它们存储到字节数组b中
（6）read(byte []b,int off,int len) 从当前位置读取len个字节的数据存放发到b中，从b[off]开始 write(byte []b,int off,int len)

• 子类

（1）AudioInputStream（音频输入流）
（2）ByteArrayInputStream(字符数组输入流)
（3） FileInputStream(文件输入流) 负责对本地磁盘文件顺序输入操作的流
构造方法 （File file）+（String name）
（4） FilterInputStream(过滤器输入流)
（5）ObjectInputStream(对象输入流)
（6）DataInputStream(基本数据类型输入流)
（7）PipedInputStream（管道输入流）
（8）SequenceInputStream(顺序输入流) 将多个顺序链接在一起，形成单一的输入数据流
（9）StringBufferdInputStream(带缓存的字符串输入流)

3.OutputStream字节输出流

• 抽象类
• 作用：将数据一个字节一个字节的写入到文件或网络中
• 常用方法

（1）close() 关闭此输出流并释放与此流相关的系统资源
（2） flush() 刷新此输出流并强制将缓冲的字节数据被写入到目标设备
（3） write(byte []b) 将b的数据全部邪恶如到输出流中
注意：只是写入到流中，若要写入到目标设备还要用flush()
（4）write(byte []b,int off,int len) 从指定的字节数组写入len字节，从偏移量off开始输出到此输出流

• 子类

(1)ByteArrayOutputStream(字节数组输出流)
(2) FileOutputStream(文件输出流)
负责对本地磁盘文件顺序输出操作的流
构造方法
注意：若有该文件则清空该文件，若无该文件则创建该文件
创建文件输出流写入指定的File对象表示的文件（File file）
创建文件输出流写入指定的名称写入文件（String name）默认覆盖原有内容
(String name,boolean append)
true:不覆盖原有内容
false：覆盖原有内容
(3)FilterOutputStream(过滤器输出流)
(4)ObjectOutputStream(对象输出流)
(5)DataOutputStream(基本数据类型输出流)
(6) PipedOutputStream(管道输出流)

3.字符流

1.概念：以字符(16位)为单位从流(stream)读取或写入数据，通常用来处理字符或字符串数据

2.Reader字符输入流

• 抽象类
• 作用：将数据一个字符一个字符的读取到内存
• 常用方法

（1）close() 关闭流并释放该流占用的所有资源
（2）read() 从流中读取单个字符
（3）read(char []c) 从当前位置读取c.length个字符数据并存储到c中
（4）(abstract)read(char []c,int off,int len)
从当前位置读取len个字符的数据存放发到c中，从c[off]开始 write(byte []b,int off,int len)

• 子类

（1）BufferedReader(带缓冲区的Reader) 高效
（2）InputStreamReader
（3） FileReader(文件Reader) 便捷类
（4）CharArrayReader(字符数组Reader)
（5）FilterReader(过滤器Reader)
（6）PipedReader(管道Reader)
（7） StringReader(字符串Reader)

3.Writer字符输出流

• 抽象类
• 作用：将数据一个字符一个字符的写入到文件或网络
• 常用方法

（1） append() 追加字符到此Writer流中，追加到尾部 追加字符序列到此Writer流中，追加到尾部
追加字符序列的子序列到Writer流中,子序列为序列的start到end部分，追加到尾部
（2）close()
关闭流，关闭之前先调用flush()
（3）flush() 刷新流，并将已在流中的数据写入指定目标设备
（4）write(char []c)
将字符数组写入流中
（5） (abstract)write(char []c,int off,int len)
将字符数组的指定部分写入流中，从off开始写入len个

• 子类

（1） BufferedWriter(带缓冲区的Writer)
（2） OutputStreamWriter 字符流通向字节流的桥梁
（3） FileWriter 便捷类
（4）CharArrayWriter(字符数组Writer)
（5） FilterWriter(过滤器Writer)
（6） OutputWriter(输出流Writer)
（7） PipedWriter(管道Writer)
（8）PrintWriter(打印Writer)
（9）StringWriter(字符串Writer)

4.相互转化

1.InputStream->Reader

• InputStreamReader

2.OutputStream->Writer

• OutputStreamWriter

5.ObjectIn/OutputStream

1.序列化

• 概念：将对象转化为字节序列

2.反序列化

• 概念：将字节序列恢复成对象

都要继承Serializable