java学习总结（三）

最新推荐文章于 2022-01-23 19:01:26 发布

DiecoDu

最新推荐文章于 2022-01-23 19:01:26 发布

阅读量424

点赞数

本文链接：https://blog.csdn.net/DiecoDu/article/details/80407392

版权

Reader和Writer

* 字符流:
*        字符输入流:Reader
*        字符输出流:Writer
* 字符输出流/字符输入流:都是抽象类
*        使用一个子类:转换流

* 字符输出流的构造方法
* public OutputStreamWriter(OutputStream out):使用默认的编码格式构造一个字符转换输出流对象
* public OutputStreamWriter(OutputStream out, Charset cs):使用指定编码格式构造一个字符转换输出流对象
*
* 转换流的构成=字节流+编码格式(平台默认/指定)
*
*
* 转换流的对象的创建,格式比较长,非常麻烦,Java--->转换流的便捷类
* Reader:抽象类:字符输入流
*        inputStreamReader(字符转换输入流 :inputStream+编码格式)
*                便捷类:FileReader,这个类可以直接对文件进行操作
*
* Writer:抽象类:字符输出流
*        outputStreamWriter(字符转换输出流:outputStream+编码格式)
*                便捷类:FileWriter,这个类可以直接对文件进行操作

*计算机如何存储中文的?
*   当前平台默认编码集 :GBK 一个中文两个字节
*       第一个字节:一定是负数
*       第二个字节:一般是负数,可能也会是正数,不会影响的结果.

public abstract class Reader

extends Objectimplements Readable, Closeable

Reader用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

InputStreamReader和OutputStreamWriter

*字符转换输入流:InputStreamReader
*InputStreamReader(InputStream in) :构造一个字符转换输入流,默认编码
*public InputStreamReader(InputStream in,Charset cs) 构造一个字符转换输入流,指定编码
*字符转换输入流=字节流+编码格式

FileReader和FileWriter

*字符输入流读数据的方法:

* int read(char[] chs):读取一个字符数组

* int read():读取单个字符

*字符输出流写数据的功能:
*   public void write(int c):写单个字符
*   public void write(char[] cbuf):写字符数组
*   public abstract void write(char[] cbuf, int off, int len):写字符数组的一部分
*   public void write(String str):写字符串
*   public void write(String str,int off, int len):写字符串的某一部分

创建对象：

FileReader fr = new FileReader("文件路径") ;

BufferdeReader和BufferedWriter

字符缓冲输入流BufferedReader特有方法：

public String readLine()
                throws IOException

功能：读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。

字符缓冲输出流BufferedWriter的特有方法：

注意其中的flush方法

public void newLine()
             throws IOException

功能：写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 ('\n') 符。

注意其中的flush方法

public void flush()
           throws IOException

刷新该流的缓冲。防止缓冲流中数据没有录入就进行了输出操作，将输入数据刷新出来。

*BufferedReader:字符缓冲输入流

* 构造方法

* public BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流。

* public BufferedReader(Reader in, int sz)创建一个使用指定大小输入缓冲区的缓冲字符输入流。

*BufferedWrier:文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
* 构造方法
* BufferedWriter(Writer out) :默认缓冲区大小构造字符缓冲输出流对象

* BufferedWriter(Writer out,int size):指定缓冲区大小

应用实例：

