JAVA学习-核心类库部分总结

---

java核心类库笔记总结

---

3.1 异常处理

• 异常分类
  • 检测异常 : 代码编写时报错
  • 运行时异常 : 非检测异常
• 处理机制
  • throw : 抛出单个异常,定义在方法体内
  • throws : 抛出多个异常,定义方法参数列表后异常之间用逗号分隔
  • try (数据源定义，可省略) {
     捕获异常,编写可能出现异常的代码
    } catch(异常类对象) {
     处理异常代码
    } finally {
     无论是否出现异常都执行的代码
    }
    注:try与catch、try与finally组合使用，代码块之间不能出现代码

//一般写法
InputStream is = null;
OutputStream os = null;
try {
    //...
} catch (IOException e) {
    //...
}finally{
    try {
        if(os!=null){
            os.close();
        }
        if(is!=null){
            is.close();
        }
    } catch (IOException e2) {
        //...
    }
}
//可替换成try-with-resources语句
//try()里每个声明的变量类型都必须是Closeable的子类或实现了java.lang.AutoCloseable接口。这些接口都定义了一个close()方法，用于释放资源和进行清理操作。
//try块退出时，编译器会自动调用这些资源对象close()方法，关闭资源
//就一个close方法相当于系统自动将关闭操作放到了finally里面而不需要我们自己写了
//try()的括号中也可以写多行声明，每个声明的变量类型都必须是Closeable的子类，用分号隔开。
//try-with-resources语句的优点包括自动关闭资源、减少代码冗余和提高代码可读性。它使得资源管理变得更加简单和方便，降低了因资源管理不当而引发的潜在问题
try(
    InputStream is = new FileInputStream("...");
    OutputStream os = new FileOutputStream("...");
){
    //...
}catch (IOException e) {
    //...
}

3.2 多线程

• 方式 :
  ①继承Thread类:重写run方法、测试类调用start()开启多线程
     
  ②实现Runnable接口:重写run方法、测试类中实例化类并与Thread构造器建立关联
• Thread类:
  • 将实现Runnable接口的类对象做参数传递给Thread类对象
    • public Thread(Runnable r)
  • 封装多线程操作代码
    • public void run()
  • 开启多线程
    • public void start()
  • 获取当前正在执行的线程
    • public static Thread currentThread()
  • 获取当前线程的的名字
    • public String getName()
  • 设置当前正在运行的线程的睡眠时间
    • public static void sleep(long time)
• 线程状态 : 运行状态、阻塞状态(处在JVM中的线程池)、创建状态、消亡状态
• object类等待唤醒机制
  • 设置线程为等待状态
    • public void wait()
  • 唤醒线程池中的一个线程
    • public void notify()
  • 唤醒所有线程
    • public void notifyAll()
• 多线程安全性
  • 多线程同时处在临时状态,抢夺执行权,对共同资源操作
  • 解决 :
    ①使用同步代码块(锁)
    synchronized(this或Object对象或class对象){}
    ②使用同步函数(this锁)
    public synchronized 返回值 方法名([参数]){操作共同资源}
    run方法中调用

3.3 常用类

Object类

• 实例化object类对象
  • public Object()
• 将任意引用数据类型以String形式返回
  • public String toString()
• 获取已实例对象的唯一标识
  • public int hashCode()
• 获取当前正在运行的类
  • public final class getClass()
• 判断调用对象与参数对象地址是否一致
  • public boolean equals(Object obj)

System类

• 将指定源数组中的数组src从指定位置srcPos复制length长度到目标数组dest的指定位置destPos
  • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
• 标准输入流
  • public static final InputStream in
• 标准输出流
  • public static final PrintStream out

Math类

• 常量π
  • public static final double PI
• 获取[0.0,1.0)无限不循环小数
  • public static double random()

Random类

• 实例化Random对象
  • public Random()
• 获取int类型取值范围内的任意一个数
  • public int nextInt()
• 获取[0,num)范围内的任意一个整数
  • public int nextInt(int num)

Scanner类

• 传递一个标准输入流
  • public Scanner(InputStream source)
• 关闭资源
  • public void close()
• 接收String类型数据
  • public String next()
• 接收int类型数据
  • public int nextInt()
