首页 > 代码库 > JAVA-day12-IO3、反射

JAVA-day12-IO3、反射

import java.io.*;
class Demo1 
{
	public static void main(String[] args)throws IOException 
	{
		/*
          PrintStream:打印流,具备字节输出流的基本功能,添加了打印功能
		  是一个可以向目的写入的输出流
		  目的:File
		        字符串形式的路径
				字节输出流
   
		*/

		PrintStream ps = new PrintStream("tt.txt");
        //一次写入一个字节
		//ps.write(353);//00000000 00000000 00000001 01100001  把低8位的一个字节写入

		ps.println(353);//按照数据原样儿写入,也就是数据的表现形式,内部使用了转成字符串的功能,String.valueOf()

		ps.write(String.valueOf(353).getBytes());


	}
}


import java.io.*;
class Demo2 
{
	public static void main(String[] args) throws IOException
	{
		/*
         PrintWriter:字符打印流,字符输出流的基本功能都具备
		 目的:File
		       字符串形式的路径
			   字节输出流
			   字符数出流

		*/

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		//PrintWriter pw = new PrintWriter(System.out,true);

		PrintWriter pw2 = new PrintWriter(new FileWriter("t.txt"),true);


		String line = null;
		while((line = br.readLine())!=null)
		{
			if("over".equals(line))
				break;
           
			pw2.println(line);
			//pw.flush();

		}


	}
}

//序列流:SequenceInputStream
import java.io.*;
import java.util.*;
class  Demo3
{
	public static void main(String[] args) throws IOException
	{ /*
		FileInputStream fis1= new FileInputStream("Demo1.java");
		FileInputStream fis2= new FileInputStream("Demo2.java");
		FileInputStream fis3= new FileInputStream("Demo3.java");


		Vector<FileInputStream> v= new Vector<FileInputStream>();
		v.add(fis1);
		v.add(fis2);
		v.add(fis3);

		Enumeration<FileInputStream>  en = v.elements();*/

		ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();

        for(int i=1;i<=3;i++)
		{
			list.add(new FileInputStream("Demo"+i+".java"));
		}

		Enumeration<FileInputStream> en = Collections.enumeration(list);

		SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("hebing2.java");

		byte[] b = new byte[1024];
		int len = 0;

		while((len = sis.read(b))!=-1)
		{
			fos.write(b,0,len);
		}

		sis.close();
		fos.close();







	}
}


//分割文件
import java.io.*;
import java.util.*;
class  Demo4
{
	public static void main(String[] args)throws IOException 
	{
		File file = new File("C:\\Users\\qq\\Desktop\\ok.jpg");
		splitFile(file);
	}
    //分割文件
	public static void splitFile(File file)throws IOException
	{
	    if(!file.isFile())
		{
			System.out.println("不是文件");
			return;
		}

		//创建存储被分割出来的文件的目录
		File dir = new File("fenge");
		if(!dir.exists())
			dir.mkdir();

		FileInputStream fis = new FileInputStream(file);

		FileOutputStream fos = null;

        byte[] arr = new byte[1024*1024*2];
		int len = 0;
        int num = 1;
		while((len = fis.read(arr))!=-1)
		{
			fos = new FileOutputStream(new File(dir,(num++)+".suipian"));
			fos.write(arr,0,len);
		}
     
         //这几个被分割出来的文件上传之后,使用者不知道文件类型和一共有
		 //几个分割出的文件,应该把这些信息以配置文件的形式告诉使用者 

		 Properties pro = new Properties();

		 pro.setProperty("filetype",file.getName());
		 pro.setProperty("fileNumber",Integer.toString(--num));

         fos = new FileOutputStream(new File(dir,"config.properties"));

		 pro.store(fos," ");


	     fis.close();
		 fos.close();
	
	
	}
}

import java.io.*;
class Person implements Serializable//标记接口
{
	static final long serialVersionUID = 42L;

	private /*static*/ String name;//被静态修饰的成员不参与序列化
	private  /*transient*/ int age;  //瞬态的成员不参与序列化

	public Person(){}

	public Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public String getName()
	{
		return this.name;
	}

	public int getAge()
	{
		return this.age;
	}


}
class  Demo5
{
	public static void main(String[] args)throws IOException,ClassNotFoundException
	{
		//writeObject();
        readObject();
	}
    //反序列化 
	//对象是依赖于其所属的类的,有那个class才会有对象 
	public static void readObject()throws IOException,ClassNotFoundException
	{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

		Person person = (Person)ois.readObject();//5964614836505496678    -2747677651716560467

		System.out.println(person.getName()+","+person.getAge());
	}

