Java学习总结（二）

一、String字符串

字符串定义后是一个常量

//创建一个hello字符串对象，将其地址保存在str变量中
String str="hello";
str="abc";//这里实际是又创建了一个字符串对象abc，将其地址保存在str变量中
//str只引用最后赋值的字符串地址abc

//字符串实际是一个字符数组
String str2="abc";
char[] list = {'a','b','c'};
String str3= new String(list);
//这里str2和str3中保存的内容是一样的

如果要频繁更改字符串中的值，建议使用StringBuilder类或StringBuffer类

创建一个字符串对象

1.使用""赋值创建

String str="hello你好";

2.通过构造方法创建

常用构造方法	说明
String()	创建一个空白字符串对象，实际创建一个空字符数组
String(String str)	创建一个指定的字符串对象，实际是创建一个形参字符串的副本
String(char[] list)	创建一个指定字符数组的字符串对象。
String(byte[] list)	按默认编码格式创建一个指定字节数组的字符串对象。
String(byte[] list,String charsetName)	按指定的编码格式创建一个指定字节数组的字符串对象。

字符串常用方法

方法名	返回值	作用
length()	int	获取字符串的长度
trim()	String	去除字符串首尾的所有空格
toLowerCase()	String	转换字符串为小写
toUpperCase()	String	转换字符串为大写
isEmpty()	boolean	判断是否为一个空字符串
getBytes()	byte[]	按默认编码格式将字符串转换为字节数组
toCharArray()	char[]	将字符串转换为字符数组
equalsIgnoreCase(String str)	boolean	忽略大小写比较指定字符串是否相同
equals(String str)	boolean	判断字符串是否相同
charAt(int index)	char	获取index位置上的字符串
indexOf(String str)	int	获取str第一次出现的位置，如果没有返回-1
lastIndexOf(String str)	int	获取str最后一次出现的位置，如果没有返回-1
contains(字符序列)	boolean	判断指定的字符序列(字符串)是否存在于原字符串中
concat(String str)	String	将str拼接到原字符串末尾
startsWith(String str)	boolean	判断是否以指定字符串开头
endsWith(String str)	boolean	判断是否以指定字符串结尾
substring(int index)	String	截取原字符串在[index,数组长度)区间内的字符。(从指定位置截取至末尾，包含指定位置)
substring(int from,int to)	String	截取原字符串在[from,to)区间内的字符。(从from截取至to，包含from不包含to)
split(String reg)	String[]	按指定字符串或正则表达式切分原字符串。如果指定内容不在末尾，n个指定字符能得到n+1个子串;如果指定内容在末尾，n个指定字符能得到n个子串(不包含末尾的无效字符)。
String.valueOf(参数)	String	将一个参数转换为字符串，参数可以是原始类型，也可以是任意对象。
replace(char oldChar,char newChar)	String	使用newChar替换oldChar

字符串注意事项

在比较字符串是否相同时，要使用String重写的equals方法进行判断。

String中equals方法判断的原理，大致为：将两个字符串保存到字符数组中，再对每个字符逐一比较，如果全部一致则返回。

在使用equals方法时，通常要将已知的非空字符串作为调用者。

二、可变字符串

在程序中，如果要频繁操作某个字符串，一定使用可变字符串类StringBuilder或StringBuffer创建对象。

StringBuilder类

用于表示可变字符串的一个类，是非线程安全的，建议在单线程环境下使用，效率略高于StringBuffer。

StringBuffer类

用于表示可变字符串的一个类，是线程安全的，建议在多线程环境下使用，效率略低于StringBuilder。

StringBuilder和StringBuffer中的方法作用都一致，只不过StringBuffer中的方法使用了synchronized关键字修饰，表示一个同步方法，在多线程环境下不会出现问题。

所以这里以StringBuilder为例。

构造方法

常用构造方法	作用
StringBuilder()	创建一个大小为16的字符数组。类似于String str=“”;
StringBuilder(int capacity)	创建一个指定大小的字符数组
StringBuilder(String str)	创建一个str长度+16的字符串数组后，将str添加到其中。类似于String str=“初始值”;

普通方法

方法	作用
append(Object obj)	将指定内容添加到原可变字符串对象末尾
delete(int start,int end)	删除[start,end)范围内的字符
deleteCharAt(int index)	删除指定索引的字符
insert(int index,Object obj)	将obj添加到index位置上
replace(int start,int end,String str)	将[start,end)范围内的字符替换为str
reverse()	翻转原字符串