• 接收double类型数据
  • public double nextDouble()

Date类

• 实例化date对象,表当前系统时间
  • public Date()

SimpleDateFotmat类

• 实例化SimpleDateFotmat对象设置时间格式
  • public SimpleDateFormat(String pattern)
• pattern格式
  • y/Y 表示年
  • M 表示月
  • d 表示天
  • H 表示24进制小时
  • h 表示12进制小时
  • D 表示当年第几天
  • m 表示分钟
  • s 表示秒
  • S 表示毫秒
  • a 表示上午
• 格式化一个对象来生成一个字符串
  • public final String format(Object obj)

Calendar类(日历类)

• 获取Calendar类对象
  • public static Calendar getInstance()
• 获取给定日历字段的值
  • public int get(int field)
• 获取当前年份
  • public static final int YEAR
• 获取当前月份(初始值为0，所以我们用它来表示日历月份时需要加1)
  • public static final int MONTH
• 获取当月第几天
  • public static final int DAY_OF_MONTH
• 获取本周第几天(周一为第一天)
  • public static final int DAY_OF_WEEK
• 获取本月第几周
  • public static final int DAY_OF_WEEK_IN_MONTH
• 获取本年第几天
  • public static final int DAY_OF_YEAR
• 获取24进制小时
  • public static final int HOUR_OF_DAY
• 获取分钟
  • public static final int MINUTE
• 获取秒钟
  • public static final int SECOND
• 获取当前系统时间
  • public final Date getTime()
• 获取当前时间距1970.1.1 0:0:0的总毫秒数
  • public long getTimeInMillis()
• 设置年月日的值
  • public final void set(int year, int month, int day)
• 设置年月日时分秒的值
  • public final void set(int year,int month,int day,int hour,int minute,int second)
• 根据日历的规则，将指定的时间量添加或减去给定的日历字段
  • public abstract void add(int field,int amount)

包装类

• 装箱 : 基本数据类型转包装类
• 拆箱 : 包装类转基本数据类型
• 对应关系 : 基本类型-----包装类
       byte ----- Byte
       short ----- Short
       int ----- Integer
       long ----- Long
       float ----- Float
       double ----- Double
       char ----- Character
       boolean ----- Boolean

String类

• byte[]转String
  • public String(byte[] bytes,int offset,int count)
• String转byte[]
  • public byte[] getBytes()
• char[]转String
  • public String(char[] value,int offset,int count)
• String转char[]
  • public char[] toCharArray()
• 获取指定位置上的元素
  • public char charAt(int index)
• 获取两个字符串的字典顺序(区分大小写)
  • public int compareTo(String anotherString)
• 获取两个字符串的字典顺序
  • public int compareToIgnoreCase(String anotherString)
• 获取指定字符第一次出现的位置(无则返回-1)
  • public int indexOf(int ch)
  • public int indexOf(int ch,int fromIndex)
  • public int indexOf(String str)
  • public int indexOf(String str,int fromIndex)
• 获取指定字符最后一次出现的位置(无则返回-1)
  • public int lastIndexOf(int ch)
  • public int lastIndexOf(int ch,int fromIndex)
  • public int lastIndexOf(String str)
  • public int lastIndexOf(String str,int fromIndex)
• 获取字符串长度
  • public int length()
• 从指定位置开始截取字符串
  • public String substring(int beginIndex)
  • public String substring(int beginIndex,int endIndex)
• 使用新字符替换旧字符
  • public String replace(char oldChar,char newChar)
• 校验字符串是否满足指定规则
  • public boolean matches(String regex)
• 将字符串按指定正则分隔返回分隔后的字符串数组
  • public String[] split(String regex，int limit)
  • 如果传入 limit(limit>0) 则得到分割后的数组长度最大是 limit
  • 默认 limit = 0 将会以最大分割次数分割，但是分割结果会舍弃末位的空串
  • 如果 limit = -1 将会以最大分割次数分割，不舍弃末位的空串
• 将字符串全部转大写
  • public String toUpperCase()
• 将字符串全部转小写
  • public String toLowerCase()
• 将字符串首尾空格去除
  • public String trim()
• 判断字符串是否以指定字符结尾
  • public boolean endsWith(String suffix)