	//写入对象
    //序列化:把一个对象写入到一个目的--对象的持久化
	public static void writeObject()throws IOException 
	{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

		oos.writeObject(new Person("lisi",23));//5964614836505496678 Person.class

		oos.close();
	}
}

import java.io.*;
class Demo6 
{
	public static void main(String[] args)throws IOException 
	{
		/*
          RandomeAccessFile:
		     随机访问文件的流类
			 只能访问文件
			 内部既有字节输入流也有字节输出流
			 内部定义了一个字节数组,并通过指针操作该数组,所以能随机访问 
		*/

		//writeFile();
        //readFile();
		rw();
	}

	public static void rw()throws IOException 
	{
	    RandomAccessFile  raf = new RandomAccessFile("rw.txt","rw");

		raf.seek(30);
		raf.writeUTF("你好");

	    long index = raf.getFilePointer();

	    System.out.println("index="+index);

        raf.seek(30);
		String ss = raf.readUTF();
		System.out.println(ss);
	
	
	}
	public static void readFile()throws IOException 
	{
		 RandomAccessFile  raf = new RandomAccessFile("temp.txt","r");
         byte[] arr = new byte[4];
		 int len = 0;
		 len = raf.read(arr);

		 int age = raf.readInt();
		 System.out.println(new String(arr,0,len)+","+age);

		 long index = raf.getFilePointer();

	     System.out.println("index="+index);

		 raf.seek(15);

		 len = raf.read(arr);
		 age = raf.readInt();

         System.out.println(new String(arr,0,len)+","+age);
	}



	public static void writeFile()throws IOException
	{
		//文件不存在会自动创建
	   RandomAccessFile  raf = new RandomAccessFile("temp.txt","rw");
	   raf.write("刘能".getBytes());
	   raf.writeInt(58);

	   long index = raf.getFilePointer();//得到指针指向的位置

	   raf.seek(15);

	   raf.write("赵四".getBytes());
	   raf.writeInt(56);

	   index = raf.getFilePointer();

	   System.out.println("index="+index);

	
	
	}
}

import java.io.*;
class  Demo7
{
	public static void main(String[] args)throws IOException 
	{
		/*
		用于操作基本数据类型的流类 
        DataInputStream  DataOutputStream


		*/

		writeData();
		readData();
	}

	public static void readData()throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

		int a = dis.readInt();
		boolean boo = dis.readBoolean();
		double d = dis.readDouble();

		System.out.println(a+","+boo+","+d);
	}

	public static void writeData()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

		dos.writeInt(34);
		dos.writeBoolean(false);
		dos.writeDouble(45.56);

		dos.close();
	}
}

import java.io.*;
class  Demo8
{
	public static void main(String[] args)throws IOException 
	{
		/*
         内存流:
		 ByteArrayInputStream:内部有一个字节数组
		 ByteArrayOutputStream: 内部有一个字节数组,直接写入了自己内部的字节数组了


        */

		ByteArrayInputStream du = new ByteArrayInputStream("owieurwoeir".getBytes());

		ByteArrayOutputStream xie = new ByteArrayOutputStream();

		byte[] arr = new byte[1024];
		int len = 0;

		while((len =du.read(arr))!=-1)
		{
			xie.write(arr,0,len);
		}

		System.out.println(new String(xie.toByteArray()));





	}
}

import java.io.*;
import java.util.*;
import java.text.*;
class Demo10 
{
	public static void main(String[] args) throws IOException
	{
		try
		{
			int[] arr = new int[3];
			System.out.println(arr[3]);
		}
		catch (Exception e)
		{
			Date d = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss");
			String ss = sdf.format(d);


            PrintStream ps = new PrintStream("bug.txt");
			ps.println(ss);

            System.setOut(ps);
			e.printStackTrace(System.out);
		}

	}
}

/*
二:有五个学生,每个学生有3门课的成绩,
从键盘输入以上数据(包括姓名,三门课成绩),
输入的格式:如:zhagnsan,30,40,60计算出总成绩,
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。

1:描述一下学生
2:定义个操作学生的工具类
*/
import java.io.*;
import java.util.*;
class Student  implements Comparable<Student>
{
	private String name;
	private int math,china,eng;
	private int sum;