注意

• 以上方法都是在直接操作原字符串，每个方法调用后，原字符串都会发生变化。

• StringBuilder或StringBuffer中并没有重写equlas方法，所以要比较两个可变字符串对象的值是否相同时，需要将可变字符串对象转换为String对象后，调用equals方法比较。

可变字符串与不可变字符串之间的转换

不可变字符串转换为可变字符串

通过创建一个可变字符串对象，将不可变字符串作为参数实现转换

//定义一个不可变字符串对象
String str="hello";
//创建一个可变字符串对象，将不可变字符串对象作为参数
StringBuilder sb = new StringBuilder(str);

可变字符串转换为不可变字符串

通过调用可变字符串的toString()方法实现转换

//创建一个可变字符串对象
StringBuilder sb = new StringBuilder("hello");
//调用toString()转换为String类型
String str=sb.toString();

三、System类

常用属性和方法	作用
System.in	获取系统输入流对象，通常用于获取输入信息
System.out	获取系统打印输出流对象，通常用于打印普通信息
System.err	获取系统打印输出流对象，通常用于打印异常信息
System.exit(int statues)	终止虚拟机运行，0表示正常结束
System.getenv(String key)	获取系统指定的环境变量信息
System.arraycopy(原数组,原数组起始位置,目标数组,目标数组起始位置,原数组要赋值的元素数量)	将原数组中指定长度的元素复制到新数组中
System.currentTimeMills()	获取从1970.1.1 0:0:0(UTC)至今经过了多少毫秒。中国是UTC(+8)所以是从1970.1.1 8:0:0至今经过了多少毫秒,返回long类型

四、Runtime类

Runtime类的对象，用于表示程序运行时对象(程序运行环境对象)。

包含了程序运行环境相关的信息。常用于获取运行环境信息(如虚拟机内存)或执行某个命令。

特点

这个类不是一个抽象类，但不能创建对象，因为其构造方法是私有的。

但是它提供了一个静态方法getRuntime()，通过这个方法，可以获取一个Runtime类的对象。

五、包装类

**包装类就是原始类型对应的类类型。**包装类通常用于将字符串转换为对应的原始类型。

在web应用中，从浏览器中获取到后台的数据，全是String类型，一定要使用转换的方法。

包装类	原始类型	将字符串转换为原始类型
Byte	byte	Byte.parseByte(String str)
Short	short	Short.parseShort(String str)
Integer	int	Integer.parseInt(String str)
Long	long	Long.parseLong(String str)
Float	float	Float.parseFloat(String str)
Double	double	Double.parseDouble(String str)
Boolean	boolean	Boolean.parseBoolean(String str)
Character	char	无

装箱和拆箱

• 所有包装类都有一个静态方法valueOf(原始类型)，将某个原始类型的数据转换为相应的包装类对象，这个过程称为装箱。

  //手动装箱
  int i=123;//定义一个原始类型的数据
  Integer aInteger=Integer.valueOf(i);//调用包装类的valueOf()方法将原始类型转换为包装类对象
  

• 所有包装类都有一个原始类型Value()方法，用于将包装类对象转换为原始类型，这个过程称为拆箱

  //手动拆箱
  Integer aInteger=new Integer(123);//创建一个包装类对象
  int i = aInteger.intValue();//调用包装类的"原始类型Value()"方法将其转换为原始类型
  

• 自动装箱拆箱。在jdk1.5之后，加入了自动装箱拆箱的特性，可以直接在原始类型和对应的包装类中互相赋值

  //自动装箱
  Integer aInteger=123;
  //自动拆箱
  int i=aInteger;
  

六、异常

异常的产生

异常在程序中以对象的形式存在。当代码执行时出现异常，虚拟机会自动创建一个相应的异常对象，如果没有对该异常进行处理，就会导致程序中断。

异常的分类

异常在程序中以对象的形式存在，所以异常有对应的类。

Throwable是异常类的根类，通常所说的异常，其实指的是Exception子类

1.Error错误

如果出现XXXXXError，如StackOverflowError栈空间溢出时，无法通过额外的代码去解决，只能修改源码。

2.Exception异常

如果出现XXXXException，如NullPointerException空指针异常时，可以通过额外代码去避免。

运行时异常和非运行时异常