（一）

 *  需求：把ArrayList集合中的字符串数据存储到文本文件
 * 
 * `		ArrayList集合存储的元素String,可以存储一些字符串
 * 			使用增强for遍历ArrayList
 * 			使用BufferedWriter(文本文件)
 * 
 * 
 * 源文件:ArrayList<String>
 * 目的地:BufferedWriter输出文本文件,给文件中写入字符
 *

    public class ArrayListToFileTest {

	    public static void main(String[] args) throws Exception {
		
		//创建一个ArrayList集合
		ArrayList<String>  list  = new ArrayList<String>() ;
		//添加元素
		list.add("hello") ;
		list.add("world") ;
		list.add("java") ;
		list.add("hello") ;
		
		//创建一个字符缓冲输出流
		BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt")) ;
		
		//遍历
		for(String s:list) {
			//将集合中元素写入到流中
			bw.write(s);
			bw.newLine();
			bw.flush();
		}
		
		//关闭资源
		bw.close();
	    }
    }

（二）

 *需求:有一个文本文本,需要将文本文件中的内容放到ArrayList集合中,遍历集合获取元素 
 *
 *源文件:b.txt----->读取---->BuffferedReader
 *目的地:ArrayList<String>
 *
 */
    public class FileToArrayListTest {
	
	    public static void main(String[] args) throws Exception {
		
		//封装源文件
		BufferedReader br = new BufferedReader(new FileReader("b.txt")) ;
		
		//创建一个ArrayList集合
		ArrayList<String> list = new ArrayList<String>() ;
		
		//读b.txt文件的内容
		String line = null ;
		while((line=br.readLine())!=null) {
			//将数据添加到集合中
			list.add(line) ;
		}
		
		//遍历集合
		for(String s:list) {
			System.out.println(s);
		}
		
		//关闭流
		br.close();
	    }
    }

（三）

 *需求：有一个文本文件中存储了几个名称，请写一个程序实现随机获取一个人的名字。 
 *
 *
 *	1)封装一个文本文件:使用字符缓冲输入流读文件
 *	2)创建一个ArrayList<String>
 *	3)使用字符缓冲输入流readLine(),一次读取一行,就将该行数据添加到集合中
 *	4)创建Random类对象
 *	5)Random类对象.nextInt(集合对象.size()) ;
 *	6)通过角标get(int index ):获取内容
 *
 */
    public class Test {
	
	    public static void main(String[] args) throws Exception {
		
		//封装文件
		BufferedReader br = new BufferedReader(new FileReader("b.txt")) ;
		//创建一个集合
		ArrayList<String> array = new ArrayList<String>() ;
		
		//一次读取一行
		String line = null ;
		while((line=br.readLine())!=null) {
			//将数据添加到集合
			array.add(line) ;
		}
		
		//释放资源
		br.close(); 
		//创建Random类对象
		Random r = new Random();
		
		//获取随机数
		int index = r.nextInt(array.size()) ;
		//通过角标查找集合中元素
		String name = array.get(index) ;
		System.out.println("幸运的人是:"+name);
	    }
    }

一些其他流

*内存操作流:适用于临时存储文件.
*       内存操作输入流:ByteArrayInputStream
*       ByteArrayInputStream(byte[] buf)
*       内存操作输出流: ByteArrayOutputStream （该流不需要关闭）
*       构造方法:ByteArrayOutputStream()
*内存操作流:一个程序结束后,那么这些程序的变量,就会从内存消失(马上消失的这些数据进行读取写入)

*打印流
* 字符打印流(针对文本进行操作:PrintWriter)

* 字节打印流(printStream 和标准输出流有关系 System.out;)

*PrintWriter:属于输出流

*           1)只能写数据(只能针对目的地文件进行操作),不能读数据(不能针对源文件进行操作)
*           2)可以针对文件直接进行操作
*               如果一个类中的构造方法里面有File对象或者String类型数据,这个类可以对文本文件直接操作
*               FileInputStream
*               FileOutputStream
*               FileWriter
*               FileReader..
*               PrintWriter
*           3)自动刷新功能::PrintWriter(OutputStream out/Writer out,boolean autoflush);第二个参数如果是true 表示启动自动刷新功能
*           4)打印的方法:print(XXX x)/println(XXX xx)

应用实例：

（一）

 *源文件:StringDemo.java		--->BufferedReader
 *目的文件:Copy.java   ----->PrintWriter
 *
    public class CopyFileDemo {

	    public static void main(String[] args) throws IOException {
		
		//封装文件
		BufferedReader br = new BufferedReader(new FileReader("StringDemo.java")) ;
		PrintWriter pw = new PrintWriter(new FileWriter("Copy.java",true)) ;
		
		//一次读取一行
		String line = null ;
		while((line=br.readLine())!=null) {
			//向打印输出内容
			pw.println(line);
			
		}
		
		//释放资源
		pw.close();
		br.close();
	    }
    }

（二）

public class PrintWriterDemo {

	public static void main(String[] args) throws IOException {
		
		//创建一个字符打印流对象
		PrintWriter pw = new PrintWriter(new FileWriter("pw.txt")) ;
		// PrintWriter pw1 = new PrintWriter(new FileWriter("pw2.txt"), true) ;//启动了自刷新
		//写数据
		/*pw.write("hello");
		pw.write("world");
		pw.write("java");*/
		
		pw.println("hello");//本身自动换行并且向pw.txt文件打印内容
		
		pw.flush(); //本身在构造的时候,就可以启动自动刷新
		
		//关闭流
		pw.close();
	}
}

合并流：

SequenceInputStream 表示其他输入流的逻辑串联(合并流)
*构造方法

* public SequenceInputStream(InputStream s1, InputStream s2)

* public SequenceInputStream(Enumeration e) 需要与 Vector类中的elements结合使用

public Enumeration<E> elements()

返回此向量的组件的枚举。返回的 Enumeration 对象将生成此向量中的所有项。生成的第一项为索引 0 处的项，然后是索引 1 处的项，依此类推。

两种方式实例：

 需求：
 * 		a.txt+b.txt--->c.txt
 * StringDemo.java+SystemInDemo.java---->Copy.java
 *
 */
public class SequenceInputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		
		//封装源文件
		InputStream in1 = new FileInputStream("StringDemo.java") ;
		InputStream in2 = new FileInputStream("SystemInDemo.java") ;
		
		//创建合并流对象
		SequenceInputStream sis = new SequenceInputStream(in1, in2) ;
		//创建一个字节缓冲输入流对象
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("Copy.java"));
		
		//原来怎么读写,现在依然这样读写
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=sis.read(bys))!=-1) {
			bos.write(bys, 0, len);
			bos.flush(); //读图片文件的时候
		}
		
		//关闭资源
		sis.close();
		bos.close();
		
	}
}

 *	将多个输入流对象进行合并
 *	a.txt+b.txt+c.txt--->d.txt
 *	
 *
 */
public class SequenceInputStreamDemo2 {
	
	public static void main(String[] args) throws IOException {
		//StringDemo.java+SystemInDemo.java+PrintWriterDemo.java--->Copy.java文件中
		
		//定义一个集合Vector
		Vector<InputStream> v  = new Vector<InputStream>() ;
		//使用InputStream封装文件
		InputStream s1 = new FileInputStream("StringDemo.java") ;
		InputStream s2 = new FileInputStream("SystemInDemo.java") ;
		InputStream s3 = new FileInputStream("PrintWriterDemo.java") ;
		
		//将流对象添加到集合中
		v.add(s1) ;
		v.add(s2) ;
		v.add(s3) ;
		
		//特有功能
		Enumeration<InputStream> en = v.elements() ;
		
		//创建合并输入流对象
		SequenceInputStream sis = new SequenceInputStream(en) ;
		//创建字节缓冲输出流对象
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java")) ;
		
		//一次读取一个字节数组
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=sis.read(bys))!=-1) {
			bos.write(bys, 0, len);
			bos.flush();
		}
		
		//关闭资源
		bos.close();
		sis.close();
	}
}

标准的输入输出流
*       InputStream in = System.in
*       PrintStream out = Syste.out ;
*
*    jdk5以后,Java--->Scanner(InputStream in)
*标准输入流
*   键盘录入
*       1)Scanner

* 2)BufferedReader里面包装字符转换输入流,包装System.in

注意：对应字节流时，不能实现一次读取一行，字节流不能用BufferedReader包装

*标准输出流

* PrintStream ps = System.out ;

注意：该类有println方法，无print方法

*使用BufferedWriter 去包装System.out

* BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out))

序列化流

* Serializable:接口没有构造方法,没有字段,也没有方法
* 接口---->标记接口
*
* 自定义类要实现序列化功能,必须实现接口Serializable接口
* 类中transient修饰的属性不会被序列化

* 类实现了serializable也意味着他是标记类

* 假设之前操作针对Peroson操作序列的时候,产生一个标记类.class--->固定ID 100

* 因为手动修改了这些类的属性/成员变量,将序列化版本Id改变了

* InvalidClassException:一般情况:该类的序列版本号与从流中读取的类描述符的版本号不匹配

* 实际开发中,不想多次对当前这些序列化,让当前实现类序列化功能的这个类产生一个固定ID,注意看程序有黄色警告线,直接就点它固定Id

*序列化:将对象按照流的方式存储到文本文件中或者再网络中传输对象---->流数据序列化流 (ObjectOutputStream)

构造：ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("文件路径+文件名称")）；

oos.writeObject(某实体类的对象)；

*反序列化:将文本文件中的流对象或者网络传输中的流对象还原成对象流数据--->对象反序列化流(ObjectInputStream)

构造：ObjectInputStream ois = new ObjectInputStream(new FileInputStream("文件路径+文件名称")）；

Object obj = ois.readObject();

属性集合类

Properties:表示了一个持久的属性集(简称:属性集合类) extends Hashtable<K,V> Map集合的
* 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

* public Properties():无参构造

属性集合类的特有功能:
*       public Object setProperty(String key, String value) :给属性列表中添加键和值,并且强制都使用String
*       public Set<String> stringPropertyNames():遍历的功能
*       public String getProperty(String key)用指定的键在此属性列表中搜索属性

可保存在流中或从流中加载,只能使用属性集合类
*public void store(Writer writer,String comments):把集合中的数据保存文本文件中(属性集合)

*public void load(Reader reader):将文本文件中的数据加载到属性集合中

store方法中，如果 comments 变量非 null，则首先将 ASCII # 字符、注释字符串和一个行分隔符写入输出流。因此，该 comments 可用作一个标识注释。注释中换行 ('\n')、回车 ('\r') 或回车后直接跟着换行，这些字符中的任意一个都由 Writer 生成的行分隔符替换，如果注释中下一个字符不是 # 字符或 ! 字符，则在该行分隔符后写出 ASCII #。

应用实例：

 * 我有一个文本文件(user.txt)，我知道数据是键值对形式的，但是不知道内容是什么。
  请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其实为”100
  
  1)读取文件的内容,将文件内容加载属性集合类中
  2)遍历属性集合,获取所有的键的集合
  3)遍历的键的时候,可以判断是否有"lisi"这样一个键
  4)有的话,就更改
  5)需要将当前属性集合类中的保存文本文件中
 *
 */
public class PropertiesTest {
	
	public static void main(String[] args) throws IOException {
		
		//创建属性集合类对象
		Properties prop = new Properties() ;
		
		//读取文本文件内容加载到集合中
		FileReader fr = new FileReader("user.txt") ;
		prop.load(fr); 
		fr.close(); 
		
		//遍历属性集合
		//获取所有的键的集合
		Set<String> keySet = prop.stringPropertyNames() ;
		for(String key:keySet) {
			//判断
			if("lisi".equals(key)) {
				//更改
				prop.setProperty(key, "100") ;
			}
		}
		
		//将属性集合中的数据保存文本文件中
		FileWriter fw = new FileWriter("user.txt") ;
		prop.store(fw, "content");
		fw.close();

	}
}

多线程

     * JVM:Java虚拟机识别main(主线程)
     面试题:
     *     JVM是多线程程序吗?至少有几条线程..
     *    jvm是多线程的,
     *        至少有2条线程...
     *        有主线程,main..执行这些代码,能够被Jvm识别
     *        在执行一些程序的时候,一些对象Jvm释放掉,原因,
     *        它开启了垃圾回收线程,里面GC:垃圾回收器(回收一些没有更多引用的对象或者变量...)

     如何实现多线程程序呢?
     *    要实现多线程程序,需要开启进程,
     *    开启进程,是需要创建系统资源,但是Java语言不能创建系统资源
     *    只有C/C++可以创建系统资源, 利用c语言创建好的系统资源实现
     *    Java提供了一个类:Thread类
     *       实现多线程程序的步骤:
     *       1)将类声明为 Thread 的子类
     *       2)该子类应重写 Thread 类的 run 方法
     *       3)在主线程进行该自定义的线程类的对象的创建

     *并行和并发(高并发:MyBatis --->IBatis:半自动化)
     *强者逻辑上的同时,指的是同一个时间段内
     *后者物理上的同时,指的是同一个时间点

Thread 类提供了一些方法

* public static Thread currentThread():返回当前正在执行的线程对象的引用

* public final void setName(String name):给线程起名称
* public final String getName() :获取线程名称

创建一个执行线程类

第一种方式：

该类需要继承Thread类并重写run（）方法

第二种方式：
        1)自定义一个类,实现Runnable接口
        2)实现接口中的run方法,对耗时的代码进行操作
        3)然后在主线程中创建该了对象,将该类对象做为一个资源类,创建Thread类的对象,将刚才的资源类作为参数进行传递
举例：

public class ThreadDemo {
	
	public static void main(String[] args) {
		
		//创建当前类对象
		MyThread my =new MyThread() ;
		
		//实现多线程
		//public Thread(Runnable target,String name)
		Thread t1 = new Thread(my, "高圆圆") ;
		Thread t2 = new Thread(my, "赵又廷") ;
		
		//启动线程
		t1.start();
		t2.start();
	}
}

run()方法里面应该是一些耗时的操作,IO操作/循环语句..执行线程不是run方法

run方法的调用相当于一个普通方法的调用

public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。同一个线程只能被执行一次。

public final void setDaemon(boolean on) :true时,表示为守护线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。(守护线程不会立即结束掉,它会执行一段时间在结束掉)该方法必须在启动线程前调用。

public final void join():等待该线程终止 interruputedException 中断异常

public static void sleep(long millis):线程睡眠指定是时间毫秒值

throws InterruptedException

public final void stop() ;强迫线程停止执行。不会执行了 (过时了),方法能使用的
public void interrupt()中断线程。表示中断线程的一种状态

wait() : wait()调用,立即释放锁 (同步锁/Lock锁)

sleep() : 线程睡眠,调用不会释放锁

public static void yield()暂停当前正在执行的线程对象，并执行其他线程

跟线程优先级相关的方法:
public final int getPriority()返回线程的优先级。

public final void setPriority(int newPriority)更改线程的优先级

线程存在一个默认优先级

public static final int MAX_PRIORITY 10 最大优先级
public static final int MIN_PRIORITY 1 最小优先级

public static final int NORM_PRIORITY 5 默认优先级

小结：

重点：字符流及线程执行类创建

掌握相关Thread类的相关方法。熟练结合集合与IO。

DiecoDu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java学习总结（三）

Reader和Writerpublic abstract class Readerextends Objectimplements Readable, CloseableReader用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 InputStreamRead...
复制链接

扫一扫