• 判断俩字符串是否一致(绝对等)
  • public boolean equals(Object anObject)
• 判断俩字符串是否一致(相对等)
  • public boolean equalsIgnoreCase(String another)
• 判断是否为空串
  • public boolean isEmpty()

StringBuffer类

• 被synchronized修饰,线程安全,需要释放锁,效率相对较低,在多线程下使用
• StringBuffer转String
  • public String toString()
  • public String(StringBuffer sbuf) //String类
• String转StringBuffer
  • public StringBuffer(String str)
• 追加StringBuffer末尾
  • public StringBuffer append(Object obj)
• 插入StringBuffer指定位置
  • public StringBuffer insert(int index,Object obj)
• 删除StringBuffer一段元素(含start不含end对应的元素)
  • public StringBuffer delete(int start,int end)
• 删除指定位置上的元素
  • public StringBuffer deleteCharAt(int index)
• 替换StringBuffer的指定范围
  • public StringBuffer replace(int start,int end,String str)
• 修改StringBuffer的指定位置
  • public void setCharAt(int index,char ch)

StringBuilder类

• 线程不安全,在单线程下使用,效率更高
• StringBuilder转String
  • public String toString()
  • public String(StringBuffer sbuf)//String类
• String转StringBuilder
  • public StringBuilder(String str)

3.4 集合框架

• 用于存储一组任意引用数据类型的容器

Collections类

• 对集合进行升序排序
  • public static void sort(List list)
• 获取给定集合的最大元素
  • public static T max(Collection coll)
• 获取给定集合的最小元素
  • public static T min(Collection coll)

Arrays类

• 对数组进行升序排序
  • public static void sort(T[] a)
• 复制指定的数组
  • public static 数据类型[] copyOf( 数据类型[] original,int newLength)
• 数组转List集合
  • public static List asList(T… a)
• List集合转数组
  • public Object toArrays()
  • public Object toArrays(T[] ar)
  • 注 : 需定义一个明确类型的数组和集合
• 比较两个数组是否相等
  • public static boolean equals(T[] a1, T[] a2)
• 获取指定数组的哈希码
  • public static int hashCode(T[] a)
• 获取指定数组的内容的字符串表示形式
  • public static String toString(T[] a)

LinkedList类

• 底层基于双链表存储(横向存储)，实现了List接口和Deque双端队列
• 创建LinkedList对象
  • public LinkedList<>()
  • LinkedList linkedList = new LinkedList<>();
• 插入第一个元素
  • public void addFirst(Object obj)
• 将指定的元素追加到此列表的末尾
  • public void addLast(Object obj)
• 删除第一个元素
  • public Object removeFirst()
• 删除最后一个元素
  • public Object removeLast()
• 获取第一个元素
  • public Object getFirst()
• 获取最后一个元素
  • public Object getLast()

ArrayList类

• 底层基于动态数组存储(纵向存储)
• 创建ArrayList对象
  • public ArrayList()
  • ArrayList arrayList = new ArrayList<>();
• 追加任意元素到集合末尾或指定位置
  • public void add(Object obj)
  • public void add(int index,Object obj)
• 合并集合
  • public void addAll(Object obj)
• 删除指定位置上的元素,返回删除元素
  • public Object remove(int index)
• 删除指定元素,不存在返回false
  • public boolean remove(Object obj)
• 从列表中删除所有元素
  • public void clear()
• 修改指定位置上的原有元素
  • public Object set(int index,Object obj)
• 获取指定位置上的元素
  • public Object get(int index)
• 获取指定元素第一次出现的位置
  • public int indexOf(Object obj)
• 获取指定元素最后一次出现的位置
  • public int lastIndexOf(Object obj)
• 获取元素的个数
  • public int size()
• 判断指定元素是否为集合中的元素
  • public boolean contains(Object obj)
• 判断集合是否为空
  • public boolean isEmpty()
• Iterator迭代器
  • 创建Iterator 名 = 集合名.Iterator();
  • 获取迭代器对象
    • public Iterator iterator()
  • 获取元素
    • Object next()
  • 判断集合是否有元素
    • boolean hasNext()

HashSet类