如果一个异常属于RuntimeException异常类的子类，称为运行时异常，可以通过编译，运行时可能抛出异常对象。

如果一个异常属于Exception异常类的子类，称为非运行时异常，无法通过编译，只有处理后才能编译运行。

处理异常Exception

只要处理Exception异常类的子类时，都称为处理异常。处理异常的目的就是为了保证程序正常运行，不要中断。

方式一：try-catch-finally语句

这种方式能成功地处理异常，无论会不会抛出异常，都能让程序保证正常执行。

try{
    //可能出现异常的代码
}catch(异常类 异常对象){
    //如果出现异常对象，且与catch中的异常类匹配，则执行
}catch(异常类 异常对象){//后续的catch中的异常类型只能与之前的异常类型同级或是父类
    //如果出现异常对象，且与catch中的异常类匹配，则执行
}finally{
    //无论程序是否会抛出异常，一定要执行的代码
}

方式二：throws关键字

这种方式，可以让非运行时异常通过编译，定义方法的时候，声明可能抛出的异常。

用法：方法的参数小括号之后，添加"throws 异常类型1，异常类型2…"

public class Test{
    public void fun() throws InterruptException{//在定义方法时，声明可能抛出的异常类型
        //如果直接写这句话，会报错，因为sleep()方法会抛出一个非运行时异常，必须要处理
        Thread.sleep(5000);
    }
}

throw和throws

• throws表示用于方法声明异常。使用时写在方法的小括号之后

  //用于声明方法的异常
  public void fun() throws Exception{
      
  }
  

• throw用于手动抛出异常对象。使用时写在{}中，通常用于满足某种条件时，强制中断程序。

  public void fun(){
      //用于手动抛出一个异常对象
      RuntimeException e =  new RuntimeException();
      throw  e;
  }
  

自定义异常

可以自定义异常，在满足某种条件下，手动通过throw关键字抛出异常，人为中断程序。

步骤

• 定义一个类，继承某个异常类。

  ​ 如果继承的是RuntimeException，表示自定义的异常类属于运行时异常，该异常对象可以不用处理。

  ​ 如果继承的是非RuntimeException，表示自定义的异常类属于非运行时异常，该异常对象必须要处理。

• [可选操作]定义一个无参数的构造方法，调用父类中无参的构造方法，定义一个带字符串参数的构造方法，调用父类带字符串参数的构造方法。

七、集合

集合框架(集合家族)

Iterable接口并不算严格意义上的集合的"根",它称为迭代器，用于遍历集合元素的一个工具接口。

所以集合的根接口为：Collection接口和Map接口，位于java.util包中

Collection接口

核心的两个子接口：Set和List。

这两个接口都可以保存一组数据，Set接口保存数据时，是无序不重复的;List接口保存数据时，是有序可重复的。

List接口(有序可重复)

有序集合，元素可以重复，允许保存null，可以通过索引获取对应位置上的元素。

在接口中定义了一些操作元素的方法，如获取元素数量、添加、删除、替换、截取等。

ArrayList实现类

• 采用数组实现的集合
• 可以通过索引访问元素、可以改变集合大小。如果要在其中插入或删除元素时，会影响其余元素。该集合查询效率高、增删中间元素效率低。

构造方法

常用构造方法	说明
ArrayList()	创建一个无参的ArrayList对象。实际是创建了一个空的Object数组。在调用添加元素方法时，才会初始化该数组大小为10。
ArrayList(int capacity)	创建一个指定容量的ArrayList对象，实际是创建一个指定大小的Object数组，如果参数为负，会抛出IllegalArgumentException异常

常用方法

常用方法	作用	返回值
add(Object obj)	添加obj到集合的末尾	boolean
add(int index,Object obj)	添加obj到index索引上	void
get(int index)	得到指定index索引的元素	Object
set(int index,Object obj)	使用obj覆盖index索引的元素，返回被覆盖的元素	Object
size()	获取集合中的元素数量	int
isEmpty()	判断集合是否为空	boolean
clear()	清空集合	void
remove(Object obj)	删除指定obj对象	boolean
remove(int index)	删除指定Index索引的元素，返回被删除的元素	Object
contains(Object obj)	判断是否存在obj元素	boolean
indexOf(Object obj)	得到元素obj第一次出现的索引	int
lastIndexOf(Object obj)	得到元素obj最后一次出现的位置	int
subList(int from,int to)	得到[from,to)区间内的元素	List
toArray()	将集合转换为数组	Object[]