	public Student(){}

	public Student(String name,int math,int china,int eng)
	{
		this.name =name;
		this.math = math;
		this.china = china;
		this.eng = eng;
		sum = math+china+eng;
	}
	public int compareTo(Student stu)
	{
		int num = this.sum-stu.sum;
		return num==0?this.name.compareTo(stu.name):num;
	}
    public int getSum()
	{
        return this.sum;
    }
	public int getMath()
	{
	    return this.math;
	}
	public int getChina()
	{
		return this.china;
	}
	public int getEng()
	{
		return this.eng;
	}
    public String toString()
	{
	   return "Student["+name+","+math+","+china+","+eng+"]";
	}


}
//操作学生的工具类
class StuTool
{   
	public static Set<Student> getStudents()
    {
	   return getStudents(null);
	}
	
	//读取键盘录入的学生信息,并存入集合
	public static Set<Student>  getStudents(Comparator<Student> com)throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		TreeSet<Student>   students;
		if(com!=null)
               students = new  TreeSet<Student>(com);
		else
               students = new  TreeSet<Student>();

		String line = null;
		for(int i=1;i<=3;i++)
		{
		   System.out.println("请输入第"+i+"个学员的信息");
		   line = br.readLine();
		   String[] arr = line.split(",");
		   Student stu = new Student(arr[0],Integer.parseInt(arr[1]),Integer.parseInt(arr[2]),Integer.parseInt(arr[3]));

           students.add(stu);
		}
		return students;

	}

	//把学员信息存入文件

	public static void saveToFile(Set<Student> students)throws IOException
	{
	     BufferedWriter  bw = new BufferedWriter(new FileWriter("stud.txt"));
         
		 for(Student stu:students)
		 {
		     bw.write(stu.toString()+"\t");
			 bw.write(""+stu.getSum());
			 bw.newLine();
			 bw.flush();
		 }

		 bw.close();
	}
}
class Demo11 
{
	public static void main(String[] args) throws IOException
	{
		Comparator<Student>  com = Collections.reverseOrder();

		Set<Student>  s = StuTool.getStudents(com);

		StuTool.saveToFile(s);

		
	}
}

import  java.io.*;
class Demo12 
{
	public static void main(String[] args)throws IOException  
	{
		//转换流的编码问题
		//writeFile();
		readFile();
	}
    public static void readFile()throws IOException
	{
		InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk.txt"),"utf-8");
		char[] ch = new char[10];
		int len = 0;
		len = isr.read(ch);
		System.out.println(new String(ch,0,len));
	}

	public static void writeFile()throws IOException 
	{
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");
		osw.write("你好");
		osw.close();

	}
}

/*
编码:家里有事,速回。----》电报文
       
	   byte[] getBytes() 
          使用平台的默认字符集将此 String 编码为 byte 序列 
	   byte[] getBytes(String charsetName) 
          使用指定的字符集将此 String 编码为 byte 序列 

解码:电报文-----》家里有事,速回。
      String(byte[] bytes) 
          通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。
      String(byte[] bytes, Charset charset) 
          通过使用指定的 charset 解码指定的 byte 数组,构造一个新的 String


编码编对了,解码就能解对
编码编错了,就不可能解对
*/
import java.util.*;
class  Demo13
{
	public static void main(String[] args)throws Exception
	{
		String ss ="你好";
		byte[] b = ss.getBytes("gbk");
		System.out.println(Arrays.toString(b));

        //解码解错了
		String str = new String(b,"ISO8859-1");
		System.out.println(str);

		//解决解码解错了的问题

       byte[] arr = str.getBytes("ISO8859-1");

       //使用gbk进行解码
	   String s = new String(arr);
	   System.out.println(s);



	}
}

class Demo14 
{
	public static void main(String[] args) 
	{
		String ss = "我的联通";

		byte[] b = ss.getBytes();

		for(byte num:b)
		{
			System.out.println(Integer.toBinaryString(num&255));
		}
	}
}