• 基于哈希值存储
• 创建集合
  • public HashSet<>()
  • HashSet hashSet = new HashSet<>();
• 追加指定的元素
  • public boolean add(Object obj)
• 删除所有元素
  • public void clear()
• 删除指定元素
  • public boolean remove(Object obj)
• 获取集合长度
  • public int size()
• 判断指定元素是否为集合中的元素
  • public boolean contains(Object obj)
• 判断集合是否为空
  • public boolean isEmpty()

HashMap类

• 由两个单列集合组成，以key-value键值对的形式存储
• 创建集合
  • public HashMap<k,v>()
  • HashMap<String, Object> hashMap = new HashMap<>();
• 清空集合
  • public void clear()
• 若key存在则替换value并返回旧值，若key不存在则存储键值对
  • V put(K key, V value)
• 根据key值删除对应的键值对，若key不存在则返回null
  • V remove(Object key)
• 根据key-value键值对删除对应的映射关系
  • boolean remove(Object key, Object value)
• 根据key值替换对应的value值，若key不存在则返回null
  • V replace(K key, V value)
• 根据key-value键值对替换对应的value值
  • boolean replace(K key, V oldValue, V newValue)
• 根据key值获取value值
  • V get(Object key)
• 获取集合中的所有key
  • Set keySet()
• 获取集合中的所有value
  • Collection values()
• 获取集合中的所有key-value实体对的集合
  • Set<Map.Entry<String,Integer>> entrySet()
• 获取集合中键值对的个数
  • int size()
• 判断集合中是否存在指定key值
  • boolean containsKey(Object key)
• 判断集合中是否存在指定value值
  • boolean containsValue(Object value)
• 判断集合是否为空
  • boolean isEmpty()

3.5 泛型与枚举

泛型

• 目的 : 为避免任意数据都可存储到集合中形成脏数据
• 格式 : 集合类型<泛型> 集合名 = new 集合类型<泛型>();
• 集合中使用 : 使元素只存储一张特定数据类型
• 方法中使用 :
  public <泛型> 返回值 方法名([参数]){ 方法体; }
• 类中使用 :
  public class 类名<泛型>{
    //泛型不能在本类中使用静态方法
    private 泛型类型 属性名;
    public 类名(泛型 名){
      this.名 = 名;
    }
  }

枚举

• 简化单例设计模式代码复杂性
• 格式 :
  public enum 枚举类类名{
   枚举对象1,枚举对象2,…;
  }
  ①有参构造器

public enum A{
	TIGER("虎");//等效于A TIGER = new A("虎");
	private A(String a){}
}

②使用抽象方法

public enum A{
	TIGER("虎"){
		public void print(){
			system.out.print("***");
		}
	}
	private A(String a){}
	public abstract void print();
}

• 枚举类方法
  • 获取枚举对象名
    • public String name()
  • 获取枚举对象的序数
    • public int ordinal()
  • 获取具有指定名称的指定枚举类型的枚举常量
    • public static valueOf(Enum enumType,String name)
  • 获取枚举对象
    • public static valueOf(String name)
  • 获取所有枚举对象
    • public static T[] valueOf()

3.6 反射机制

• 动态获取该类的任意一个类成员
• 适用场景:实例化对象困难
  ①没有提供构造器
  ②需直接调用抽象类中普通方法,成员属性,构造器
  ③框架底层源码都是单例设计模式
• 获取Class类
  ①反射机制实现 : 类名.class
  ②public final Class getClass()
  ③Class.forName(String path)
  ④类名.class.getClassLoader.LoadClass(String path)

Class类

• 获取与给定字符串名称的类或接口相关联的类对象
  • public static Class forName(String className)
• 获取指定类所有属性
  • public Field[] getDeclaredFields()
• 根据指定属性名获取对应Field对象
  • public Field getDeclaredField(String name)
• 获取指定类所有构造器
  • public Constructor[] getConstructors()
• 根据指定类有参构造器获取Constructor对象
  • public Constructor getConstructor(Class … Types)
• 获取指定类的无参构造器
  • public T newInstance()
• 获取指定类所有方法
  • public Method[] getDeclaredMethods()
• 根据指定方法名和参数列表获取方法对象
  • public Method getDeclaredMethod(String name,Class … Types)