LinkedList实现类

• 采用双向链表实现的集
  -中间进行插入和删除的效率高，随机读取的效率低

构造方法

常用构造方法	说明
LinkedList()	创建一个空链表

常用方法

由于LinkedList实现了List接口，所有这里省略List接口中常用的方法，如add(Object obj)、Remove(Object obj)等。参考ArrayList中的方法

常用方法
addFirst()	添加头结点
addLast()	添加尾结点
getFirst()	得到头结点
getLast()	得到尾结点
remove()	删除头结点
removeFirst()	删除头结点
removeLast()	删除尾结点
push(Object obj)	添加头结点(入栈)
pop()	得到并移除头结点(出栈)
peek()	得到头结点
poll()	删除头结点
offer(Object)	添加尾结点

ArrayList和LinkedList的区别

• 两者都是List接口的实现类，保存的元素有序可重复，允许保存null，拥有一些公共的方法，如size()，isEmpty()，subList(int from,int to)等
• ArrayList采用数组实现，对于随机读取效率更高，通常用于查询；LinkedList采用双向链表实现，插入删除不影响其他元素位置，通常用于中间插入删除。

Set接口(无序不重复)

无序集合，元素不可以重复，允许保存null，没有索引。

在接口中定义了一些操作元素的方法，如获取元素数量、添加、删除、替换、截取等。

HashSet实现类

• 采用哈希表实现
• 元素不能重复，无序保存，允许保存null
• 本质是一个HashMap对象，调用add()方法，实际调用的也是HashMap中的put()方法，参数作为put()方法的键，new Obejct()作为put()方法的值

构造方法

常用构造方法	说明
HashSet()	创建一个默认的集合对象，实际是创建了一个大小为16，加载因子为0.75的HashMap对象
HashSet(int capacity)	创建一个指定容量的集合对象，实际是创建了一个指定大小，加载因子为0.75的HashMap对象
HashSet(int capacity,float loadFactor)	创建一个指定容量和指定加载因子的集合对象。

常用方法

常用方法	说明
add(Object obj)	添加元素到集合中
size()	得到元素数量
isEmpty()	判断集合是否为空
remove(Object obj)	根据对象删除元素
contains(Object obj)	判断是否存在某个元素
toArray()	将集合转换为Object数组
clear()	清空集合

TreeSet实现类

构造方法

常用构造方法	说明
TreeSet()	实际会创建一个TreeMap对象

常用方法

常用方法	作用
add(Object obj)	添加元素到集合中
size()	得到元素数量
isEmpty()	判断集合是否为空
clear()	清空集合
ceiling(Object obj)	得到比指定元素大的最小元素
floor(Object obj)	得到比指定元素小的最大元素
first()/last()	得到第一个/最后一个元素

HashMap实现类

• JDK1.8之后，HashMap的数据结构采用"数组+链表+红黑树"实现
• 数据采用**"键值对"的形式保存，键称为key**，值称为value ，键不能重复，允许null，值没有限制，键和值都是引用类型

构造方法

常用构造方法	说明
HashMap()	创建一个空的集合对象，默认大小为16，加载因子为0.75

常用方法

常用方法	作用
put(Object key,Object Value)	添加一组键值对
get(Object key)	根据键得到值
size()	得到键值对的数量
clear()	清空所有键值对
keyset()	得到所有键的集合
values()	得到所有值的集合
containtsKey(Object key)	判断是否包含某个键
containsValue(Object value)	判断是否包含某个值
remove(Object key)	根据键删除键值对

遍历集合的方式

遍历List

方式一：普通for循环

List list= new ArrayList();
list.add("123");
list.add("123");
list.add("123");
list.add("123");
for(int i=0;i<list.size();i++){
    Object obj= list.get(i);
}

方式二：增强for循环

List list= new ArrayList();
list.add("123");
list.add("123");
list.add("123");
list.add("123");
for(Object o:list){
    Object obj= o;
}

方式三：迭代器

List list= new ArrayList();
//获取迭代器对象
Iterator it= list.iterator();
//hasNext判断是否还有下一个元素
while(it.hasNext()){
    //获取读到的元素
    Object obj=it.next();
}

遍历Set

方式一：增强for循环

Set list= new HashSet();
list.add("123");
list.add("qwe");
list.add("hello");
list.add(null);
for(Object o:list){
    Object obj= o;
}

