首页 > 代码库 > 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、反射
声明:以上内容来自用户投稿及互联网公开渠道收集整理发布,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任,若内容有误或涉及侵权可进行投诉: 投诉/举报 工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。