Field类

• 获取操作私有化属性对象
  • public void setAccessible(boolean flag)
• 根据类对象获取属性值
  • public Object get(Object obj)
• 根据类对象设置属性值
  • public void set(Object obj,Object value)

Constructor类

• 获取指定类的有参构造器
  • public T newInstance(Object… Types)

Method类

• 获取操作私有化方法对象
  • public void setAccessible(boolean flag)
• 设置指定类中方法的参数值
  • public Object invoke(Object obj,Object… args)
  • 注 : 静态方法Object obj为null/this.class

3.7 文件与流

File类

• 指定父路径下定义指定子路径
  • public File(File parent,String child)
• 指定父路径下创建文件对象
  • public File(String pathname)
• 创建文件
  • public boolean createNewFile()
• 删除文件
  • public boolean delete()
• 程序终止删除文件
  • public void deleteOnExit()
• 修改文件名和类型
  • public boolean renameTo(File dest)
  • 注 : 若文件名一致,则创建新的文件
• 获取文件的绝对路径(操作文件)
  • public File getParentFile()
• 获取文件的绝对路径(操作文件路径)
  • public File getParentPath()
• 获取文件名
  • public String getName()
• 获取指定路径下所有文件
  • public File[] listFiles()
• 判断指定路径下是否存在该文件
  • public boolean exists()
• 判断路径是否为绝对路径
  • public boolean isAbsolute()
• 判断是否为文件夹
  • public boolean isDirectory()
• 判断是否为普通文件
  • public boolean isFile()
• 判断是否为隐藏文件
  • public boolean isHidden()

四大基流 八大子流

• Reader ----- 字符流中的输入流
  • FileReader/BufferedReader
• Writer ----- 字符流中的输出流
  • FileWriter/BufferedWriter
• InputStream ----- 字节流中的输入流
  • FileInputStream/BufferedInputStream
• OutputStream ----- 字节流中的输出流
  • FileOutputStream/BufferedOutputStream
• 注 : 四大基流为抽象类需同具体实现类完成操作

Reader类

• 读文件中一个字符
  • public int read()
• 将字符读入数组
  • public int read(char[] cbuf)
• 将字符读入数组的一部分
  • public abstract int read(char[] cbuf,int off,int len)
• 关闭流资源
  • public abstract void close()

FileReader类

• 读取实体文件
  • public FileReader(String fileName)
• 继承抽象父类Reader中的方法

BufferedReader类

• 实例化对象
  • public BufferedReader(Reader in)
• 读一行文字
  • public String readLine()
• 继承抽象父类Reader中的方法

Writer类

• 文件末尾追加字符
  • public Writer append(char c)
• 向文件中写入一个字符数组或一部分
  • public void write(char[] cbuf)
  • public abstract void write(char[] cbuf,int off,int len)
• 写一个字符
  • public void write(int c)
• 写一个字符串或一部分
  • public void write(String str)
  • public void write(String str,int off,int len)
• 将流资源中数据刷新到目的文件中
  • public abstract void flush()
• 刷新后关闭流资源
  • public abstract void close()

FileWriter类

• 创建实体文件
  • public FileWriter(String fileName)
• 继承抽象父类Write类中的方法

BufferedWriter类

• 实例化对象
  • public BufferedWriter(Writer out)
• 不同操作系统实现换行
  • public void newLine()
• 继承抽象父类Write类中的方法

InputStream类

• 从输入流读取字节数据
  • public abstract int read()
• 从输入流读取字节数组
  • public int read(byte[] b)
• 从输入流读取len字节的数据到一个字节数组
  • public int read(byte[] b,int off,int len)
• 关闭流资源
  • public void close()

FileInputStream类

• 实例化对象
  • public FileInputStream(String name)
• 继承抽象父类InputStream中的方法

BufferedInputStream类

• 实例化对象
  • public BufferedInputStream(InputStream in)
• 获取从该输入流中可以读取（或跳过）的字节数的估计值
  • public int available()

OutputStream类

• 将指定的字节写入此输出流
  • public abstract void write(int b)
• 将b.length字节从指定的字节数组写入此输出流
  • public void write(byte[] b)