方式二：迭代器

Set list= new HashSet();
//获取迭代器对象
Iterator it= list.iterator();
//hasNext判断是否还有下一个元素
while(it.hasNext()){
    //获取读到的元素
    Object obj=it.next();
}

泛型

一种规范，常用于限制集合中元素的类型，省去遍历元素时转型的过程。

//定义集合，默认不限制元素类型
List list = new ArrayList();
list.add("hello");
list.add("world");
list.add(123);

//如果没有限制集合的类型，要通过循环做某个事情时，可能对于某些元素并不适用
for(int i=0;i<list.size();i++){
    //String有length属性，Integer没有，运行时就会抛出异常
    System.out.println(list.get(i).length);
}

用法

在定义集合时，在接收集合变量的数据类型后，写上<数据类型>。

集合类或接口<数据类型> 集合变量名 = new 集合实现类<>();

List<String> list = new ArrayList<>();
//这样只能在集合中保存String
//list.add(123);//不能通过编译
//如果要限制集合保存int类型的数据，不能写int，要写int的包装类Integer。因为集合中保存的都是引用类型。
//List<int> list2=new ArrayList();//无法通过编译
List<Integer> list2=new ArrayList();

Collections集合工具类

• Collection是集合的根接口，定义了集合的方法
• Collections是集合的工具类，定义了很多静态方法，直接通过类名使用

常用方法

常用方法
Collections.shuffle(List list)	打乱有序集合中的元素顺序
Collections.swap(List list,int i,int j)	交换有序集合中i和j索引上的元素
Collections.replaceAll(List list,Object oldVal,Object newVal)	将有序集合中的旧元素替换为新元素
Collections.fill(List list,Object obj)	将有序集合使用obj填充
Collections.rotate(List list,int distance)	将最后distance个元素放在最前
Collections.sort(List list)	对有序集合中的元素进行排序，元素必须实现了Comparable接口
Collections.max(Collection list)	得到有序集合中的最小元素，元素必须实现了Comparable接口
Collections.min(Collection list)	得到有序集合中的最大元素，元素必须实现了Comparable接口

八、File文件

构造方法

常用构造方法	说明
File(String pathName)	根据文件的完整路径创建对象
File(String parent,String name)	根据文件所在的父目录路径和自身文件名创建对象
File(File parent,String name)	根据文件所在父目录文件对象和自身文件夹创建对象

常用方法

常用方法	说明	返回值
exists()	判断文件是否存在	boolean
isFile()	判断是否为文件	boolean
isDirectory()	判断是否为目录	boolean
getName()	得到文件名	String
getPath()	得到文件所在相对路径	String
getAbsolutePate()	得到文件所在绝对路径	String
getParent()	得到父目录的名称	String
getParentFile()	得到父目录的对象	File
lastModified()	得到文件最后一次修改时间对应的毫秒数	long
length()	得到文件的所占字节大小	long
isHidden()	判断文件是否为隐藏	boolean
list()	得到目录下的第一层子文件名的字符串数组	String[]
listFiles()	得到目录下的第一层子文件的文件数组	File[]
delete()	删除某个文件或空目录	boolean
mkdir()	创建一个空目录	boolean
renameTo(File newFile)	将原文件命名为新文件(新文件可以指定新位置)	boolean

九、流

在Java中，流用于表示计算机硬盘与内存之间传输数据的通道。

流的分类

Java中将流定义成了类，以对象的形式保存。流有"四大家族"，是所有流的父类。

InputStream字节输入流

FileInputStream文件字节输入流 ObjectInputStream对象字节输入流(反序列化)

OutputStream字节输出流

FileOutputStream文件字节输出流 ObjectOutputStream对象字节输出流(序列化)

Writer字符输出流

FileWriter文件字符输出流 **BufferedWriter缓冲字符输出流(包装流) ** OutputStreamWriter字节输出流转换为字符输出流(转换流)

Reader字符输入流

FileReader文件字符输入流 BuffedredReader缓冲字符输入流(包装流) InputStreamReader字节输入流转换为字符输入流(转换流)

FileInputStream文件字节输入流

按字节读取本地文件，本地文件必须存在

构造方法

常用构造方法	说明
FileInputStream(String pathName)	根据文件名创建文件字节输入流对象
FileInputStream(File file)	根据文件对象创建文件字节输入流对象

常用方法

