java 常用的API
Scanner类
一个可以使用正则表达式来解析基本数据类型和字符串类型的简单文本扫描器
查看类
java.util.Scanner:需要导入java.util
查看构造方法
public Scanner(InputStream source);构造一个新的Scanner对象，他生成的值是从指定的输入流中扫描的
查看成员方法
public int nextInt():将输入的信息的下一个标记扫描为一个int类型值
Random类
此类的实例主要是用于生成伪随机数
查看类：
java.util.Random 该类导入才能使用
查看构造方法：
public Random();常见一个新的随机数生成器
查看成员方法：
public int nextInt(int n)返回一个伪随机整数，范围在[0 --- n-1]
public double nextDouble();返回一个伪随机小数，范围在[0.0 --- 1.0）
ArrayList类
java.util.ArrayList类是一个【大小可变的数组】的实现，里面存储的数据称为元素.该类提供了一些常用的api方法来操作内部存储的元素
ArrayList类的使用步骤：
查看类
java.util.ArrayList<E>:该类也是需要import导入后才能使用
查看构造方法：
public ArrayList();构造一个初始容量为10的空列表
public ArrayList(int initialcapacity)构造一个指定的初始容量的空列表；
查看成员方法：
public boolean add (E e)将指定的元素添加到此列表的尾部。
public void add(int index,E element)将指定的元素插入此列表中的指定位置。
public void clear()移除此列表中的所有元素。
public boolean contains(Object o) 如果此列表中包含指定的元素，则返回 true,否则返回false
public E get(int index) 返回此列表中指定位置上的元素。
public int indexOf(Object o) 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
public boolean isEmpty() 如果此列表中没有元素，则返回 true
public E remove(int index) 移除此列表中指定位置上的元素。
public E set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。
public int size()返回此列表中的元素数。
String类
java.lang.String类代表字符串，java程序中所有的字符串文字，如“abc”都可以看作是String类的实例.
程序当中的所有双引号字符串，都是String类的对象.（没有new，也是对象）.
创建String字符串的常见3+1种方式
三种构造方法
public String();创建一个空白的字符串，不包含任何内容.
public Stirng(Char[] array);根据字符数组的内容，来创建对应的字符串.
public Stirng(byte[] array);根据字节数组内容，来创建对应的字符串.
一种直接创建
String str = "abc";//右边直接用双引号
常用方法：【重点】
判断功能方法
public boolean equals(Object anObject);将此字符串与指定对象进行比较，（参数可以是任意值）
public boolean equalsIgnoreCase(String anObject);将此字符串与指定的对象进行比较，不考虑大小写
获取功能
public int length();返回字符串的长度
public String concat(String str);将指定的字符串连接到该字符串的末尾
public char charAt(int index);返回指定索引处的char值 索引起始值为0
public int indexOf(String str);返回指定的子字符串第一次出现在该字符串内的索引值"连续的"（返回-1就是没有）
public String substring(int beginIndex);返回一个子字符串，从beginIndex开始截取该字符串的末尾
新的字符串 World是新的字符串对象
public String substring(int beginIndex,int endIndex);返回一个子字符串，从beginIndex区间截取该字符串
包含beginIndex索引值,不包含endIndex索引值---》[beginIndex,int endIndex)
转换功能：
public char[] toCharArray();将此字符串转换成新的字符数组
public byte[] getBytes();适用平台默认的字符集将该字符串编码转换成新的字节数组.
public String replace(CharSequence oldString,CharSequence newString);
Arrays类
java.util.Arrays 此类主要是用来操作数组的，里面提供了很多的操作数组的API方法，如排序和搜索功能.
其所有的均为静态方法调用起来非常简单
操作数组的方法
1.public static Stirng toString(int[] arr);返回指定数组内容的字符串表示形式
2.public static void sort(int[] arr);对指定的int数组按照数字升序排序，从小到大
3.public static int binarySearch(int[] arr,int key);//使用二分搜索法来搜索指定的 int 型数组，以获得指定的值
此时key指的是要搜索的值，而方法返回值声明的int指的是搜索值对应的索引值.
备注：使用binarySearch()方法.搜索数组当中的元素时，数组必须是有序的.【升序】
得到的索引值是排序后的新数组的索引值
没有找到对应的元素值，得到的索引值是负值
4.public static void fill(int[] arr,int val);将指定的 int 值分配给指定 int 型数组的每个元素。填满
Math类
概述：
java.util.Math 包含了用于执行基本数学运算的方法，如：指数，幂次方，对数，平方根，三角函数等运算
里面的方法均是静态方法，并且也不需要创建对象，调用起来非常方便.
基本的运算方法
1.public static double abs(double a);返回double值的绝对值
2.public static double ceil(double a);返回大于等于参数的最小整数.往上取整
3.public static double floor(double a);返回小于等于参数的最小整数.往下取整
4.public static long round(double a);返回最接近参数的long类型值（四舍五入）负数（五舍六入）
Object类
java.lang.Object
类Object 是类结构层次的根类(父类)
每个类(Person,People,Student,Animal......String......)都是Object类的子类
所有对象(包括数组)都实现了Object类的方法
重写toString
Student student = new Student("小刘",20);
//打印这个student对象
System.out.println(student);
// com.zhiyou100.api.object.Student@15db9742逻辑地址值
// 简明但易于读懂的信息表达式
// 当重写之后，调用的就是重写之后的toString方法
// Student：{name = 小刘,age = 20}
// 当打印对象是，系统认为你是要查看该对象的成员信息，那必然调用toString()方法,
// 此时toString方法，可以省略不写，但是这个toString方法名不能改变
重写toString方法
直接打印对象产看的是这个对象表示的内存地址值是没有意思，我们想查看的是该对象中的信息
应该打印对象中的成员信息(name,age)
@Override
public String toString(){
return "Student：{"+"id = "+id+",name = "+ name +",age = "+ age+"}";
}
重写equals
Object类中的equals，默认比较是两个对象的地址值，没有意义
所以我们需要重写equals方法，比较两个对象的成员变量(name,age)
问题：
隐含一个多态
多态的弊端；无法使用子类独有的内容(属性和方法)
解决办法：向下转型
伴随着转型失败 可能会抛出类转换异常ClassCastException
解决办法：使用java提供的关键字instanceof类型判断
重写Object类中的equals()方法
@Override
public boolean equals(Object object){
// 比较方法的调用者和方法的参数
// == 比较的地址值
// 如果两个地址一样直接返回true
if (this == object) {
return true;
}
if (object == null) {
return false;
}
}
if (object instanceof Student) {
//使用向下转型
Student student = (Student)object;
//比较两个对象的成员变量是否相等
boolean result = this.name.equals(student.getName())&&this.age == student.age;
return result;
}
//如果object不属于Student类型，没有比较可言
return false;
}
重写hashCode()
@Override
public int hashCode(){
//通过Objects类生成hash值
int hash = Objects.hash(name,age);//如果name和age值相等
return hash;
}
Date类:
定义一个日期类
java.util.Date 表示时间和日期的类
Date可以获取到精确毫秒值的特定时间
毫秒：千分之一秒就是毫秒 1秒等于1000毫秒
一天 = 24*60*60*1000 = 86400000
2020-11-27 19：26：30：333 瞬间
毫秒值的作用：可以对时间和日期做一个精确的计算
注意：
中国属于东八区 会在标准时间之上在增加八小时 上海或者北京
1970年1月1日 08:00:00
构造方法：
public Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。获取当前时间
public Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。放毫秒值，得到时间
成员方法：
public long getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。获取时间的毫秒值
simleDateFormat类
java.text.DateFormat:进行日期/时间格式化子类的抽象类
作用：
格式化 日期---文本
解析 文本---日期
成员方法：
String format(Date date);按照指定的模式把date日期，格式化为符合模式的字符串
Date parse(String source)把符合模式的字符串，解析成Date日期
Dateformat类是一个抽象类，无法直接创建对象，可以使用它的子类simleDateFormat
构造方法：
public simleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造simleDateFormat
参数：
String pattern 传递指定的模式
Thu Jan 01 08:00:00 CST 1970
调整为 20:15 2020/11/27
模式：严格区分大小写
y 年
M 月
d 日
H 二十四时制
m 分
s 秒
F 星期
写对应的模式 他会把模式转换成对应的日期和时间
"HH:mm yyyy/MM/dd"
使用format方法 把日期格式化为文本
public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition pos)
将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。
public Date parse(String text, ParsePosition pos)解析字符串的文本，生成 Date。
使用DateFormat类中的方法parse，把文本解析成日期
Calendar类
java.util.Calendar;日历类，抽象类.在Date类后出现的，替换掉了很多Date类中的方法，
该类将所有的可能用到的时间信息封装为静态成员变量，通过类名.静态成员变量获取时间字段值
获取方式
由于Calendar类只一个抽象类，语言敏感性，Calendar类并不是直接创建对象来获取时间属性值，
而是通过静态方法创建，返回子类对象
常用的方法：
public int get(int field):返回的是一个给定的日历字段值
public void set(int field,int value):将给定的日历字段设置为给定的值
public abstract void add(int field,int amount):根据日历规则，为给定的日历字段添加或者是减去指定的时间量值
public Date getTime():返回的是一个表示此Calendar时间值(从历元到现在的毫秒偏移量)Date对象
public long getTimeInMillis();获取日历对象的毫秒值
Calendar类中提供了很多个成员常量，代表给定的日历字段
字段值 含义
YEAR 年
MONTH 月
DATE 月中的某一天（几号）
DAY_OF_MONTH 月中的第几天
HOUR 时(12小时制)
HOUR_OF_DAY 时（24小时制）
MINUTE 分
SECOND 秒
DAY_OF_WEEK 一周中的第几天（周几，周日为1）
备注：在西方的星期，开始为周日，中国为周一
在Calendar类中，月份的表示是以0-11代表的是1-12月
日期是有大小关系的，时间靠后，时间越大
System类
java.lang.System类中提供了大量的静态方法，主要是用来获取与系统相关的信息或者是进行系统级操作
不能被实例化，也不能被继承
字段：
static InputStream in “标准”输入流。
static PrintStream out “标准”输出流。
常用API方法
public static long currentTimeMills():可以获取当前时间的毫秒值
public static void arrarcopy(Object src,int srcPos,Object dest,int destPos,int length):
把数组当中的数据拷贝到另一个数组中可能异常不能超过 源数组和目标数组的元素索引
public static void exit(int status);停止当前正在执行的虚拟机 0代表正常退出，非0代表异常退出
arraycopy()方法
将一个数组元素复制到另一个数组当中，数组拷贝动作是系统级的操作，性能比较高
arraycopy方法当中涉及到了五个参数
参数列表 参数名称 参数类型 参数的含义
1 src Object 源数组
2 secPos int 源数组索引的起始位置
3 dest Object 目标数组
4 destPos int 目标数组索引的起始位置
5 length int 复制元素的个数
StringBuilder类
java.lang.StringBuilder 一个可变的字符序列。
构造方法
public StringBuilder():构造一个不带任何字符的字符生成器，其初始容量为16个字符
public StringBuilder(String str)构造一个字符串生成器，并初始化为指定的字符串内容
常用方法
public StringBuilder append(...)添加任意类型的字符串形式 并返回当前对象本身
public StringBuilder insert(int offset,...)根据指定位置插入任意类型的字符串形式，返回的是当前对象。不管存储什么类型数据，进入字符串缓冲区都变成了字符值
StringBuilder可以和String进行互相交换
String ---》StringBuilder：可以使用StringBuilder的带参构造方法
StringBuilder(String str)构造一个字符串生成器，并初始化为指定的字符串内容
StringBuilder---》String：可以使用StringBuilder类中的toString
public String toString();将当前的StringBuilder对象转换为String对象
包装类：
装箱：把基本数据类型，包装到包装类中（10 Integer 3.14 Double）
装箱：把基本数据类型的数据包装到包装类中（基本数据类型---》包装类型）
拆箱：从包装类中取出基本类型数据
拆箱：在包装类中取出基本数据类型的数据（包装类型---》基本数据类型）
以Integer int的包装类
构造方法:
Integer(int value):构造一个新分配的Integer独享，他表示的指定的int类型值
Integer(String s):构造一个新分配的Integer对象，他表示的String参数类型指定的int值
静态方法：
static Integer valueOf(int i):将指定的int值转换成Integer实例
static Integer valueOf(String s)：将String类型的int值转换成Integer对象
成员方法
int intValue();将指定的包装类型的对象转换为int类型值
在JDK1.5之后出现了新特性：自动装箱自动拆箱---》基本数据类型和包装类型可以自由的相互转换
自动装箱：直接把int类型值赋值给包装类
如：integer int01 = 123;相当于 Integer int01 = new Integer(123);
自动拆箱：正常 int01是包装类型，无法直接参与运算的，可以自由地转换成基本数据类型，再进行相关的运算
如：int01 + 2 相当于 int01.intValue() + 2
当我们把基本数据类型存储到容器当中，一般不能直接存储 ArrayList集合
容器当中一般存储的就是引用数据类型（对象）
基本数据类型转换成字符串
1.基本数据类型+ ""---》最简单的方法（常用）
2.使用Integer类中的toString(参数);返回的是表示指定整数的String对象
static String toString（int i）
3.String类中的静态方法valueOf(参数)
static String ValueOf（int i）;返回的是int参数的字符串表示形式
字符串转成基本数据类型
1.使用包装类的静态方法parseXxx(字符串);
Integer类：static int parseInt(String s)
Integer类：static double parseDouble(String s)
Collection集合
集合的概述
前面我们已经学习过了ArrayList集合了，那么集合到底是一个什么呢？
集合：是Java中提供的一种容器，可以用来存储多个数据
Collection集合常用功能
Collection集合是所有单列集合的父接口，在Collection集合中定义所有单列集合的共性API方法，
这些方法适用于所有的单列集合 增删改查功能 crud操作
public boolean add(E e);把给定的对象添加到当前的集合当中
public void clear();清空集合当中的所有元素
public boolean remove(E e);把给定的对象从当前集合当中删除掉
public boolean contains(E e);判断当前集合当中是否包含给定的对象
public boolean isEmpty();判断当前集合是否为空 null 空
public int size();获取当前集合的元素个数 StringBuilder capacity()容量 length()个数
public Object[] toArray();把当前集合中的元素存储到一个数组当中.
有关该接口当中其他API方法，大家可以自行查看API帮助文档
迭代器Iterator
迭代器接口
在程序开发工程中，经常需要遍历集合当中的所有元素，针对这种情况JDK官方又提供了一个接口
java.uril.Iterator。iterator接口他也是集合当中的一员，但是他于Map、Collection接口不同
Collection接口和Map接口：它主要是用来存储元素的，而Iterator主要用于迭代访问的Collection于
Map接口元素的。因此我们也经常把Iterator对象称为迭代器
想要遍历Collection集合当中的元素，首先要获取集合的迭代器，通过迭代器完成迭代操作
获取迭代器的方法为
public Iterator iterator();获取集合对应的迭代器，用来便利集合当中的元素
Iterator接口常用的api方法：
public E next();获取迭代的下一个元素
public boolean hasNext();如果集合当中仍有元素可以迭代，则返回true，如果没有元素则返回false
List集合：
java.util.List 接口继承于Collection接口，是单列集合的一个重要分支，在List集合当中允许出现重复的元素
所有的元素都是以一种线性方式进行存储的，在List集合当中基本上我们可以通过索引来进行访问集合中的元素
另外List集合元素是有序的，指的是存取元素顺序相同
List接口当中的常用API方法：增删改查 crud
除了继承Collection接口当中的方法外还增加了一些根据元素索引来操作集合的特点方法：
public void add(int index,E element);将指定的元素添加到给定集合中的指定位置上
public E get(int index);根据指定索引获取对应位置上的元素
public E remove(int index);通过索引删除索引对应位置上的元素
public E set(int index,E element);在指定索引位置上替换成给定的元素，并且返回更新前的元素
List集合的子类
ArrayList集合
有索引，有序，元素可重复，长度可变的数组，可以存储NULL元素，元素增删慢，查询快
LinkedList集合
java.util.LinkedList集合数据存储的结构采用的是链表结构，方便元素的添加和删除操作。
此外【LinkedList是一个双向链表】，特点：增删快，查询慢，在LinkedList集合当中，
封装了大量的关于首节点和尾节点的元素操作方法。
方法如下：
public void addFirst(E e):将指定元素插入到首节点位置
public void Last(E e);将指定的元素插入到尾节点位置上
public E getFirst();获取首节点的元素
public E getLast();获取尾节点的元素
public E removeFirst();删除首节点元素
public E removeLast();删除尾节点的元素
public E pop();从此列表所表示的堆栈当中弹出一个元素
public void push(E e);将元素推入到此列表所表示的堆栈当中
public boolean isEmpty();如果此列表不包含任何元素返回true.
Set接口
java.util.Set接口和java.util.List接口是一样的，都是继承自Collection接口，他与Collection接口中的方法基本一样
没有对Collection进行功能上的扩展，只是比Collection接口更加严格。与Linst接口不同的是Set接口中的元素是无序的
并且都会以某种规则保证存入的元素不重复。
HashSet集合
java.util.HashSet是Set接口的一个实现类，他存储的元素是不可重复的，并且元素都是无序的（存取顺序不一致）
java.util.HashSet底层的实现其实是一个java.util.HashMap支持的
HashSet是根据对象的哈希值来确定元素在集合当中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性
的方式依赖于hashCode和equals方法
他与Collection接口中的方法基本一样
LinkedHashSet集合
继承了很多类的方法
我们知道HashSet保证元素的唯一，可是存进去的元素是没有顺序的，那么如何保证存进去的元素是有序的呢
在Java.util.HashSet类下面还有一个子类java.util.LinkedHashSet，他是链表和哈希表的组合的一个数据存储结构.
底层是一个哈希表（数组+链表/红黑树）+ 链表：多了一条链表（记录元素的存储顺序的），从而保证元素的有序
Collections集合工具类
常用API方法
java.util.Collections集合工具类,用来操作集合对象的元素方法如下：
public static <T> boolean addAll(Collection<? super T> c,T...elements);往集合中一次性添加多个元素
public static <T> void shuffle(List<?> list);打乱集合中的元素顺序
public static <T> void sort(List<T> list);将集合中的元素按照默认规则排序
public static <T> void sort(List<T> list,Comparator<? super T> c);将集合中的元素按照指定规则排序
Comparator接口比较器
Conllections工具集中的sort()
public static <T> void sort(List<T> list);
public static <T> void sort(List<T> list,Comparator<? Super T> c);
Comparator接口在java.util包下面，排序是Comparator需要实现的功能之一，该接口代表的是一个比较器，比较器具有可比性，可以做
排序，其实是比较两个对象谁排在前面谁排在后面。那么比较的方法是：
public int compare（Object o1，Object o2）;比较两个参数的顺序
如果两个对象比较结果有三种：大于，等于，小于
如果按照升序排序：则o1小于o2返回（负数），相等返回（0），o1大于o2返回（正数）
如果按照降序排序：则o1小于o2返回（正数），相等返回（0），o1大于o2返回（负数）
简化操作：
升序排序：o1-o2
降序排序：o2-o1
Map接口概述：
现实生活中，我们常会看到这样一种集合：IP地址和主机名，身份证号和个人，系统用户名与系统用户对象等，
这种是一一对应关系，我们把它称之为映射。在java当中提供了专门的集合类用来存放这种映射关系的对象。
即java.util.Map接口
Map接口当中的常用API方法：Map<K,V>
常用方法如下：
public V put(K key,V value);把指定的键与指定的值添加到Map集合当中
public V remove(Object key);把指定的键所对应的键值对元素从Map集合中删除，返回的是被删除元素的值
public V get(Object key);根据指定的键 获得在Map集合中对应的值
public Set<K> keySet();获取Map集合当中所有的key值，存储到Set集合当中
public Set<Map.Entry<K,V>>entrySet();获取到Map集合当中的所有的键值对对象集合（Set集合）
Map.Entry<K,V>；在Map接口有一个内部接口Entry
作用：当Map集合一创建，紧接着就在Map集合中创建一个Entry对象
用来及Map中的键与值（键值对对象，键与值是映射关系）
Objects类:
常用方法:public static <T> T requireNunNull（T obj）;查看指定的引用对象不是null值
public static int hash(Object... values);为输入值序列生成哈希码。
Throwable类:
如何获取异常的信息
Throwable类中定义了一些常用的API方法
public String getMessage();获取异常的描述信息，原因（提示给用户的，提示错误原因）
public String toString();获取异常的类型、异常描述的信息
public voidprintStackTrace();打印异常的跟踪栈信息并且输出到控制台中
包含了：异常的类型，异常的原因，还包括异常出现的位置，在开发和调试的阶段一般都是使用printStackTrace
Thread类
API帮助文档中定义了有关线程的一些方法,具体如下:
[构造方法:]
public Thread();分配一个新的线程对象
public Thread(String name);分配一个指定名字的新的线程对象
public Thread(Runnable target);分配一个带有指定目标的线程对象
public Thread(Runnable target,String name);分配一个带有指定目标的新的线程对象,并且带有指定名字的
[常用的方法:]
public String getName();获取当前线程的名称
public void start();让此线程开始执行,java虚拟机会调用此线程的run()方法
public void run();此线程要执行的任务在此方法内定义
public static void sleep(long millis);使当前正在执行的线程以指定的毫秒数暂停(临时性暂停线程的执行)
public static Thread currentThread();获取当前正在执行的线程对象的引用
通过翻阅API得知,创建线程有两种方式,一种继承Thread类,一种是实现Runnable接口
File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法.
构造方法:
§ public File(String pathname):通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
§ public File(String parent, String child):根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例.
§ public File(File parent String child):根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
常用API方法
§ 获取功能的方法
§ 判断功能的方法
§ 创建删除功能的方法
§ 目录遍历功能
获取功能的方法
Str
§ public String getAbsolutePath();返回此抽象路径名的绝对路径名字符串。
§ public String getPath();将次File转换为路径名字符串
§ public String getName();返回由此File表示的文件或目录的名称
§ public long length();返回此File表示的文件长度
判断文件的功能
§ public boolean exists();判断文件夹是否实际存在
§ public boolean isDirectory();判断此File表示的文件夹是否存在
§ public boolean isFile();判断此File表示的文件是否存在
创建和删除文件的功能
§ public boolean createNewFile();当且仅当具有该文件名称的文件不存在时,创建一个新的空的文件返回值是true
§ public boolean delete();删除由此File类表示的文件或者目录
§ public boolean mkdir();创建由此File表示的文件夹
§ public boolean mkdirs();创建由此File表示的文件夹,包含任何必须但是有不存在的父目录.
目录的遍历:
public String[] list();返回一个String数组,表示该File目录中的所有的子目录或者是子文件
public File[] listFile();返回一个File数组,表示该File目录中的所有的子目录或者是子文件
字节输出流[OutputStream]
java.io.OutputStream此抽象类是表示输出字节流的所有类的超类，将指定的字节信息写入到目的地。它定义了字节输出流的基本共性的api方法：
public void close()：关闭此输出流并释放与此流相关的其他任何系统资源。
public void flush()：刷新此输出流并强制任何缓冲的的输出字节信息被写入。
public void write(byte[] b)：将b.length字节从指定的字节数组写入到此输出流中。
public void write(byte[] b,int off,int len)：从指定的字节数组写入len个字节，从偏移量off开始输出到此输出流中
public abstract void write(int b)：将指定的字节输出到此输出流中。
备注：close方法，当完成流的操作时，必须调用此方法，释放系统资源。
FileOutputStream类
java.io.FileOutputStream类是文件字节输出流，用于将数据写入到文件中。
构造方法
public FileOutputStream(File file)：创建一个向指定 `File` 对象表示的文件中写入数据的文件输出流。
public FileOutputStream(String name)：创建文件输出流以指定的的文件名称写入文件中。
数据的追加续写
如何在保留目标文件中的数据，还能继续添加新的数据到目标文件中？
public FileOutputStream(File file,boolean append)：创建文件输出流以写入由指定的File对象表示的文件中。
public FileOutputStream(String name,boolean append)：创建文件输出流以指定的名称写入文件中。
字节输入流【InputStream】
java.io.InputStream此抽象类是表示字节输入流的所有类的超类。可以读取字节信息到内存中。他定义了字节输入流的基本共性的api方法：
public void close()：关闭此输入流并释放与此流相关的其他的任何系统资源。
public abstract int read()：从输入流中读取数据的下一个字节。
public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组b当中。
备注：close方法，当完成流的相关操作后，需要调用此方法关闭输入流，释放系统资源。
FileInputStream类
java.io.FileInputStream类是文件输入流，从文件中读取字节。
构造方法
FileInputStream(File file)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的File对象file命名。
FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名。
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件，会抛出FileNotFoundException。
字符输入流【Reader】
java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存当中，它定义了字符输入流的基本共性的api方法：
public void close()：关闭此输入流并且释放与此流相关的其他系统资源。
public int read()：从输入流中读取一个字符。
public int read(char[] chuf)：从输入流中一次读取多个字符，并将它们存储到字符数组chuf当中。
FileReader类
java.io.FileReader类主要是用于读取字符文件的便捷类。构造方法使用时默认的编码字符集和默认的字节缓冲区。
备注：
1. 字符编码：字节与字符的对应规则。Windows系统中的中文编码默认是GBK编码表，idea中采用UTF-8
2. 字节缓冲区：一个字节数组，用来临时存储字节数据。
构造方法
FileReader(File file)：创建一个新的FileReader对象，指定需要读取的file对象。
FileReader(String filename)：创建一个新的FileReader对象，指定需要读取的文件名称。
当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream。
字符输出流【Writer】
java.io.Writer抽象类是表示用于输出字符流的所有类的超类。将指定的字符信息写入到目的地中。它定义了字符输出流的基本共性的api方法：
void write(int c)：写入单个字符。
void write(char[] chuf)：写入字符数组。
abstract void write(char[] chuf,int off,int len)：写入char数组的一部分，从char数组的起始索引值off开始，len个写入字符个数。
void write(String str)：写入字符串。
void write(String str,int off,in len)：写入字符串的一部分，从字符串的起始索引off开始，写入len个字符个数。
void flush()：刷新该流的缓冲。
void close()：关闭此流，但是需要先刷新它。
FileWriter类
java.io.FileWriter类是用于写入字符到文件中。构造方法使用系统默认的字符编码和默认的字节缓冲区。
构造方法
FileWriter(File file)：创建一个新的FileWriter，指定写入的file对象。
FileWriter(String filename)：创建一个新的FileWriter，指定需要写入的文件的名称。
当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。
属性集[Properties]
java.util.Properties类继承于Hashtable,用来表示一个持久的属性集.它使用的键值对结构存储数据,每个键及其对应的值都是一个字符串
构造方法
public Properties();创建一个空的属性集列表
共性的API方法:
public Object setProperty(String key,String value);保存一对属性
public String getProperty(String key);使用此属性列表中指定的键来搜索对应的值
public Set<String >stringPropertyNames();获取所有键的名称并封装到Set集合中
与流相关的方法
public void load(InputStream input);从字节输入流中读取键值对元素
public void store(OutputStream out,String comments);(评论注释)把集合当中的数据写入到字节输出流中
缓冲流[Buffered]
字节缓冲流:
构造方法
public BufferedInputStream(InputStream,input);创建一个新的缓冲输入流
public BufferedOutputStream(OutputStream,output);创建一个新的缓冲输出流
字符缓冲流:
构造方法:
public BufferedWriter(Writer out);创建一个新的字符缓冲输出流
public BufferedReader(Reader in);创建一个新的字符缓冲输入流
特有方法:
BufferedReader:public String readLine();读取整行的文本信息
BufferdWriter;public void newLine();写入一行行分隔符,由系统属性定义换行符号.
InputStreamReader类
转换流java.io.InputStreamReader,是Reader的子类,他是从字节流到字符流的一个桥梁,他读取字节,并使用指定的字符集将其解码为字符.
他的字符集可以有名称指定,或者可以使用平台默认的字符集
构造方法:
public InputStreamReader(InputStream in);创建一个使用默认的字符集的字符流
public InputStreamReader(InputStream in,String charsetName);创建一个指定字符集的字符流
OutputStreamWriter类
转换流java.io.OutputStreamWriter是Writer的子类,他是字符流到字节流的桥梁.使用指定的字符集将字符编码为字节.字符集可以手动指定,
也可以使用平台默认的字符集
构造方法:
public OutPutStreamWriter(OutputStream out);创建一个使用平台默认的字符集的字符流
public OutPutStreamWriter(OutputStream out,String charsetName);创建一个指定字符集的字符流
ObjectOutputStream类
java.io.ObjectOutputStream类,将java对象的原始数据类型写入到文件中,实现对象的持久化存储
构造方法
public ObjectOutputStream(OutputStream out);创建一个指定的OutputStream的ObjectOutputStream类对象
特有的独有方法
void writeObject(Object obj);将指定的对象写入到ObjectOutputStream类对象中
java.io.ObjectInputStream类是反序列化流,将之前使用ObjectInputStream序列化流的原始数据回复为对象
构造方法
public ObjectInputStream(InputStream in);创建一个指定的InputStream的对象反序列化流对象
特有的方法
public final Object readObject();从反序列化流中读取一个对象.
java.io.PrintStream:打印流
特有的方法:
void print(任意类型的值)
void println(任意类型的值并且含有换行)
构造方法:
PrintStream(File file);输出目的地是一个文件
PrintStream(String filename);输出目的地是一个文件路径
PrintStream(OutputStream out);输出目的地是一个字节输出流
PrintStream extends OutputStream
共性API方法:close,flush,write(int b),write(byte[] b)
Socket类:
Scoket类 实现客户端套接字,套接字指的是两台设备通信的端点.
构造方法:
Socket(String host, int port) 创建一个流套接字并将其连接到指定主机(服务器端)上的指定端口号。如果指定的host是一个null值,
则相当于指定地址为回送地址.
备注:回送地址(127.x.x.x);是本机回送地址,(loopback address),主要用于网络软件测试用的,本机上进程间的通信,无论什么程序一旦使用回送地址
发送数据,会立即返回,不进行任何的数据网络传输
成员方法:
public InputStream getInputStream();获取套接字输入流
public OutputStream getOutputStream();获取此套接字的输出流
public void close();关闭此套接字
public void shutdownOutput();禁用此套接字的输出流
任何先前写入的数据都会将会被发送,随后终止此输出流
ServerSocket类
ServerSocket类实现了服务器套接字,该对象等待通过网络请求.
构造方法:
public ServerSocket(int port);使用该构造方法在创建ServerSocket对象时,就可以将其绑定到一个指定的端口号上,参数port就是端口号
成员方法:
public Socket accept();监听并接受连接,返回一个新的Socket对象,用于和客户端实现通信,该方法会一直阻塞直到建立连接.
浙公网安备 33010602011771号