• 从指定的字节数组写入len字节，从偏移off开始输出到此输出流
  • public void write(byte[] b,int off,int len)
• 关闭流资源
  • public void close()

FileOutputStream类

• 实例化对象
  • public FileOutputStream(String name)
• 继承抽象父类OutputStream中的方法

BufferedOutputStream类

• 实例化对象
  • public BufferedOutputStream(OutputStream out)

3.8 网络编程

• 三要素 : 指定IP地址、指定设备收发数据、协议
• 传输模式:

UDP(离线)	TCP(在线)
面向无连接	面向连接
传输快	传输慢
传输数据量小	传输数据量大
不安全	安全

InetAddress类

• 根据主机名获取InetAddress对象
  • public static InetAddress getByName(String host)
• 获取本机对应的InetAddress对象
  • public static InetAddress getLocalHost()
• 获取IP地址
  • public String getHostAddress()
• 获取此IP地址主机名
  • public String getHostName()

DatagramSocket类(UDP)

• 实例化对象
  • public DatagramSocket()
• 发送数据报包
  • public void send(DatagramPacket p)
• 接收数据报包
  • public void receive(DatagramPacket p)
• 关闭资源
  • public void close()

DatagramPacket类(UDP)

• 构造一个DatagramPacket用于发送数据包length
  • public DatagramPacket(byte[] buf,int length,InetAddress address,int port)
• 构造一个DatagramPacket用于接收数据包length
  • public DatagramPacket(byte[] buf,int length)
• 获取该数据报发送或接收数据报的计算机的IP地址
  • public InetAddress getAddress()
• 获取该数据报的字节数组
  • public byte[] getData()
• 获取该数据报的数据长度
  • public int getLength()

public class UDPSender {
	public static void main(String[] args){
		DatagramSocket ds = null;
		InetAddress inet = null;
		try {
			ds = new DatagramSocket();
			String str = "我要发送数据了";
			byte[] data = str.getBytes();
			inet = InetAddress.getLocalHost();
			DatagramPacket packet = new DatagramPacket(data, 0, data.length, inet, 8899);		
			ds.send(packet);
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(ds != null) {
				ds.close();
			}
		}
	}
}

public class UDPReceiver {
	public static void main(String[] args) {
		DatagramSocket ds = null;
		DatagramPacket packet = null;
		try {
			ds = new DatagramSocket(8899);
			byte[] buffer = new byte[1024];
			packet = new DatagramPacket(buffer, 0, buffer.length);
			ds.receive(packet);
			System.out.println(new String(packet.getData(),0,packet.getLength()));
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(ds != null) {
				ds.close();
			}
		}
	}
}

Socket类(TCP客户端)

• 创建流套接字并将其连接到指定IP地址的指定端口号
  • public Socket(InetAddress address,int port)
• 获取此套接字的输出流
  • public OutputStream getOutputStream()
• 获取此套接字的输入流
  • public InputStream getInputStream()

ServerSocket类(TCP服务端)

• 创建绑定到指定端口的服务器套接字
  • public ServerSocket(int port)
• 侦听要连接到此套接字并接受它
  • public Socket accept()

public class TCPClient {
	public static void main(String[] args) {
		Socket socket = null;
		OutputStream os = null;
		try {
			socket = new Socket(InetAddress.getByName("127.0.0.1"), 8899);
			os = socket.getOutputStream();
			os.write("我是客户端".getBytes());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(socket != null) {
				try {
					socket.close();
				} catch (Exception e2) {
				}
			}
			if(os != null) {
				try {
					os.close();
				} catch (Exception e2) {
				}
			}
		}
	}
}

public class TCPServer {
	public static void main(String[] args) {
		ServerSocket s = null;
		Socket so = null;
		InputStream is = null;
		ByteArrayOutputStream bao = null;
		try {
			s = new ServerSocket(8899);
			so = s.accept();
			is = so.getInputStream();
			bao = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int len;
			while ((len = is.read(buffer)) != -1) {
				bao.write(buffer, 0, len);
			}
			System.out.println(bao.toString());
		} catch (Exception e) {
		} finally {
			if(bao != null) {
				try {
					bao.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(is != null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(so != null) {
				try {
					so.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(s != null) {
				try {
					s.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}