常用方法	作用
read()	读取一个字节。返回读取到的字节本身。
read(byte[] b)	按字节数组读取。返回读取到的字节数量。读取到的内容保存在了字节数组中
close()	关闭流对象

FileOutputStream文件字节输出流

按字节将数据写入到本地文件中，本地文件可以不存在

构造方法

常用构造方法	说明
FileOutputStream(String pathName)	根据文件名创建文件字节输出流对象，写入内容时覆盖原内容
FileOutputStream(String pathName,boolean append)	根据文件名创建文件字节输出流对象，写入内容时追加在原内容之后
FileOutputStream(File file)	根据文件对象创建文件字节输出流对象，写入内容时覆盖原内容
FileOutputStream(File file,boolean append)	根据文件对象创建文件字节输出流对象，写入内容时追加在原内容之后

常用方法

常用方法	作用
write(int i)	写入一个字节
write(byte[] bytes)	写入一个字节数组
write(byte[] bytes,int off,int len)	写入字节数组中从off开始的len个字节
flush()	将数据冲刷到本地文件中
close()	关闭流对象

FileReader文件字符输入流

按字符读取文件。

构造方法

常用构造方法	说明
FileReader(String fileName)	根据文件名创建文件字符输入流对象
FileReader(File file)	根据文件对象创建文件字符输入流对象

常用方法

常用方法	作用
ready()	判断是否还有下一个字符
read()	读取下一个字符，返回读取到的字符
read(char[] chars)	按字符数组读取字符，返回读取到的字符数量，读取到的字符保存在了字符数组中
close()	关闭流对象

FileWriter文件字符输出流

按字符写入。

构造方法

常用构造方法	说明
FileWriter(String fileName)	按文件名创建字符输出流对象
FileWriter(String fileName,boolean append)	按文件名创建字符输出流对象，允许追加写入
FileWriter(File file)	按文件对象创建字符输出流对象
FileWriter(File file,boolean append)	按文件对象创建字符输出流对象，允许追加写入

常用方法

常用方法	作用
write(String str)	按字符串写入
write(char[] c)	按字符数组写入
write(String str,int off,int len)	按字符串写入，从off开始写入len个字符
write(char[] c,int off,int len)	按字符数组写入，从off开始写入len个字符
flush()	冲刷流中的数据到硬盘中(必须调用该方法或close方法后，才能真正写入)
close()	关闭流对象

BufferedReader字符缓冲输入流

构造方法

常用构造方法	说明
BufferedReader(Reader reader)	创建一个带有缓冲区(字符数组)的字符输入流对象，默认缓冲区大小为8192。参数注意是一个Reader类型的对象，但Reader是一个抽象类，所以要使用其子类，如FileReader，然后在FileReader中定义要读取的文件信息
BufferedReader(Reader reader,int size)	创建一个指定缓冲区(字符数组)大小的字符输入流对象

常用方法

常用方法	作用
ready()	判断是否还有字符
readLine()	读取整行字符
close()	关闭流对象

BufferedWriter字符缓冲输出流

自带字符数组(缓冲区)的字符输出流。

构造方法

常用构造方法	说明
BufferedWriter(Writer writer)	创建一个带有缓冲区(字符数组)的字符输出流对象，参数为一个Writer对象，但Writer是一个抽象类，所以要使用其子类，如FileWriter对象，在FileWriter中定义要写入的文件
BufferedWriter(Writer writer,int size)	创建一个指定缓冲区(字符数组)大小的字符输出流对象

常用方法

常用方法	作用
write(String str)	写入一个字符串
newLine()	换行
flush()	将输出流中的字符冲刷到文件中
close()	关闭流对象

ObjectOutputStream对象字节输出流(序列化)

序列化：将对象转换为文件的过程

被序列化的对象，必须要实现Serializable接口。

这个接口是一个特殊的接口，没有定义方法，只是给这个类打上标记，表示该类可以被序列化。

构造方法

常用构造方法	说明
ObjectOutputStream(OutputStream os)	创建一个对象字节输出流对象，参数为一个字节输出流对象，由于是抽象类，所以要使用其子类，如FileOutputStream对象，在其中定义要写入的文件。

常用方法

常用方法	作用
writeObject(Object obj)	将一个对象写入到本地文件中
close()	关闭流对象

ObjectInputStream对象字节输入流(反序列化)

反序列化：将文件转换为对象的过程

构造方法