import java.io.*;
class Demo1 
{
	public static void main(String[] args)throws IOException 
	{
		/*
          PrintStream:打印流,具备字节输出流的基本功能,添加了打印功能
		  是一个可以向目的写入的输出流
		  目的:File
		        字符串形式的路径
				字节输出流
   
		*/

		PrintStream ps = new PrintStream("tt.txt");
        //一次写入一个字节
		//ps.write(353);//00000000 00000000 00000001 01100001  把低8位的一个字节写入

		ps.println(353);//按照数据原样儿写入,也就是数据的表现形式,内部使用了转成字符串的功能,String.valueOf()

		ps.write(String.valueOf(353).getBytes());


	}
}
import java.io.*;
class Demo2 
{
	public static void main(String[] args) throws IOException
	{
		/*
         PrintWriter:字符打印流,字符输出流的基本功能都具备
		 目的:File
		       字符串形式的路径
			   字节输出流
			   字符数出流

		*/

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		//PrintWriter pw = new PrintWriter(System.out,true);

		PrintWriter pw2 = new PrintWriter(new FileWriter("t.txt"),true);


		String line = null;
		while((line = br.readLine())!=null)
		{
			if("over".equals(line))
				break;
           
			pw2.println(line);
			//pw.flush();

		}


	}
}
//序列流:SequenceInputStream
import java.io.*;
import java.util.*;
class  Demo3
{
	public static void main(String[] args) throws IOException
	{
		FileInputStream fis1= new FileInputStream("Demo1.java");
		FileInputStream fis2= new FileInputStream("Demo2.java");
		FileInputStream fis3= new FileInputStream("Demo3.java");


		Vector<FileInputStream> v= new Vector<FileInputStream>();
		v.add(fis1);
		v.add(fis2);
		v.add(fis3);

		Enumeration<FileInputStream>  en = v.elements();

		SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("hebing.java");

		byte[] b = new byte[1024];
		int len = 0;

		while((len = sis.read(b))!=-1)
		{
			fos.write(b,0,len);
		}

		sis.close();
		fos.close();







	}
}



import java.io.*;
class Demo1 
{
	public static void main(String[] args)throws IOException 
	{
		/*
          PrintStream:打印流,具备字节输出流的基本功能,添加了打印功能
		  是一个可以向目的写入的输出流
		  目的:File
		        字符串形式的路径
				字节输出流
   
		*/

		PrintStream ps = new PrintStream("tt.txt");
        //一次写入一个字节
		//ps.write(353);//00000000 00000000 00000001 01100001  把低8位的一个字节写入

		ps.println(353);//按照数据原样儿写入,也就是数据的表现形式,内部使用了转成字符串的功能,String.valueOf()

		ps.write(String.valueOf(353).getBytes());


	}
}
import java.io.*;
class Demo2 
{
	public static void main(String[] args) throws IOException
	{
		/*
         PrintWriter:字符打印流,字符输出流的基本功能都具备
		 目的:File
		       字符串形式的路径
			   字节输出流
			   字符数出流

		*/

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		//PrintWriter pw = new PrintWriter(System.out,true);

		PrintWriter pw2 = new PrintWriter(new FileWriter("t.txt"),true);


		String line = null;
		while((line = br.readLine())!=null)
		{
			if("over".equals(line))
				break;
           
			pw2.println(line);
			//pw.flush();

		}


	}
}
//序列流:SequenceInputStream
import java.io.*;
import java.util.*;
class  Demo3
{
	public static void main(String[] args) throws IOException
	{ /*
		FileInputStream fis1= new FileInputStream("Demo1.java");
		FileInputStream fis2= new FileInputStream("Demo2.java");
		FileInputStream fis3= new FileInputStream("Demo3.java");


		Vector<FileInputStream> v= new Vector<FileInputStream>();
		v.add(fis1);
		v.add(fis2);
		v.add(fis3);

		Enumeration<FileInputStream>  en = v.elements();*/

		ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();

        for(int i=1;i<=3;i++)
		{
			list.add(new FileInputStream("Demo"+i+".java"));
		}

		Enumeration<FileInputStream> en = Collections.enumeration(list);

		SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("hebing2.java");

		byte[] b = new byte[1024];
		int len = 0;

		while((len = sis.read(b))!=-1)
		{
			fos.write(b,0,len);
		}

		sis.close();
		fos.close();







	}
}


反射



package com.qianfeng.reflect;

public class Demo1 {

	public Demo1() {
		// TODO Auto-generated constructor stub
	}