常用构造方法	说明
ObjectInputStream(InputStream is)	创建一个对象字节输入流对象，参数为一个字节输入流对象，由于是抽象类，所以要使用其子类，如FileInputStream对象，在其中定义要读取的文件

常用方法

常用方法	作用
readObject()	读取序列化后的文件，返回对象Object
close()	关闭流对象

转换流

实际属于字符流，作用为将一个字节流对象转换为字符流对象

OutputStreamWriter

将字节输出流转换为字符输出流

InputStreamReader

将字节输入流转换为字符输入流

十、Java中的线程

Java中，线程以对象的形式存在。Thread表示线程类。

构造方法

常用构造方法	说明
Thread()	创建一个默认的线程对象
Thread(String name)	创建一个指定线程名的线程对象
Thread(Runnable target)	将一个Runnable对象包装为线程对象
Thread(Runnable target,String name)	将一个Runnable对象包装为线程对象同时命名

常用方法

常用方法	作用
setName(String str)	设置线程名称
setPriority(int i)	设置线程优先级(1~10)，数字越大优先级越高，线程越先执行完
setDaemon(boolean f)	是否将该线程设置为守护线程
getId()	获取线程ID
getName()	获取线程名，主线程名默认main，自定义线程名默认Thread-N
getPriority()	获取线程优先级
getState()	获取线程状态
isDaemon()	判断该线程是否属于守护线程
start()	启动线程
run()	线程启动后执行的方法
Thread.currentThread()	获取当前运行的线程对象
Thread.sleep(long m)	设置当前线程休眠m毫秒
Thread.yield()	线程让步，让其他线程执行

实现多线程

方式一：继承Thread类

• 1.让某个类成为Thread类的子类
• 2.重写Thread类中的run方法，将要让该线程执行的内容写在该方法中
• 3.创建Thread类的对象后，调用start()方法，启动线程

方式二：实现Runnable接口(建议使用)

由于Java中是单继承，所以如果某个类已经使用了extends关键字去继承了另一个类，这时就不能再使用extends继承Thread类实现多线程，就需要使用实现Runnable接口的方法实现多线程。

• 1.自定义一个类，实现Runnable接口
• 2.重写run方法，将要多线程执行的内容写在该方法中
• 3.创建Thread线程对象，将自定义的Runnable接口实现类作为构造方法的参数
• 4.调用线程对象的start()方法启动线程

方式三：使用匿名内部类

如果不想创建一个Runnable接口的实现类，就可以使用匿名内部类充当Runnable接口的实现类

package com.hqyj.UnnameInnerClassThreadTest;
/*
* 使用匿名内部类
* 本质还是使用Thread(Runnable target)
* 并没有创建一个Runnable接口的实现类，而是直接用一个匿名内部类作为参数，包装成一个线程对象
* */
public class Test {
    public static void main(String[] args) {
        //newThread()小括号中的参数就是一个匿名内部类
        //创建线程对象，将匿名内部类包装成Thread对象后直接start()启动
        new Thread(new Runnable() {
            //多线程做的事情依然写在run方法中
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }, "线程A").start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }, "线程B").start();
    }
}

线程的生命周期

线程的初始化到终止的整个过程，称为线程的生命周期

新生状态

当线程对象被实例化后，就进入了新生状态。new Thread()

就绪状态

当某个线程对象调用了start()方法后，就进入了就绪状态。

在该状态下，线程对象不会做任何事情，只是在等待CPU调用。

运行状态

当某个线程对象得到运行的机会后，则进入运行状态，开始执行run()方法。

不会等待run()方法执行完毕，只要run()方法调用后，该线程就会再进入就绪状态。这时其他线程就有可能穿插其中。

阻塞状态

如果某个线程遇到了sleep()方法或wait()等方法时，就会进入阻塞状态。

sleep()方法会在一段时间后自动让线程重新就绪。

wait()方法只有在被调用notify()或notifyAll()方法唤醒后才能进入就绪状态。

终止状态

当某个线程的run()方法中所有内容都执行完，就会进入终止状态，意味着该线程的使命已经完成。

十一、该部分知识重点难点：

1.可变字符串：StringBuffer类的应用
2.集合：Arraylist、HashMap的应用
3.流：FileInputStream文件字节输入流、FileOutputStream文件字节输出流、BufferedReader字符缓冲输入流、ObjectOutputStream对象字节输出流(序列化)、ObjectInputStream对象字节输入流(反序列化)的应用