	/**
	 *反射:动态获取类(class)及类中成员,并对类中的成员运行
	 *
	 *怎么获取到Class对象
	 *
	 *动态获取Person.class对象
	 *获取方式有三种:
	 *1:使用Object中的getClass()方法
	 *   需要先创建对象,所以的需要其所属的类实现存在 
	 *:2:每个数据类型都有一个静态的属性class,通过该属性可以得到其所属的字节码文件对象
	 *    不需要创建对象了,但是需要那个类存在
	 * 3:Class.forName()只需要提供一个字符串,这个字符串的内容是类的名字
	 * 
	 */
	public static void main(String[] args) throws ClassNotFoundException {
		
		//getClass1();
		//getClass2();
		getClass3();
    
	}

	private static void getClass3() throws ClassNotFoundException {
		Class claz = Class.forName("com.qianfeng.reflect.Person");
		
		System.out.println(claz);
		
	}

	private static void getClass2() {
		
		Class claz1 = Person.class;
		Class claz2 = Person.class;
		
		System.out.println(claz1==claz2);
	}

	private static void getClass1() {
		
		 Person p1 = new Person();
		 Class claz = p1.getClass();//Person.class
		 
		 
		 Person p2 = new Person();
		 Class claz2 = p2.getClass();//Person.class
		 
		 System.out.println(claz==claz2);
		 
	}
}









package com.qianfeng.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {

	public Demo2() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 动态获取类并创建对象 
	 * @throws ClassNotFoundException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 * @throws SecurityException 
	 * @throws NoSuchMethodException 
	 * @throws InvocationTargetException 
	 * @throws IllegalArgumentException 
	 */
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		
         createObj1();
         createObj2();
	}
    //使用带参数的构造方法创建对象
	private static void createObj2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//Person  p = new Person("lisi",23);
		Class claz = Class.forName("com.qianfeng.reflect.Person");
		
		Constructor cons = claz.getConstructor(String.class,int.class);
		
		Object obj = cons.newInstance("lili",23);
		
		System.out.println(obj);
		
	}

	private static void createObj1() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		//Person  p = new Person();
		
		Class claz = Class.forName("com.qianfeng.reflect.Person");//Person.class
		
		Object obj = claz.newInstance();//用的是默认的空参数的构造方法
		
		System.out.println(obj);
		
	}
	
	

}

package com.qianfeng.reflect;

import java.lang.reflect.Field;

public class Demo3 {

	public Demo3() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 动态创建对象并给属性赋值 
	 * @throws ClassNotFoundException 
	 * @throws SecurityException 
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
		
        accessField1();
	}
   //动态创建对象并给属性赋值 
	private static void accessField1() throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
		//Person p = new Person();
		//p.name = "";
		Class claz = Class.forName("com.qianfeng.reflect.Person");
		
		//Field field = claz.getField("name");//只能获取公共的成员属性
		Field field = claz.getDeclaredField("name");//只要是在类中的声明的就可以得到
		
		//创建一个Person类型的对象
		Object obj = claz.newInstance();
		
		//设置可以访问该属性---暴力访问
		field.setAccessible(true);
		
		field.set(obj, "zhangsan");
		
		System.out.println(obj);
		
		
	}
}















package com.qianfeng.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo4 {

	public Demo4() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 动态执行类中的方法
	 * @throws ClassNotFoundException 
	 * @throws SecurityException 
	 * @throws NoSuchMethodException 
	 * @throws InvocationTargetException 
	 * @throws IllegalArgumentException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		
		invokeMethod1();
		invokeMethod2();
		invokeMethod3();

	}
	
    private static void invokeMethod3() throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    	Class claz = Class.forName("com.qianfeng.reflect.Person");
    	
    	Method m = claz.getMethod("fun",null);
    	
    	m.invoke(null,null);
	}

	private static void invokeMethod2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    	Class claz = Class.forName("com.qianfeng.reflect.Person");
    	
    	Method m = claz.getMethod("method", String.class);
    	
    	//创建对象
    	Object obj = claz.newInstance();
    	
    	m.invoke(obj, "haha");
		
	}

	//执行无参数的方法
	private static void invokeMethod1() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		
		//Person p = new Person();
		//p.show();
		Class claz = Class.forName("com.qianfeng.reflect.Person");
		
		//得到方法
		Method   m = claz.getMethod("show",null);
		
		//创建对象
		Object obj = claz.newInstance();
		
		m.invoke(obj, null);		
	}

}

















JAVA-day12-IO3、反射