新普金娱乐网址


地理【一】与君初相识,犹似故人归。

【都市】一起渡过的小日子(4)

JAVASE高级2地理

  • 三月 15, 2019
  • 地理
  • 没有评论

反射概述

前二日阿泉同学在微信上跟作者说刘先生退休了,再到新山时跟老师聚一聚。作者承诺着。

什么是反射?

那么些年间,去乌特勒支是时常的事儿,见导师同学是偶发的事情。

  反射的的概念是有smith一九八五年第二遍提议的,zhuy主借使指程序能够访问、检查和测试和改动它自个儿情状或行为的一种能力。

自家还想着刘先生也就2九虚岁不到,从北镇(现安顺)刚调到卡利,当大家的班CEO。他精瘦清瘦的,喜欢吸烟,站在那边偶尔还爱好抖抖腿;那时师母还没调到波特兰,他们两地分居,忘了当时她唯一的幼子有没有出生。

  JAVA反射机制是运营情况中,对于随意二个类,都能够精通那几个类的兼具属性和方式;对于随意二个对象,都能都调用它的即兴一个办法;

左右刘先生在我回想中可能小青年儿二个。怎么一须臾一挥间他就到退休的年华了啊?又一想,哦,眼看大家毕业都快30年了。

那种动态获取的新闻以及动态调用对象的方式的成效称为Java语言的反射机制。

这时候刘先生住单宿,偶尔周末会请各地的同校去他家打打牙祭。小编在他那边理解了“吃在北镇”的布道,也在教员职员和工人家学会了做“醋溜白菜”。那年寒假回家,给亲属用白菜梆子一步一趋般做了一道醋溜白菜,亲戚品过都觉着不错,于是那也成了本身的“拿手菜”之一。近期,每当笔者在厨房里捯饬着炒菜做饭,常会记忆一些人、一些事,因为那道醋溜白菜,便平常会回想刘先生。

  简单的话,反射机制指的是先后在运行时亦可得到自笔者的新闻。在JAVA中,只要给定类的名字,那么就足以经过反射机制来赢得类的具备音讯。

幸亏,除了做菜吃饭的这么些事,他教我们的《机械制图》笔者还没忘,是本身学得最好的课业之一。除了刚开端时对“三视图”的不开窍,后来本身的绘图向来没考过9五分以下。参预工作后所在的工厂有3遍摸底考试,理论课有一道制图题,我怎么也画不出,后来判断是题出错了,跟厂里总工程师讲,他说不或者,后来又跟技术厂长反映,他是高很多届的大家的同班,本身做了二遍,又看了自家画的立体图,说了句”题错了“。暗下的得意也是对教师职员和工人的谢谢,把大家教得科学,没给学校丢脸。

回顾其访问修饰符、父类、达成的接口、属性和方法的拥有音讯,并可在运行时创立对象、修改属性(包涵个人的)、调用方法(包蕴个人的)。

有三遍生病没去上课,在宿舍里脑瓜疼。笔者还记得跟老师说:老师您不明了自家头多致命啊!老师道:作者又不可能把您头割下来称称?笔者看看是用工程力学来解依旧用制图方法总结你的头多沉。

缘何要用反射机制?直接创制对象不就能够了么?那就涉及到了动态和静态的概念?

师资其实很庄敬有点不苟言笑,那是他的有趣,是自笔者听过的她唯一的玩笑话了。次日导师端来魅族粥,这是给自个儿的“病号饭”,是她协调在独立宿舍里有福同享熬的,未来追思,更是加剧了一份感恩和感激——老师对学生的那份用心,历久弥新。

  静态编写翻译:在编译时规定项目,绑定队形,即通过。

今天是教授节。于自笔者,每逢佳节,必有回顾。

       Student stu = new
Student(“zhangsan”,20);

其实自个儿是个相比较木讷的人。曾自嘲“小时怕老师,长大怕领导”。前段时间看对白羊座人的解析,说咱俩有”社交恐惧症“,小编给协调贴上标签,深以为然。每到节日都相比较低沉地问候示好,每逢教师节等,也亮堂至少要发些祝福的短信问候,但是……大约羞于启齿吧。

  动态编写翻译:运维时规定项目,绑定对象。动态编写翻译最大限度发挥了java的八面玲珑,展现了多态的行使,用以下落类之间的耦合性。

一对老师,已经忘了名字,但局地先生,一生难忘。

       Class.forName(“com.mysql.jdbc.Driver.class”).newInstance();

小学一年级,在乡村老家丁家界脉头小学,启蒙先生是庄会美(音)。大家老家向来尊尊敬老人师,老辈的人还习惯称老师为”先生“,当年村里找不出多少个识字的人的时候,写封信都要称二斤香油果子(
油条)跑几里路到道口请先生来信,所以庄会美老师在地方的出名度很高。她就如只教过大家多少个拼音字母就随爱人去蚌埠办事了。

  一句话,反射机制的亮点便是能够落成动态创制对象和编写翻译,展示出相当大的油滑,特点是在J2EE的支出中。

那阵子农村办小学学唯有几间破屋,“石桌子石凳子泥孩子“,2个体育场所装八个年级的上学的小孩子,老师教完一年级的a、o、e,布置写作业,再教二年级的课。

  它的老毛病是对质量有震慑。使用反射基本上是一种解释操作,那类操作总是慢于直接实施的均等操作。

作者妈曾说,那时候的民间兴办教授真厉害,一个人教语文算术美术唱歌体育不说,还教五个年级!小编还记得上学要和谐带杌子(一种方凳),学生写字有的还用石笔石板,夏日在学堂午间休息要带蓑衣,把蓑衣铺在课桌底上午睡。还记得有个男人调皮,捉了豆虫放在叁个女孩子的蓑衣上,吓得他花容失色,被庄先生告到家里……说起来也快40年没见过她了,再见,笔者不认得他她自然也不记得本人了。

Java反射机制首要提供了以下成效

二年级转学后去到的该校还叫“卫东红校”,后来恢复生机械学校名“实小”。班老板老师姓牛,我早就不记得她的大名也忘记她的容貌了,只记得他有一儿一女,儿子叫赵无产阶级文化大革时局动,呵,学校和教育者孩子的名字都有分明的一世印痕。四年级时又换了个姓李的班老总,也不记得名字,很凶的二个女生,大致作者采用性地对她进行了遗忘,但照旧尤其记得多少个根本事件。一是他曾给过自家的一篇写作9陆分的高分,刚学完《李四光》,《小编的优秀》作文写的是当贰个地质勘探队员,立志为祖国发掘宝藏,想想真没出息,小编的优异要是是地质学家至少能当队员吧?后来去法国巴黎在金融大学的酒店住过几天,还不满没在那边上过学。

  在运行时判断任意一个对象所属的类

也记得他在班上声讨同学写作文以“有叁遍”和“记得”先导。“你们不写‘记得’和‘有3遍’就不可能开首写作吗?!”所以,到今日自家还有个”毛病“,文字段落倘诺发轫是”有1遍“或”记得“,都会想起李先生的不容许,会无意地修改、替换掉。

  在运作时构建任意二个类的对象

小学四年级照旧五年级,有次作文课安排的是写电影的观后感《千万不要忘记》,作者平素没写过,就把电影的好玩的事情节复述了1回,洋洋洒洒写了最长的作文,被老师在课上批得狗血喷头。

  在运行时判断任意三个类所独具的分子变量和艺术

有三遍,今年自家居然特意写过一篇每一段都以”有1遍“起头的博客小说。以示记得。

  在运维时调用任意二个对象的法子

有鉴于此,小学老师对一个人的震慑有多大!小编的广大小学同学钢笔字写得那多少个好,并不曾专门学过书法,想来是受小学老师的熏陶。那时候小学老师的板书都尤其了得,庄先生、牛先生还有李先生,在黑板上的字自个儿现今记得都以令人”仰止“的万丈。

Class对象是Reflection有趣的事出自。要想操纵类中的属性和艺术,都必须从获得Class对象开首

再有从小学到中学遇到的另内科目标教育工我,比如小学的体育老师,带我们去孟庙上课讲张仪苏秦;比如历史助教,讲历史就象讲故事;比如地理教员,北京人,每回只带叁头粉笔来讲课,徒手画世界地图跃然纸上,作者迄今保留着他手刻的一份油印试卷,那硬笔书法才叫飘逸……

  类是先后的一片段,每一种类都有二个Class对象。换言之,每当编写并且编写翻译三个新类,就会爆发与之对应的2个Class对象。

比方自个儿幸运受过更高级的教诲,会遇见愈来愈多的好先生。其实正是走向社会,也遭遇过很多可称为师的师资。乌特勒支人习惯把全数人称呼为“老师”大致便是”五中国人民银行必有吾师“之意。

  Class类没有集体的构造方法。Class对象实际加载类时由JAVA虚拟机以及经过类加载器中的方法自动构造的,由此不可能显示地声称三个Class对象

自个儿上的初级中学是个新建校区,班COO是张先生。11月份随父参与她的战友聚会,还跟几个同学去拜访过她。看到助教肢体比几年前好了诸多,本人能下楼去活动活动了,甚感欣慰。

得到Class对象的艺术有各类

岁月越久纪念越长,好先生,值得感恩毕生。

 

喜欢丁是丁的稿子,欢迎关心、点赞和打赏,须要转发开白请简信联系,感激~~~

地理 1地理 2

 1 package com.ab.tzy;
 2 
 3 public class ClassDemo {
 4 public static void main(String[] args) {
 5     // 对像名.getClass()
 6     // Class<?> getClass() 返回此 Object 的运行时类。 
 7     Employee employee = new Employee("zhangsan",15);
 8     Class<?> classType = employee.getClass();
 9     //String getName() 以 String 的形式返回此 Class 对象所表示的实体(类、接口、数组类、基本类型或 void)名称。 
10     System.out.println(classType.getName());//com.ab.tzy.Employee
11     //Class<? super T> getSuperclass() 返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的超类的 Class。 
12     System.out.println(classType.getSuperclass().getName());//java.lang.Object
13     
14     //类名.class
15     Class<?> classType1 = Employee.class;
16     System.out.println(classType1.getName());//com.ab.tzy.Employee
17     System.out.println(classType1.getSuperclass().getName());//java.lang.Object
18     
19     //使用Class.forName();
20     //static Class<?> forName(String className)  返回与带有给定字符串名的类或接口相关联的 Class 对象。 
21     try {
22         Class<?> classType2=Class.forName("com.ab.tzy.Employee");
23         System.out.println(classType2.getName());//com.ab.tzy.Employee
24         System.out.println(classType2.getSuperclass().getName());//java.lang.Object
25     } catch (ClassNotFoundException e) {
26         e.printStackTrace();
27     }
28     //获取基本数据类型的Class对象
29     Class<?> classType3 = int.class;
30     System.out.println(classType3.getName());//int
31     //System.out.println(classType3.getSuperclass().getName());
32     // java.lang.NullPointerException
33     //通过基本数据类型的包装类来获取对应的基本数据类型所对应的Class对象
34     
35     //static Class<Integer> TYPE  表示基本类型 int 的 Class 实例。 (基本数据类型包装类都有该属性)
36     Class<?> classType4 = Integer.TYPE;
37     System.out.println(classType4.getName());//int
38     //System.out.println(classType4.getSuperclass().getName());
39     // java.lang.NullPointerException
40     
41     Class<?> classType5 = Integer.class;
42     System.out.println(classType5.getName());//java.lang.Integer
43     System.out.println(classType5.getSuperclass().getName());//java.lang.Number(除了character都是)
44     Class<?> classType6 = String.class;
45     System.out.println(classType6.getName());//java.lang.String
46     System.out.println(classType6.getSuperclass().getName());//java.lang.Object
47     Class<?> classType7 = Character.class;
48     System.out.println(classType7.getName());//java.lang.Character
49     System.out.println(classType7.getSuperclass().getName());//java.lang.Object
50     
51 }
52 }
53 
54 
55 class Employee{
56     private String name;
57     private int age;
58     public Employee(String name, int age) {
59         super();
60         this.name = name;
61         this.age = age;
62     }
63     public String getName() {
64         return name;
65     }
66     public void setName(String name) {
67         this.name = name;
68     }
69     public int getAge() {
70         return age;
71     }
72     public void setAge(int age) {
73         this.age = age;
74     }
75     
76 }

反射入门

 Java.lang.reflect库

Class类与java.lang.reflect类库一起对反射的概念进行支撑。

Java.lang包下

  Class<T>:表示三个正在周转的Java应用程序中的类和接口,是Reflection的源于

Java.lang.reflect包下:

  Field类:代表类的积极分子变量(成员变量也称为类的习性)。

  Method类:代表类的法门。

  Constructor类:代表类的协会方法.

  Array类:提供了动态创制数组,以及走访数组的因素的静态方法。

由此反射实例化对象

日常情形大家透过new
Object来生成三个类的实例,但有时候大家没办法直接new,只好通过反射动态变化。

实例化无参构造函数的指标,二种方式:

  Class.newInstance();

  Class.getConstructor(new Class[]{}).newInstance(new Object[]{})

实例化带参构造函数的对象

  clazz.getConstructor(Class<?>…parameterTyprs).newInstance(Object…initargs)

透过反射获取并调用方法

取妥贴前类以及超类的public
Method

  Method[] arrMethods = classType.getMethodes();

得到当前类评释的具有Method

  Method[] arrMethods = classType.getDeclaredMethodes();

获取当前类以及超类钦赐的public
Method

  Method[] arrMethod = classType.getMethode(String
name,Class<?>…parameterTypes);

取妥当前类证明的钦赐的Method

  Method[] arrMethod = classType.getDeclaredMethode(String
name,Class<?>…parameterTypes);

通过反射动态运营钦点Method

  Object obj = method.invoke(Object obj,Object…args);

 通过反射获取并调用属性

取安妥前类以及超类的public
菲尔德

  Field[] arrFields = classType.getFields();

得到当前类证明的具有Field

    Field[] arrFields = classType.getDeclaredFields();

获取当前类以及超类钦赐的public Field

  Field[] arrField = classType.getField();

取妥当前类证明的钦赐的Field

  Field[] arrField = classType.getDeclaredFields();

通过反射动态设定Field的值

  Field.set(Object obj,Object value)

 通过反射动态获取菲尔德的值

  Object obj = field.get(Object obj);

地理 3地理 4

  1 package com.ab.tzy;
  2 
  3 import java.lang.reflect.Constructor;
  4 import java.lang.reflect.Field;
  5 import java.lang.reflect.Method;
  6 
  7 public class ReflectionAPIDemo {
  8     public static void main(String[] args) throws Exception {
  9         // 获取Employee这个类所关联的Class对象
 10         Class<?> classType = Class.forName("com.ab.tzy.Employee");
 11         // 通过反射机制来构造一个Employee的实例对象
 12         // T newInstance() 创建此 Class 对象所表示的类的一个新实例。 (Class)
 13         Object newInstance = classType.newInstance();
 14         Employee employee = (Employee) newInstance;
 15         // java.lang.InstantiationException默认调用无参构造方法,如果雇员类里面没有无参就会包实例化异常
 16         System.out.println(employee);// Employee [name=null, age=0]
 17 
 18         // 调用指定的构造方法来构造对象(无参构造方法)
 19         // Constructor<T> getConstructor(Class<?>... parameterTypes)
 20         // 返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。 (Class)
 21         Constructor<?> constructor = classType.getConstructor(new Class[] {});
 22         // T newInstance(Object... initargs)
 23         // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。
 24         // (Constructor)
 25         Object newInstance2 = constructor.newInstance(new Object[] {});
 26         Employee employee2 = (Employee) newInstance2;
 27         System.out.println(employee2);// Employee [name=null, age=0]
 28 
 29         // 调用指定的构造方法来构造对象(无参构造方法)
 30         // Constructor<T> getConstructor(Class<?>... parameterTypes)
 31         // 返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。 (Class)
 32         Constructor<?> constructor3 = classType.getConstructor(new Class[] {String.class,int.class});
 33         // T newInstance(Object... initargs)
 34         // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。
 35         // (Constructor)
 36         Object newInstance3 = constructor3.newInstance(new Object[] {"张三",30});
 37         Employee employee3 = (Employee) newInstance3;
 38         System.out.println(employee3);// Employee [name=张三, age=30]
 39 
 40         //获取Class对象所指定的所有方法,包括私有的
 41         // Method[] getDeclaredMethods() 返回 Method 对象的一个数组,
 42         // 这些对象反映此 Class 对象表示的类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。 (Class)
 43         // Method[] getMethods() 返回一个包含某些 Method 对象的数组,这些对象反映此 Class 对象
 44         //所表示的类或接口(包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口)的公共 member 方法。  (Class)
 45         System.out.println("*****");
 46         Method[] methods = classType.getDeclaredMethods();
 47         for (Method method : methods) {
 48              //String getName()  以 String 形式返回此 Method 对象表示的方法名称。 
 49             //int getModifiers() 以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符。 
 50             // Class<?> getReturnType()  返回一个 Class 对象,该对象描述了此 Method 对象所表示的方法的正式返回类型。 
 51             System.out.println(method.getName()+"--"+method.getModifiers()+"--"+method.getReturnType());
 52         }
 53                 /*
 54                 toString--1--class java.lang.String
 55                 getName--1--class java.lang.String
 56                 setName--1--void
 57                 eat--2--class java.lang.String
 58                 work--2--void
 59                 setAge--1--void
 60                 getAge--1--int
 61                 work1--0--void
 62                 work2--4--void
 63                 */
 64         System.out.println("*****");
 65         
 66         //获取Class对象所指定的方法,包括私有
 67         // Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
 68         //返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 (Class)
 69         //获取Class对象所指定的方法,不包括私有
 70         // Method getMethod(String name, Class<?>... parameterTypes) 
 71         //返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定公共成员方法。 (Class)
 72         Method method = classType.getMethod("toString", new Class[]{});
 73         //String toString()    返回描述此 Method 的字符串。 (Method)
 74         System.out.println(method);
 75         //public java.lang.String com.ab.tzy.Employee.toString()
 76         //String getName() 以 String 形式返回此 Method 对象表示的方法名称。 (Method)
 77         System.out.println(method.getName());//toString
 78         Object desc = method.invoke(employee3, new Object[]{});
 79         System.out.println(desc);//Employee [name=张三, age=30]
 80         //方法的调用
 81         // Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
 82         //返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 (Class)
 83         Method method1 = classType.getDeclaredMethod("eat", new Class[]{String.class});
 84         // Object invoke(Object obj, Object... args) 
 85         //对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。 (Method)
 86         System.out.println(method1.getName());//eat
 87          //void setAccessible(boolean flag) 将此对象的 accessible 标志设置为指示的布尔值。
 88         //(method父类AccessibleObject的方法)
 89         method1.setAccessible(true);
 90         Object desc1 = method1.invoke(employee3, new Object[]{"拉拉"});
 91         System.out.println(desc1);//拉拉
 92         //java.lang.IllegalAccessException非法访问异常  必须要调用一个权限方法设置
 93         
 94         
 95         //获取Class对象所指定的属性,包括私有的
 96         Field field = classType.getDeclaredField("name");
 97         //void setAccessible(boolean flag) 将此对象的 accessible 标志设置为指示的布尔值。
 98         //(field父类AccessibleObject的方法和method共同的父类)
 99         field.setAccessible(true);
100         // void set(Object obj, Object value) 
101         //将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 (Field)
102         field.set(employee3, "李四");
103         // String toString() 返回一个描述此 Field 的字符串。 (Field)
104         System.out.println(field);//private java.lang.String com.ab.tzy.Employee.name
105         // Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。 (Field)
106         System.out.println(field.get(employee3));//李四
107         // Field getDeclaredField(String name) 
108         //返回一个 Field 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明字段。 (Class)
109         
110         // Field[] getDeclaredFields() 
111         //返回 Field 对象的一个数组,这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。 (Class)
112         
113         //  Field getField(String name) 返回一个 Field 对象,它反映此 Class 对象所表
114         //示的类或接口的指定公共成员字段。 (Class)
115         
116         // Field[] getFields()  返回一个包含某些 Field 对象的数组,这些对象反映此 Class 对象所表
117         //示的类或接口的所有可访问公共字段。 (Class)
118         
119     }
120 }
121 
122 class Employee {
123     private String name;
124     private int age;
125 
126     public Employee() {
127         super();
128     }
129 
130     public Employee(String name, int age) {
131         super();
132         this.name = name;
133         this.age = age;
134     }
135 
136     public String getName() {
137         return name;
138     }
139 
140     public void setName(String name) {
141         this.name = name;
142     }
143 
144     public int getAge() {
145         return age;
146     }
147 
148     public void setAge(int age) {
149         this.age = age;
150     }
151 
152     @Override
153     public String toString() {
154         return "Employee [name=" + name + ", age=" + age + "]";
155     }
156     private String eat(String s){
157         return s;
158     }
159     private void work(){
160         System.out.println("我要工作---私有");
161     }
162     void work1(){
163         System.out.println("我要工作---默认");
164     }
165     protected  void work2(){
166         System.out.println("我要工作---保护");
167     }
168 }

反射常用

地理 5地理 6

 1 package com.abc.tzy;
 2 
 3 import java.lang.reflect.Array;
 4 
 5 public class ArrayDemo {
 6     public static void main(String[] args) throws Exception {
 7         //创建一个一维数组(String)
 8         Class<?> classType = Class.forName("java.lang.String");
 9         //static Object         newInstance(Class<?> componentType, int length) 
10         //创建一个具有指定的组件类型和长度的新数组。 (Array)
11         Object array = Array.newInstance(classType, 5);
12         //static void             set(Object array, int index, Object value) 
13         //将指定数组对象中索引组件的值设置为指定的新值。 
14         Array.set(array, 3, "abc");
15         //static Object get(Object array, int index) 
16         //返回指定数组对象中索引组件的值。 
17         //System.out.println(Array.get(array, 5));
18         // java.lang.ArrayIndexOutOfBoundsException
19         System.out.println(Array.get(array, 3));//abc
20         
21         //创建一个二维数组(3行3列)
22         //static Object newInstance(Class<?> componentType, int... dimensions) 
23         //创建一个具有指定的组件类型和维度的新数组。 
24         int [] dimens={3,3};
25         Object array1 = Array.newInstance(int.class, dimens);
26         Object arrayobj = Array.get(array1, 2);//获取第三行(就是一个一维数组)
27         //static void setInt(Object array, int index, int i) 
28         //将指定数组对象中索引组件的值设置为指定的 int 值。 (基本数据类型方法相似)
29         Array.setInt(arrayobj, 2, 10);//给指定数组位置的元素赋新值
30         int [] [] arr = (int[][]) array1;
31         for (int[] is : arr) {
32             for (int i : is) {
33                 System.out.print(i+"\t");
34             }
35             System.out.println();
36         }
37         //0       0      0    
38         //0    0    0    
39         //0    0    10    
40 
41     }
42 }

反射成立数组

反射总计

假设利用反射,先获得Class对象。

从未有过主意能获取当前类的超类的private方法和总体性,你必须透过getSuperclass()找到超类现在再去尝尝获得

常常状态正是是日前类,private属性或方法也是不能够访问的,你须要设置压制权限setAccessible(true)来博取private的访问权。但说实话,那早已磨损了面向对象的条条框框,

于是除非万不得已,请尽量少用。

地理 7地理 8

  1 package com.abc.tzy;
  2 
  3 import java.lang.reflect.Field;
  4 import java.lang.reflect.InvocationTargetException;
  5 import java.lang.reflect.Method;
  6 
  7 public class ReflectionDemo {
  8     public static void main(String[] args) {
  9         // 2生成一个学生对象(被赋值的哪个对象,源对象)
 10         Student stu = new Student(1, "张三", 30);
 11         try {
 12             Student copystu = (Student) ObjectCopyUtil.copyObj(stu);
 13             System.out.println("复制对象成功");
 14             System.out.println(copystu);
 15         } catch (InstantiationException e) {
 16             e.printStackTrace();
 17         } catch (IllegalAccessException e) {
 18             e.printStackTrace();
 19         } catch (NoSuchMethodException e) {
 20             e.printStackTrace();
 21         } catch (SecurityException e) {
 22             e.printStackTrace();
 23         } catch (IllegalArgumentException e) {
 24             e.printStackTrace();
 25         } catch (InvocationTargetException e) {
 26             e.printStackTrace();
 27         }
 28     }
 29 }
 30 
 31 //复制对象成功
 32 //Student [id=1, name=张三, age=30]
 33 
 34 
 35 /**
 36  * 这是一个Copy对象的工具类,内部提供了一个Copy对象的方法,接受源对象
 37  * 
 38  * @author Administrator
 39  *
 40  */
 41 class ObjectCopyUtil {
 42     public static Object copyObj(Object obj) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
 43         // 3获取Student对象所对应类型的Class对象(也就是Student这个类所对应的Class对象)
 44         Class<?> classType = obj.getClass();
 45         // 4通过Class对象的newInstance方法构建一个目标对象。
 46         Object objRes = classType.newInstance();
 47         // 5获取Class对象的set和get方法
 48         Field[] fields = classType.getDeclaredFields();
 49         for (Field field : fields) {
 50             
 51             // 得到属性所对应的get和set方法
 52             // String substring(int beginIndex) 返回一个新的字符串,它是此字符串的一个子字符串。
 53             // String substring(int beginIndex, int endIndex)
 54             // 返回一个新字符串,它是此字符串的一个子字符串。
 55             // String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
 56             // String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
 57             String getMethodName = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);// 拼接getId
 58             String setMethodName = "set" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);// 拼接SetId
 59             //调用源对象的get方法获取属性值
 60             Method getMethod = classType.getDeclaredMethod(getMethodName, new Class[]{});//方法名 参数
 61             Object value = getMethod.invoke(obj, new Object[]{});
 62             //调用源对象的set方法给属性赋值
 63             // Class<?> getType()  返回一个 Class 对象,它标识了此 Field 对象所表示字段的声明类型。 
 64             Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]{field.getType()});//参数类型就是属性的类型
 65             setMethod.invoke(objRes, new Object[]{value});
 66             /*
 67             //方法二:
 68             field.setAccessible(true);
 69             // Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。 
 70             Object value1 = field.get(obj);
 71             // void set(Object obj, Object value) 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 
 72             field.set(objRes, value1);
 73             */
 74         }
 75         return objRes;
 76     }
 77 }
 78 
 79 // 1申明一个学生类
 80 class Student {
 81     private int id;
 82     private String name;
 83     private int age;
 84 
 85     public Student(int id, String name, int age) {
 86         super();
 87         this.id = id;
 88         this.name = name;
 89         this.age = age;
 90     }
 91 
 92     public int getId() {
 93         return id;
 94     }
 95 
 96     public void setId(int id) {
 97         this.id = id;
 98     }
 99 
100     public String getName() {
101         return name;
102     }
103 
104     public void setName(String name) {
105         this.name = name;
106     }
107 
108     public int getAge() {
109         return age;
110     }
111 
112     public void setAge(int age) {
113         this.age = age;
114     }
115 
116     public Student() {
117         super();
118     }
119 
120     @Override
121     public String toString() {
122         return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
123     }
124 
125 }

通过反射赋值对象

 

线程方式

什么样是先后:

  安装在磁盘上的一段指令集合,它是静态的定义。

如何是进程:

  它是运作中的程序,是动态的定义。每种进度都有单独的财富空间。

什么是线程:

  线程,又称作轻量级进程,是程序执行流的微乎其微单元,是先后中二个纯粹的顺序控制流程。线程是进程中的三个事例,是被系统独立调度和分担的着力单位。

如何是多线程:

  三十二线程则指的是在单个程序中得以同时运营多少个例外的线程执行不相同的职分。

二十十六线程的特征:

  二个顺序能够分包1个或多少个线程。

  3个程序实现八个代码同时交替运维就要求发出三个线程。

  线程本人不负有系统财富,与同属2个进程的其他线程共享所在经过所兼有的能源。

  同一进度中的多个线程之间能够并发执行。CPU会随机抽出事件,让我们的顺序一会做那件工作,一会做另一件业务。

八线程的目标:

  正是“最大限度地选用CPU能源”,当某一线程的处理不须要占用CPU而只和I/O等财富打交道时,让急需占用CPU能源的其它线程有机遇得到CPU能源。

从根本上说,那正是多线程编制程序的指标。

JAVA运维种类在很多方面注重于线程,所有的类库设计都考虑到多线程。JAVA是纯面向对象语言,JAVA的线程模型也是面向对象的。

线程模型

由此持续Thread类创造线程

  普通JAVA类如继续自Thread类,就改成多少个线程类,并可由此此类的start方法来运转线程,执行线程代码。

  Thread类的子类可一贯实例化,但在子类中务必覆盖run方法才能真的运转线程的代码。

地理 9地理 10

 1 package com.abc.tzy;
 2 
 3 public class HelloThreadDemo {
 4 public static void main(String[] args) {
 5     Thread thread1 = new HelloThread("a");
 6     //void setName(String name) 改变线程名称,使之与参数 name 相同。 
 7     //thread1.setName("线程1");
 8     thread1.start();
 9     Thread thread2 = new HelloThread();
10     thread2.setName("线程2");
11     thread2.start();
12 }
13 }
14 
15 
16 class HelloThread extends Thread{
17     public HelloThread(String name){
18         super(name);
19     }
20     public HelloThread(){
21         super();
22     }
23     @Override
24     public void run() {
25         for (int i = 0; i < 5; i++) {
26             // String getName()  返回该线程的名称。 
27             System.out.println(this.getName()+":"+i);
28         }
29     }
30 }

extends—>Thread

透过落实Runnable接口成立线程

  贯彻Runnable借口的类必须借助Thread类才能成立线程。通过Runnable接口创制线程分为两步:

    创制实现Runnable接口的类的实例。

    创立三个Thread类对象,将第二步实例化获得的Runnable对象作为参数字传送入Thread类的构造方法。

  透过Thread类的start方法运维线程

地理 11地理 12

 1 package com.abc.tzy;
 2 
 3 public class RunnableDemo {
 4 public static void main(String[] args) {
 5     HelloRunnable helloRunnable = new HelloRunnable();
 6     Thread t1 = new Thread(helloRunnable,"A");
 7     t1.start();
 8     Thread t2 = new Thread(helloRunnable,"B");
 9     t2.start();
10 }
11 }
12 //避免单继承的局限,一个类可以实现多个接口,但只能继承一个类
13 //适合资源的共享
14 class HelloRunnable implements Runnable{
15 
16     @Override
17     public void run() {
18         for (int i = 0; i < 5; i++) { 
19             //static Thread     currentThread() 返回对当前正在执行的线程对象的引用。 
20             System.out.println(Thread.currentThread().getName()+":"+i);
21         }
22     }
23 }

implements–>Runnable

 

地理 13地理 14

 1 package com.abc.tzy;
 2 
 3 public class SharedDataThreadDemo {
 4 public static void main(String[] args) {
 5     TicketThread s1 = new TicketThread("一号窗口");
 6     s1.start();
 7     TicketThread s2 = new TicketThread("二号窗口");
 8     s2.start();
 9 }
10 }
11 
12 
13 class TicketThread extends Thread{
14     private static int ticket = 5;//加上static变成静态变量就可以实现卖五张
15     public TicketThread(String name){
16         super(name);
17     }
18     @Override
19     public void run() {
20         while(true){
21             System.out.println(this.getName()+":"+(ticket--));
22             if(ticket<1){
23                 break;
24             }
25         }
26     }
27 }

卖票Thread

地理 15地理 16

 1 package com.abc.tzy;
 2 
 3 public class SharedDataThreadDemo {
 4 public static void main(String[] args) {
 5     TicketRunnable run = new TicketRunnable();
 6     Thread t1 = new Thread(run, "一号窗口");
 7     t1.start();
 8     Thread t2 = new Thread(run, "二号窗口");
 9     t2.start();
10     
11 }
12 }
13 
14 //不需要设置静态变量就可以数据共享
15 class TicketRunnable implements Runnable{
16     private int ticket = 5;
17     @Override
18     public void run() {
19         while(true){
20             System.out.println(Thread.currentThread().getName()+":"+(ticket--));
21             if(ticket<1){
22                 break;
23             }
24         }
25     }
26 }

卖票Runnable

 

线程的生命周期

线程状态:

  与人的生老病死一样,线程野同样要经历新建、就绪、运转(活动)、阻塞和寿终正寝多种区别的场所。那七种状态都足以因此Thread类中的方法举办支配。

始建并运营线程

  新建状态(New Thread)

    在JAVA语言中运用new操作符创制二个线程后,该线程仅仅是贰个空对象,它装有了线程的一对风味,但此时系统并未为其分配能源,那时的线程处于创制状态。

    线程处于创造状态时,可通过Thread类的艺术来安装线程各类品质,如线程的优先级(setPriority)、线程名(setName)和线程的种类(setDaemon)等。

  就绪状态(Runnable)

    使用start()方法运行二个线程后,系统为该线程分配了除CPU外的所需财富,使该线程处于就绪状态。其它,倘若有些线程执行了yield()方法,那么该线程会被方今

    剥夺CPU能源,重新进入就绪状态。

  运作景况(Running)

    JAVA运转种类通过调度选中一个处于就绪状态的线程,使其占用CPU并转为运维处境。此时,系统真正执行线程的run()方法。

      能够透过Thread类的isAlive方法来判定线程是或不是处在就绪/运营状态:当线程处于就绪/运营状态时,isAlive再次回到true,当isAlive再次回到false时,大概线程处于阻塞状

      态,也恐怕处于终止状态

  阻塞状态(Blocked)

    2个正值运维的线程因有个别原因不能够延续运行时,就进入阻塞状态。这一个缘故归纳:

      当执行了有些线程对象的sleep()等绿灯类型的艺术时,该线程对象会被置入三个堵塞集(Blocked
Pool)内,等待超时而自动苏醒。

      当四个线程试图跻身有些同步区域(synchronized)时,没能进入该联合区域的线程会被置入锁定集(Lock
Pool),知道得到该联合区域的锁,进入就绪状态。

      当线程执行了有些对象的wait()方法时,线程会被置入该对象的等待集(Wait
Pool)中,知道执行了该目标的notify()方法,wait()/notify()方法的履行要求线程首先获得到该指标的锁

  呜呼意况(Dead)

    线程在run()方法执行完结后跻身与世长辞情形。其余,假诺线程执行了interrupt()或stop()方法,那么它也会以越发退出的方法进入归西情形。  

甘休线程的二种办法:

  采纳退出标志,使线程寻常退出,也正是当run方法成功后线程终止,推荐应用。

  使用stop方法强行终止线程(这几个措施不引进应用,因为stop和suspend、resume一样,也说不定爆发不可预料的结果)。

  使用interrupt方法中断线程。

线程同步

为什么必要共同

  线程同步是为了避防万一七个线程访问二个数据对象时,对数码造成损坏

  线程的联合是承接保险十六线程安全访问竞争财富的一种手段。

一起和锁

  Java中种种对象都有三个内置锁。

  当程序运转到非静态的synchronized同步方法上时,自动获取与正在推行代码类的如今实例(this实例)有关的锁;当程序运营到synchronized同步代码块时,自动获取锁定目的的锁。

  获得一个指标的锁也叫做获取锁、锁定目的、在对象上锁定或在目的上一起。当程序运维到synchronized同步方法或代码块时该对象锁才起成效。

  三个指标只有贰个锁。所以,借使3个线程得到该锁,就从未有过别的线程能够获取锁,知道第三个线程释放锁。那也象征任何别的线程都不能够进入synchronized方法或代码块,知道该

  锁被放走。释放锁是指持锁线程退出了synchronized同步方法或代码块.

对于联合,一般而言在java代码中必要达成多个操作:

  把竞争访问的能源标识为private。

  同步那叁个访问财富的代码,使用synchronized关键字来修饰方法或代码块。当synchronized方法执行完或发生卓殊时,会自动释放锁。

看一下急需:

  某银行卡帐号上有500元现金。1个人拿着存折去取钱,同时另一位拿着卡去ATM机上取钱,各自取400元。

  需求取钱进程中无法出现财富竞争:比如400元被取出三回、银行卡的账面不可能小于0等.

地理 17地理 18

 1 package com.abc.tzy;
 2 
 3 public class BankDemo {
 4     public static void main(String[] args) {
 5         Bank bank = new Bank();
 6         BankThread p1 = new BankThread(bank, "取钱人1");
 7         p1.start();// 柜台取钱
 8         BankThread p2 = new BankThread(bank, "取钱人2");
 9         p2.start();// ATM取钱
10 
11     }
12 }
13 
14 class BankThread extends Thread {
15     private Bank bank = null;
16 
17     public BankThread(Bank bank, String name) {
18         super(name);
19         this.bank = bank;
20     }
21 
22     @Override
23     public void run() {
24             System.out.println(this.getName()+"取钱:" + bank.getMoney(300));
25     }
26 
27 }
28 
29 class Bank {
30     private int money = 500;
31 
32     // 取钱的方法,返回取钱的数目
33     // 当一个线程去调用同步方法的时候,这个线程就获取了当前对象的锁。
34     // 其他线程当调用同步方法的时候,只能等待,因为无法获取对象的锁。
35     // 只有等第一个线程释放对象的锁方可进入.
36     //this 位置上可以换成任何对象,获取哪个对象的锁不影响
37     public /* synchronized */ int getMoney(int number) {
38         synchronized (this) {
39             if (number < 0) {
40                 return -1;
41             } else if (money < 0) {
42                 return -2;
43             } else if (money < number) {
44                 return -3;
45             } else {
46                 try {
47                     // static void sleep(long millis)
48                     // 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。
49                     Thread.sleep(1000);// 模拟取钱的时间
50                 } catch (InterruptedException e) {
51                     e.printStackTrace();
52                 }
53                 money -= number;
54                 System.out.println("余额:" + money);
55             }
56             return number;
57         }
58     }
59 }

案例

 

一道发生死锁的原因

  当多少个线程已赢得了指标1的锁,同时又想博得对象2的锁。而此时另三个线程当前已具有了指标二的锁,而又想获取对象1的锁。那种互相等待对方释放锁的进度,会招致死锁。

地理 19地理 20

 1 package com.abc.tzy;
 2 
 3 public class DieThreadDemo {
 4 public static void main(String[] args) {
 5     Example ex = new Example();
 6     DieThread1 die1 = new DieThread1(ex);
 7     die1.start();
 8     DieThread2 die2 = new DieThread2(ex);
 9     die2.start();
10 }
11 }
12 
13 class DieThread1 extends Thread{
14     private Example example = null;
15 
16     public DieThread1(Example example) {
17         super();
18         this.example = example;
19     }
20     @Override
21     public void run() {
22         example.method1();
23     }
24 }
25 class DieThread2 extends Thread{
26     private Example example = null;
27 
28     public DieThread2(Example example) {
29         super();
30         this.example = example;
31     }
32     @Override
33     public void run() {
34         example.method2();
35     }
36 }
37 
38 
39 class Example{
40     private Object obj1 = new Object();
41     private Object obj2 = new Object();
42     public void method1(){
43         synchronized (obj1){
44             try {
45                 Thread.sleep(1000);
46             } catch (InterruptedException e) {
47                 e.printStackTrace();
48             }
49             synchronized (obj2){
50                 System.out.println("method1");
51             }
52         }
53     }
54     public void method2(){
55         synchronized (obj2){
56             try {
57                 Thread.sleep(1000);
58             } catch (InterruptedException e) {
59                 e.printStackTrace();
60             }
61             synchronized (obj1){
62                 System.out.println("method2");
63             }
64         }
65     }
66 }

死锁

 线程通讯

  Java提供了一个首要的点子巧妙的消除线程间的通讯难点。这个格局分别是:wait()、notify()、notifyAll()。(Object类)

  调用wait()方法能够使调用该措施的线程释放共享财富的锁,然后从运市价况退出,进入等待列队,直到被另行提示。

  调用notify()方法能够唤起等待队列中第②个等待同一共享财富的线程,并使该线程退出等待队列,进入可运转态。

  调用notifyAll()方法能够使拥有正在等候列队中同一共享财富的线程从等待状态退出,进入可运营意况,此时,优先级最高的特别线程大概会开头执行。

 

地理 21地理 22

  1 package com.abc.tzy;
  2 
  3 import java.util.LinkedList;
  4 
  5 public class ProductorConsumerDemo {
  6 
  7     public static void main(String[] args) {
  8 
  9         Basket basket = new Basket();
 10         Productor productor = new Productor(basket);
 11         Consumer consumer = new Consumer(basket);
 12         productor.start();
 13         consumer.start();
 14     }
 15 
 16 }
 17 class Productor extends Thread{
 18     private Basket basket = null;
 19 
 20     public Productor(Basket basket) {
 21         super();
 22         this.basket = basket;
 23     }
 24     @Override
 25     public void run() {
 26         basket.pushApple();
 27     }
 28 }
 29 class Consumer extends Thread{
 30     private Basket basket = null;
 31 
 32     public Consumer(Basket basket) {
 33         super();
 34         this.basket = basket;
 35     }
 36     @Override
 37     public void run() {
 38         basket.popApple();
 39     }
 40 }
 41 //篮子类
 42 class Basket{
 43     private LinkedList<Apple> basket = new LinkedList<Apple>();
 44     //放4轮苹果
 45     public synchronized void pushApple(){
 46         for (int i = 0; i < 20; i++) {
 47             Apple apple = new Apple(i);
 48             push(apple);
 49         }
 50     }
 51     //吃4轮苹果
 52         public synchronized void popApple(){
 53             for (int i = 0; i < 20; i++) {
 54                 pop();
 55             }
 56         }
 57     //向篮子放苹果
 58     private void push(Apple apple){
 59         if(basket.size()==5){
 60             try {
 61                 wait();
 62             } catch (InterruptedException e) {
 63                 e.printStackTrace();
 64             }//等待并释放当前对象的锁
 65         }
 66         try {
 67             Thread.sleep(500);
 68         } catch (InterruptedException e) {
 69             e.printStackTrace();
 70         }
 71         basket.addFirst(apple);
 72         System.out.println("存放"+apple.toString());
 73         notify();//通知消费者来消费
 74     }
 75     //向篮子取苹果
 76         private void pop(){
 77             //当篮子中苹果数为0的时候就等待并通知生产者来生产
 78             if(basket.size()==0){
 79                 try {
 80                     wait();
 81                 } catch (InterruptedException e) {
 82                     e.printStackTrace();
 83                 }//等待并释放当前对象的锁
 84             }
 85             try {
 86                 Thread.sleep(500);
 87             } catch (InterruptedException e) {
 88                 e.printStackTrace();
 89             }
 90             Apple apple = basket.removeFirst();
 91             System.out.println("吃掉"+apple.toString());
 92             notify();//通知消费者来消费
 93         }
 94     
 95 }
 96 //苹果类
 97 class Apple{
 98     private int id;
 99     public Apple(int id){
100         this.id=id;
101     }
102     @Override
103     public String toString() {
104         return "苹果 :" + (id+1)+"号";
105     }
106     
107 }

生产者消费者

 

IO框架

IO(Input/Output)是总结机输入/输出的接口。JAVA的为主库java.io提供了全方面的IO接口,包蕴:文件系统的操作,文件读写,标准配备出口等等

      java.io

    /   |   \

  File InputStream Reader

    ||  OutputStream  Writer  

  文件和目录类      ||                ||

      字节流读写类  字符流读写类

File类及运用
1个File类的目的,表示了磁盘上的文本或目录。

File类提供了与平台非亲非故的法子来对磁盘上的文本或目录进行操作。

File类间接处理公事和文件系统。比如删除文件,获取文件长度大小等新闻。

File没有提供情势从文件读取或向文件储存消息。

构造方法:File(String
directory帕特h)  文件所在路径  File(String directoryPath,String
filename)  文件所在路径,文件名 File(File dirObj,String filename)   
  文件所在路径封装,文件名

地理 23地理 24

 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileFilter;
 5 import java.io.FilenameFilter;
 6 import java.io.IOException;
 7 
 8 public class FileDemo {
 9     public static void main(String[] args) throws IOException {
10         File file = new File("d:\\qq");// "d:/qq"
11         // File getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
12         System.out.println(file.getAbsolutePath());// d:\qq
13         // String getParent() 返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回 null
14         System.out.println(file.getParent());// d:\
15         // boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
16         System.out.println(file.isDirectory());// true
17         // boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
18         System.out.println(file.isFile());// false
19         // boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
20         System.out.println(file.exists());// true
21         // boolean delete() 删除此抽象路径名表示的文件或目录。
22         System.out.println(file.delete());// false
23         File myFile = new File("d:\\zhangsan");
24         // boolean mkdir() 创建此抽象路径名指定的目录。
25         System.out.println(myFile.mkdir());// 没有时true 有了就是false
26         File myFile2 = new File("d:/zhangsan/tzy.txt");
27         // boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。
28         System.out.println(myFile2.createNewFile());// 没有时true 有了就是false
29         // String[] list() 返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录。
30         /*
31         String[] files = file.list();
32         for (String f : files) {
33             System.out.println(f);
34         }
35         System.out.println("*************");
36         */
37         // String[] list(FilenameFilter filter)
38         // 返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
39         /*
40         String[] list = file.list(new FilenameFilter() {
41 
42             @Override
43             public boolean accept(File dir, String name) {
44                 // boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 (String)
45                 return name.endsWith(".exe");
46             }
47         });
48         for (String f : list) {
49             System.out.println(f);
50         }
51         */
52         //File[] listFiles()  返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。
53         /*
54         File[] listFiles = file.listFiles();
55         for (File f : listFiles) {
56             // String getName() 返回由此抽象路径名表示的文件或目录的名称。 
57             //long length()  返回由此抽象路径名表示的文件的长度。 
58             System.out.println(f.getName()+"---"+f.length());
59         }
60         */
61         //public interface FileFilter用于抽象路径名的过滤器。
62         //File[] listFiles(FilenameFilter filter)  返回抽象路径名数组,
63         //这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
64          /*
65         File[] listFiles = file.listFiles(new FilenameFilter() {
66             
67             @Override
68             public boolean accept(File dir, String name) {
69                 return name.endsWith(".exe");
70             }
71         });
72          for (File f : listFiles) {
73              System.out.println(f.getName()+"---"+f.length());
74         }
75         */
76         //File[] listFiles(FileFilter filter) 
77         //返回抽象路径名数组,这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
78         File[] listFiles = file.listFiles(new FileFilter() {
79             
80             @Override
81             public boolean accept(File pathname) {
82                 return pathname.getName().endsWith(".exe");
83             }
84         });
85          for (File f : listFiles) {
86              System.out.println(f.getName()+"---"+f.length());
87         }
88     }
89 }

File测试

地理 25地理 26

 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 
 7 public class IteratorDirDemo {
 8     public static void main(String[] args) {
 9         IteratorUtil.IteratorDir(new File("d:\\qq"));
10     }
11 
12 }
13 
14 class IteratorUtil{
15     private static int level = 0;//层级数
16     public static void IteratorDir(File file){
17         if(file!=null){
18             //找出递归的出口
19             //假设是文件或者时空文件夹
20             if(file.isFile()||file.listFiles().length==0){
21                 return;
22             }else{
23                 File[] files = file.listFiles();
24                 //要求时先输出文件夹再输出文件
25                  files = sort(files);
26                  for (File f : files) {
27                      //这是一个动态字符串
28                     StringBuilder sb = new StringBuilder();
29                     if(f.isFile()){
30                         sb.append(getTab(level));
31                         sb.append(f.getName());
32                     }else{
33                         sb.append(getTab(level));
34                         sb.append(f.getName());
35                         sb.append("\\");
36                     }
37                     System.out.println(sb.toString());
38                     //加入是文件夹
39                     if(f.isDirectory()){
40                         level++;//进入目录遍历,层级+1;
41                         IteratorDir(f);//递归调用遍历目录的方法
42                         level--;//目录层级减一,退回上一级目录继续打印输出
43                     }
44                 }
45                 
46             }
47         }
48     }
49     /**
50      * 对File类型的数组进行先目录后文件的排列
51      * @param files
52      * @return
53      */
54     private static File[] sort(File[] files){
55         List<File> fList = new ArrayList<File>();
56         //先存放文件夹
57         for (File f : files) {
58             if(f.isDirectory()){
59                 fList.add(f);
60             }
61         }
62         //再存放文件
63         for (File f : files) {
64             if(f.isFile()){
65                 fList.add(f);
66             }
67         }
68         //<T> T[]  toArray(T[] a) 按适当顺序(从第一个到最后一个元素)
69         //返回包含此列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。 (ArrayList)
70         return fList.toArray(new File[fList.size()]);
71     }
72     //根据层级数来得到\t的个数
73     private static String getTab(int level){
74         StringBuilder sb = new StringBuilder();
75         for (int i = 0; i < level; i++) {
76             sb.append("\t");
77         }
78         return sb.toString();
79     }
80 }

递归打字与印刷文件夹及文件

流的概念和归类

流时3个很形象的概念,当程序须求读取数据的时候,就会打开二个朝向数据源的流,这一个数据源能够是文本,内部存款和储蓄器,或是互联网连接。类似的,当程序须求写入数据的时候,就会开启

一个通往目标地的流。那时候你就能够想像数据好像在那中间流动一样。

流的归类:

  流按其流向分为“输入流”和“输出流”

  流按数据传输单位分成“字节流”和“字符流”

    “字节流”用来读写陆位二进制的字节;(mp5,mp4,图片录制等多媒体文件)

    “字符流”用来读写13人二进制字符;(文本文件)

  流按效率分为“节点流”和“过滤流”

    “节点流”用于直接操作目的设备的流。例如:磁盘或一块内部存款和储蓄器区域

    “过滤流”时对七个已存在的流的连接和打包,通过对数码进行处理,为顺序提供功用强大、灵活的读写作用。

InputStream抽象类

  字节流类用于向字节流读写6人二进制的字节。一般的,字节流类首要用于读写诸如图片大概声音等的二进制数据。

  字节流类以InputStream和OutputStream为顶层类。它们都以抽象类。

  InputStream是概念了字节输入流的抽象类

Outputstream抽象类

  Outputstream是概念了字节输出流的抽象类

  该类全部办法重临void值,在失误意况下抛IOException分外

InputStream和Outputstream**

  每种抽象类都有五个有血有肉的子类,那么些子类对区别的外设进行拍卖,例如磁盘文件,网络连接,甚至是内部存款和储蓄器缓冲区。

  FileInputStream类表示能从文件读取字节的InputStream类

  常用构造: FileInputstream(String
filepath)  FileInputStream(File fileObj)

  FileOutStream表示能向文件写入字节的OutputStream类

  常用构造:FileOutStream(String
filepath)  FileOutStream(File fileObj)  FileOutStream(String
filepath,boolean append)

 

地理 27地理 28

 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 public class FileInputStreamOutputStreamDemo {
10 
11     public static void main(String[] args) {
12         try {
13             FilecopyUtil.copyFile(new File("D:\\oo\\photo02.jpg"), new File("D:\\oo\\photo01.jpg"));
14         } catch (IOException e) {
15             e.printStackTrace();
16         }
17     }
18 
19 }
20 
21 class FilecopyUtil{
22     public static void copyFile(File src,File dst) throws IOException{
23         FileInputStream fis = new FileInputStream(src);
24         FileOutputStream fos = new FileOutputStream(dst);
25         long t1 = System.currentTimeMillis();
26         int data = -1;
27         int count=0;
28         while((data=fis.read())!=-1){
29             fos.write(data);
30             count++;
31         }
32         fos.close();
33         fis.close();
34         long t2 = System.currentTimeMillis();
35         System.out.println("复制完成花费:"+(t2-t1)+"毫秒,读了"+count+"次");
36     }
37     
38 }

字节流复制图片

 

 

    地理 29

 

地理 30地理 31

 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 public class FileInputStreamOutputStreamDemo {
10 
11     public static void main(String[] args) {
12         try {
13             FilecopyUtil.copyFile(new File("D:\\oo\\photo02.jpg"), new File("D:\\oo\\photo01.jpg"));
14         } catch (IOException e) {
15             e.printStackTrace();
16         }
17     }
18 
19 }
20 
21 class FilecopyUtil{
22     public static void copyFile(File src,File dst) throws IOException{
23         FileInputStream fis = new FileInputStream(src);
24         FileOutputStream fos = new FileOutputStream(dst);
25         
26 
27         int count=0;
28         int len = 0;//*****为什么需要这个变量****
29         //因为下面的read(buf)是将文件以8位二进制形式(也就是1b即一字节)装入byte数组作为一个元素.那么当数组读到最后一次时肯定时读不满的,
30         //故要将最后一次装入的---元素的个数---统计出来。
31         byte [] buf = new byte[1024];//创建一个1kb大小的缓冲区,用来存放输入流中的字符数
32         long t1 = System.currentTimeMillis();
33         // int read()   从此输入流中读取一个数据字节。 
34         // int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 
35         // int read(byte[] b, int off, int len)  从此输入流中将最多 len 个字节的数据读入一个 byte 数组中 
36         
37         // void write(int b) 将指定字节写入此文件输出流。 
38         // void write(byte[] b)  将 b.length 个字节从指定 byte 数组写入此文件输出流中。
39         //write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
40         while((len=fis.read(buf))!=-1){
41             fos.write(buf, 0, len);
42             count++;
43         }
44         fos.close();
45         fis.close();
46         long t2 = System.currentTimeMillis();
47         System.out.println("复制完成花费:"+(t2-t1)+"毫秒,读了"+count+"次");
48     }
49     
50 }

字节流–数组–读取与读出-内部存储器解析

小结:输入流其实正是文件读入内部存款和储蓄器的桥接,输出流即是内部存款和储蓄器读出到文件的桥接.

 ByteArrayInputStream/OutputStream

  ByteArrayInputStream是把字节数组当李松益的输入流

  四个构造方法,各种都急需二个字节数组提供数据源

    ByteArratInputStream(byte array[])

    ByteArrayInputStream(byte array[],int start,int numBytes)

  ByteArrayOutStream是把字节数组当作指标的输出源

  八个构造方法:

    ByteArrayOutStream()创制八个新的byte数组输出流

    ByteArrayOutStream(int
numBytes)成立二个新的byte数组输出流,具有制定大小的缓冲区(字节为单位)

地理 32地理 33

 1 package com.abc.tzy;
 2 
 3 import java.io.ByteArrayInputStream;
 4 import java.io.ByteArrayOutputStream;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 
 8 public class ByteArrayInputStreamOutputStreamDemo {
 9 public static void main(String[] args) throws IOException {
10     String str = "hello,shanghai";
11     ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes());
12     int data = 0;
13     while((data=bis.read())!=-1){
14         System.out.println((char)data);
15     }
16     System.out.println("******");
17     ByteArrayOutputStream bos = new ByteArrayOutputStream();//默认32位长度
18     bos.write(97);
19     bos.write(65);
20     bos.write("hello,world".getBytes());
21     byte[] buff = bos.toByteArray();
22     for (byte b : buff) {
23         System.out.println((char)b);
24     }
25     System.out.println("********");
26     FileOutputStream fos = new FileOutputStream("d://aa.txt",false);//false不覆盖
27     bos.writeTo(fos);//把ByteArrayOutputStream内部缓冲区的数据写到对应文件输出流中
28     fos.close();
29     
30 }
31 }

ByteArrayInput/OutputStream

 过滤流介绍

过滤流(filtered
Stream)仅仅是为底层透明地提供扩张作用的输入流(输出流)的包裹。这一个流一般由普通类的艺术(即过滤流的贰个父类)访问。

过滤字节流FilterInputStream和FilterOutputStream.构造方法:FilterOutStream(OutputStream
os)         FilterInputStream(InputStream is)

这么些类提供的主意和InputStream及OutputStream类的主意同样

常用的过滤流BufferedInputStream和BuffOutputStream,DataInputStream和DataOutputStream

地理 34地理 35

 1 package com.abc.tzy;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.File;
 6 import java.io.FileInputStream;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 
10 public class BufferedInputStreamOutputStreamDemo {
11 
12     public static void main(String[] args) {
13         try {
14             FilecopyUtil1.copyFile(new File("D:\\oo\\photo02.jpg"), new File("D:\\oo\\photo01.jpg"));
15         } catch (IOException e) {
16             e.printStackTrace();
17         }
18     }
19 
20 }
21 
22 class FilecopyUtil1 {
23     public static void copyFile(File src, File dst) throws IOException {
24         FileInputStream fis = new FileInputStream(src);
25         FileOutputStream fos = new FileOutputStream(dst);
26         BufferedInputStream bis = new BufferedInputStream(fis);
27         BufferedOutputStream bos = new BufferedOutputStream(fos);
28         int data = 0;
29         long time1 = System.currentTimeMillis();
30         while ((data = bis.read()) != -1) {
31             bos.write(data);
32         }
33         bos.close();
34         bis.close();
35         long time2 = System.currentTimeMillis();
36         System.out.println("复制完成,共花费"+(time2-time1)+"毫秒");
37     }
38 }

过滤流Buffered

地理 36地理 37

 1 package com.abc.tzy;
 2 
 3 import java.io.DataInputStream;
 4 import java.io.DataOutputStream;
 5 import java.io.FileInputStream;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 
10 public class DataInputOutputStreamDemo {
11     public static void main(String[] args) throws IOException {
12         String name = "zhangsan";
13         int age = 10;
14         boolean flag = true;
15         char sex = '男';
16         double money = 100.56;
17         DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:\\b.txt"));
18         dos.writeUTF(name);
19         dos.writeInt(age);
20         dos.writeBoolean(flag);
21         dos.writeChar(sex);
22         dos.writeDouble(money);
23         dos.close();
24         
25         DataInputStream dis = new DataInputStream(new FileInputStream("d:\\b.txt"));
26         //读写顺序必须一致
27         System.out.println(dis.readUTF());
28         System.out.println(dis.readInt());
29         System.out.println(dis.readBoolean());
30         System.out.println(dis.readChar());
31         System.out.println(dis.readDouble());
32         
33     }
34 }

过滤流Data

  BufferedInputStream和BuffOutputStream

    须要动用已经存在的节点流来构造,提供带缓冲区的读写,升高了读写的频率

      文件–>从文件中赢得输入字节(FileInputStream)–>扩充字节缓冲区功效(BufferedInputStream)–>数据

      数据–>提供数据写入到缓存区
(
FileOutputStream)–>将数据以字节写入到文件中–>文件

  DataInputStream和DataOutputStream

    数据输入输出流允许应用程序读写基本Java数据类型。应用程序能够利用数据输出流写入稍后由数量输入流读取。读写顺序要保持一致。

地理 38地理 39

 1 package com.asd.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 public class CopyDirDemo {
10 
11     public static void main(String[] args) {
12         try {
13             CopyDirUtil.copyDir(new File("D:\\xmind"), new File("D:\\xmind2"));
14             System.out.println("拷贝成功");
15         } catch (IOException e) {
16             e.printStackTrace();
17         }
18     }
19 
20 }
21 
22 class CopyDirUtil{
23     public static void copyDir(File src,File dst) throws IOException{
24         dst.mkdirs();//d:\\zz\\bb创建目标文件夹
25         if(src!=null){
26             File[] files = src.listFiles();//遍历源文件夹中的所有文件或目录
27             for (File f : files) {
28                 if(f.isFile()){
29                     //是文件就复制
30                     FileInputStream fis = new FileInputStream(f);
31                     FileOutputStream fos = new FileOutputStream(dst.getAbsolutePath()+"\\"+f.getName());
32                     byte [] buff = new byte[1024*1024];//1M
33                     int len = 0 ;//保存的时读到的字节个数
34                     while((len=fis.read(buff))!=-1){
35                         fos.write(buff,0,len);
36                     }
37                     fos.close();
38                     fis.close();
39                 }else{
40                     copyDir(f,new File(dst.getAbsolutePath()+"\\"+f.getName()));
41                 }
42             }
43         }
44     }
45 }

行使字节流复制1个文本夹

 Reader和Writer抽象类

字节流提供处理其余类型输入输出操作的十足功效,但不能够一贯操作Unicode字符(比如汉语2字节),由此须要字符流

字符流层次结构的顶层是Reader和Writer抽象类

Reader是定义Java的流式字符输入形式的抽象类

Writer是概念流式字符输出的抽象类:该类的艺术都回来void值并在失误条件下抛出IOException万分

 FileReader和FileWriter

FileReader类表示能够读取文件内容的Reader类

构造方法:File里德r(String
filePath)  FileReader(File fileObj)

FileWriter表示能够写文件的Writer类

构造方法:FileWriter(String
filePath)  FileWriter(String file帕特h,boolean
append)  FileWriter(File fileObj)

地理 40地理 41

 1 package com.asd.tzy;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.FileReader;
 5 import java.io.FileWriter;
 6 import java.io.IOException;
 7 
 8 public class FileReaderWriterDemo {
 9 
10     public static void main(String[] args) throws IOException {
11         FileReader fr = new FileReader("d:\\tzy.txt");
12         FileWriter fw = new FileWriter("d:\\tzy1.txt");
13         char[] buff = new char[100];
14         int len = 0;//实际读取的字符个数
15         while((len=fr.read(buff))!=-1){
16             fw.write(buff,0,len);
17         }
18         fw.close();//如果不关闭 那么缓冲区文件不会被读出来,可以使用fw.flush()强制清空缓存区
19         fr.close();
20     }
21 
22 }

字符流复制文件

BufferedReader和BufferedWriter

BufferedReader通过缓冲输入提升质量

构造方法:Buffered里德r(Reader
inputStream)  BufferedReader(Reader inputStream,int bufSize)

BufferedWriter通过缓冲输出提供质量

构造方法:BufferedWriter(Writer
outputStream)  BufferedWriter(Writer outputStream,int bufSize)

地理 42地理 43

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileReader;
 7 import java.io.FileWriter;
 8 import java.io.IOException;
 9 
10 public class BufferedReaderWriterDemo {
11 
12     public static void main(String[] args) throws IOException {
13         FileReader fr = new FileReader("d:\\tzy.txt");
14         BufferedReader br = new BufferedReader(fr);
15         FileWriter fw = new FileWriter("d:\\tzy2.txt");
16         BufferedWriter bw = new BufferedWriter(fw);
17         String line = null;
18         while((line=br.readLine())!=null){
19             System.out.println(line);
20             bw.write(line);
21             bw.newLine();//使文件换行
22             bw.flush();
23         }
24         bw.close();
25         br.close();
26     }
27 
28 }

缓冲字符流复制文件

ObjectInputStream/ObjectOutputStream

ObjectOutputStream和ObjectInputStream分别与FileOutStream和FileInputStream一起利用,能够为应用程序提供对指标的始终不渝储存。我们把对象以某种特定获得编码格式写入

名为系列化。把写入的编码格式内容还原成对象称之为反体系化

类别化的靶子必须贯彻Serializable接口

地理 44地理 45

 1 package com.asd.tzy;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.ObjectInputStream;
 8 import java.io.ObjectOutputStream;
 9 import java.io.Serializable;
10 
11 public class ObjectInputOutputDemo {
12 
13     public static void main(String[] args) throws IOException {
14         Stduent st = new Stduent("张三", 30);
15         FileOutputStream fos = new FileOutputStream("d:\\tzy.txt");
16         ObjectOutputStream oos = new ObjectOutputStream(fos);
17         oos.writeObject(st);//把对象序列化到制定文件输出流中
18 //         java.io.NotSerializableException
19         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\tzy.txt"));
20         try {
21             Stduent stu = (Stduent) ois.readObject();
22             System.out.println(stu);
23         } catch (ClassNotFoundException e) {
24             e.printStackTrace();
25         }finally{
26             ois.close();
27         }
28     }
29 
30 }
31 
32 class Stduent implements Serializable{
33     /**
34      * 
35      */
36     private static final long serialVersionUID = 7425793184115828439L;
37     private String name;
38     private int age;
39     private String address;
40     public Stduent(String name, int age) {
41         super();
42         this.name = name;
43         this.age = age;
44     }
45     public String getName() {
46         return name;
47     }
48     public void setName(String name) {
49         this.name = name;
50     }
51     public int getAge() {
52         return age;
53     }
54     public void setAge(int age) {
55         this.age = age;
56     }
57     @Override
58     public String toString() {
59         return "Stduent [name=" + name + ", age=" + age + "]";
60     }
61     
62 }

种类化及反种类化对象

 InputStreamReader,OutputStreamWrite

转换流是指将字节流与字符流之间的转换。

转换流的出现有利于了对文件的读写,它在字符流和字节流之间架起了一座大桥,使原先非亲非故乎的三种流操作可以进行中间转播,升高了程序的油滑。

字节流中的数据都是字符时,转成字符流操作更搞笑。

假使应用非默许编码保存文件可能读取文件时,供给接纳转换流,因为字节流的重载构造方法中右制定编码格式的参数,而FileReader和FileWriter是默许编码的文本文件。

周边的编码表:

  ASCLL:美利坚合众国家标准准新闻交流码。用叁个字节的7人能够象征

  ISO8859-1:拉丁码表,澳洲码。用多个字节的六位代表

  GB2312:中夏族民共和国的华语编码表

  GBK:中夏族民共和国的华语编码表升级,融合了更加多的汉语文字标记。

  Unicode:国际标准码,融合了各个文字。全数文字都用3个字节来代表,Java语言应用的正是Unicode

  UTF-8:最多用三个字节来代表3个字符。

 

地理 46地理 47

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileInputStream;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 import java.io.InputStreamReader;
10 import java.io.ObjectInputStream;
11 import java.io.ObjectOutputStream;
12 import java.io.OutputStreamWriter;
13 import java.io.Serializable;
14 
15 public class InputOutputStreamReaderWriterDemo {
16 
17     public static void main(String[] args) throws IOException {
18         FileOutputStream fos = new FileOutputStream("d:\\tzy.txt");
19         OutputStreamWriter oos = new OutputStreamWriter(fos, "utf-8");
20         BufferedWriter osw = new BufferedWriter(oos);
21         osw.write("我是谁");//在utf-8里中文占3个字节 如果直接用FileReader读,那么用的是默认编码读的是2个字节,所以读出来是乱码
22         osw.newLine();//换行
23         osw.write("我时你");
24         osw.flush();//
25         osw.close();
26         BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:\\tzy.txt"), "utf-8"));
27         String line = null;
28         while((line=br.readLine())!=null){
29             System.out.println(line);
30         }
31     }
32 
33 }

转移流对内定编码文件读写

 RandomAccessFile随机访问文件

帮忙对随意访问文件的读写和写入

轻易走访文件的行事看似存款和储蓄在文件系统中的二个巨型byte数组。存在指向该隐含数组的光标或索引,称为文件指针

输入操作从文件指针开端读取字节,随着对字节的读取而前移此文件指针

若是任意走访文件以读取/写入格局创设,则输出操作也可用;输出操作从文件指针起先写入字节,随着对字节的写入而前移此文件指针

写入隐含数组末尾之后的输出操作导致该数组扩张。

该公文指针能够经过getFilePointer方法读取,通过seek方法设置

地理 48地理 49

 1 package com.asd.tzy;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.IOException;
 5 import java.io.RandomAccessFile;
 6 import java.util.Scanner;
 7 
 8 public class RandomAccessFileDemo {
 9     public static void main(String[] args) throws IOException {
10         Person[] persons = { new Person("zhangsan", 90), new Person("justin", 30), new Person("bush", 88),
11                 new Person("lisi", 20) };
12         RandomAccessFile randomAccessFile = new RandomAccessFile("d:\\tzy.txt", "rw");// r只读// rw可读可写
13         //写入数据到RandomAccessFile
14         for (int i = 0; i < persons.length; i++) {
15             randomAccessFile.writeChars(persons[i].getName());
16             randomAccessFile.writeInt(persons[i].getAge());//按4个字节写入数字
17         }
18         //读取指定位置上的Person对象
19         Scanner sc = new Scanner(System.in);
20         System.out.println("读取第几个Person对象数据");
21         int num = sc.nextInt();
22         //使用seek方法来操作存取位置
23         randomAccessFile.seek((num-1)*Person.size());//跳过多少字节读
24         Person person = new Person();
25         person.setName(readName(randomAccessFile));
26         person.setAge(randomAccessFile.readInt());
27         System.out.println("姓名:"+person.getName()+";年龄:"+person.getAge());
28         randomAccessFile.close();
29         
30     }
31     private static String readName(RandomAccessFile randomAccessFile) throws IOException{
32         char [] name = new char[15];
33         for (int i = 0; i < name.length; i++) {
34             name[i]=randomAccessFile.readChar();
35         }
36         return new String(name).replace("\u0000", "");
37     }
38 }
39 
40 class Person {
41     private String name;
42     private int age;
43 
44     public Person(String name, int age) {
45         StringBuilder builder = null;
46         if (name != null) {
47             builder = new StringBuilder(name);// 默认为16长度+传入字符串长度的字符串
48 
49         } else {
50             builder = new StringBuilder(15);// 制定为15长度的字符串
51         }
52         builder.setLength(15);// 固定长度15个字符,占了30个字节的大小
53         this.name = builder.toString();
54         this.age = age;
55     }
56 
57     public Person() {
58         super();
59     }
60 
61     public String getName() {
62         return name;
63     }
64 
65     public void setName(String name) {
66         this.name = name;
67     }
68 
69     public int getAge() {
70         return age;
71     }
72 
73     public void setAge(int age) {
74         this.age = age;
75     }
76 
77     // 每个对象所占的字节数
78     public static int size() {
79         return 34;
80     }
81 }

RandomAccessFile读写对象

 网络基础知识

总括机网络

  总结机网络,正是把分布在分化地理区域的微型总计机与专程的外部设备通讯线路互联成1个层面大,功用强的网络体系,从而使许多的处理器能够便宜地相互传送细心,共享硬件、

  软件、数据新闻等财富。

互连网类别结构

  网络连串结构定义总括机设备和任何装置怎么着连接在共同以多变三个允许用户共享信息和能源的通讯系统。

  国际标准化组织IOS于1979年建议“开放系统互连参考模型”,即闻明的OSI模型。OSI模型保证了各项设施生产厂家的成品分外新。

  该模型把电脑互联网分成物理层、数据链路层、网络层、传输层、会话层、表示层、应用层等七层

OSI模型分层的便宜

  分化厂商生产的设施都得以互相合营。 

  设备得以小心于某一层的功能,如交流机工作在第叁层,路由器工作在第一层。

  方便网络故障排错

  不用过多着想情理接口等这一个物理层的东西

TCP/IP是一组用于落到实处网络互联的通讯协议。Internet网络种类结构以TCP/IP为主题。基于TCP/IP的参考模型将合计分成多少个层次,它们分别是接口层、互联网层、传输层、和应用层。

网络编制程序的指标

  网络编程的指标正是指直接或简介地经过网络协议与任何电脑进行报导。网络编制程序中有七个首要的题材,3个是如何规范的一定互联网上的一台或多台主机,

  另二个正是找到主机后

  怎么着可信高效的拓展数据传输。

互连网通训要素

  IP地址;端口号;传输协议

IP地址

  网络中每台主机都无法不有二个唯一的IP地址。

  因特网上的IP地址具有全球唯一性。

  IP地址由叁十六个人2进制组成,占七个字节,常用十进制的格式表示,

  例如:192.168.0.5

  对应的类-InetAddress

端口号

  端口号用来代表该总计机上的应用程序,代表此应用程序逻辑地址。

  端口号使用一个14人的数字来代表,它的限量是0~65535,1024以下的端口号保留给预约义的劳动。例如http使用80端口。

协和式飞机概念

  为计算机网络中实行数据交换而树立的平整、标准或预订的汇集。

周边的传导协议

  TCP是一种面向连接的有限补助保险传输的商业事务。通过TCP协议传输,获得的是二个依次的无差错的数据流

  UDP是一种无连接的合计,每一个数据包都以三个单独的新闻,包蕴完全的源地址或目标地址,它在网络上以任何大概的不二法门传往目标地,因而能不可能达到目的地,

  到达指标地的风云以及内容的科学都以不可能被担保的。

Socket

  方今较为流行的网络编制程序模型是客户机/服务器通讯格局(C/S架构:客户机下边要设置客户端 
        B/S框架结构:只要有浏览器就能够了,不必要设置客户端)

    客户进度向服务器进度产生要求某种服务的央求,服务器进度响应该请求。平常,一个服务器进度会同时为多个客户进程服务

  所谓的socket平日也称为“套接字”,用于描述IP地址和端口,是二个通讯链句柄。应用程序常常通过“套接字”向网络发出请求或然应答互连网请求。。

  Socket是一而再运营在网络上的多少个程序间的双向通许的端点。

  互联网通许其实指的就是Socket间的广播发表。

  通信的两端都有Socket,数据在七个Socket之间通过IO来开始展览传输。

  使用Socket进行网络通讯的进程

    服务器程序将1个套接字绑定到1个一定的端口,并由此此套接字等待和监听客户的总是请求。

    客户程序依据服务器程序所在的主机名和端口号发出连接请求。

    倘诺一切平常,服务器接受请求。并拿走3个新的绑定到差异端口地址的套接字。

    客户和服务器通过读、写套接字举办报纸发表。

  创立TCP服务器的步骤

    成立二个ServerSocket对象

    调用accept()方法接受客户端请求

    从Socket中获取IO流

    对IO流实行读写操作,完成与客户端的互交。

    关闭IO流和Socket

  创立TCP客户端步骤

    创立四个Socket对象

    从Socket中获取IO流

    对IO流实行读写操作,实现与服务器的交互。

    关闭IO流和Socket

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 import java.io.PrintWriter;
 9 import java.net.ServerSocket;
10 import java.net.Socket;
11 
12 public class TCPServer {
13 
14     public static void main(String[] args) throws IOException {
15         // 创建一个ServerSocket对象(服务器)
16         ServerSocket serverSocket = new ServerSocket(8888);
17         // 调用accept()方法来接受客户端的请求;
18         // Socket accept() 侦听并接受到此套接字的连接。
19         Socket socket = serverSocket.accept();
20         // InetAddress getInetAddress() 返回套接字连接的地址。
21         // String getHostAddress() 返回 IP 地址字符串(以文本表现形式)。
22         // String getHostName() 获取此 IP 地址的主机名
23         System.out.println("主机名" + socket.getInetAddress().getHostName() + "IP地址"
24                 + socket.getInetAddress().getHostAddress() + "连接成功");
25         // 获取socket对象的输入输出流
26         // InputStream getInputStream() 返回此套接字的输入流。
27         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
28         //BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
29         PrintWriter pw = new PrintWriter(socket.getOutputStream(),true);
30         String line = null;
31         //读取客户端传过来的数据
32         while ((line = br.readLine()) != null) {
33             if (line.trim().equals("over")) {
34                 break;
35             } else {
36                 System.out.println(line);
37                 //bw.write(line.toUpperCase());//转换成大写的传给客户端
38                 //bw.newLine();
39                 //bw.flush();
40                 pw.println(line.toUpperCase());
41             }
42         }
43         //bw.close();
44         pw.close();
45         br.close();
46         socket.close();
47         System.out.println("主机名" + socket.getInetAddress().getHostName() + "IP地址"
48                 + socket.getInetAddress().getHostAddress() + "连接断开");
49     }
50 
51 }

TCPServer

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 import java.net.Socket;
 9 import java.net.UnknownHostException;
10 
11 public class TCPClient {
12 
13     public static void main(String[] args) throws UnknownHostException, IOException {
14         Socket socket = new Socket("localhost", 8888);
15         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
16         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
17         BufferedReader br1 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
18         while(true){
19             String line = br.readLine();//获取键盘输入的字符串
20             bw.write(line);
21             bw.newLine();//要加换行 服务器才知道读了一行
22             bw.flush();
23             if(line.trim().equals("over")){
24                 break;
25             }
26             System.out.println(br1.readLine());//获取服务端传来的大写字符串
27         }
28         br1.close();
29         bw.close();
30         br.close();
31         socket.close();
32     }
33 
34 }

TCPClient

 基于UDP协议的Socket编程

创设发送端

  创立DatagramSocket对象。
该断点建立,系统会随随便便分配三个端口。假设不想随机配置,能够手动钦命。

  将数据开始展览packet包的包裹,必须要钦命目标地
地址和端口

  通过socket服务的send方法将该包发出。

  将socket关闭

始建接受端

  建立DatagramSocket对象。要监听1个端口。

  透过socket的receive方法将数据存入数据包中。

  通过数量包dp的方法getData(),getAddredss(),getPort()等办法获得包中的内定音信。

  将socket关闭

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 import java.net.SocketException;
 8 
 9 public class UDPDemo2 {
10 public static void main(String[] args) throws IOException {
11     DatagramSocket socket = new DatagramSocket(8000);
12     byte [] buff = new byte[100];
13     DatagramPacket packet = new DatagramPacket(buff, 100);
14     socket.receive(packet);//接受传来的数据包
15     System.out.println(new String(packet.getData()));
16     String str = "me too!";
17     DatagramPacket packet2 = new DatagramPacket(str.getBytes(), 0, str.length(), packet.getAddress(), packet.getPort());
18     socket.send(packet2);
19     socket.close();
20 }
21 }

UDPDemo2 先启动

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 import java.net.SocketException;
 8 import java.net.UnknownHostException;
 9 
10 public class UDPDemo1 {
11 
12     public static void main(String[] args) throws IOException {
13         DatagramSocket socket = new DatagramSocket();
14         String str = "i love you!";
15         //把数据进行封装,封装到数据报 包中;
16         DatagramPacket packet = new DatagramPacket(str.getBytes(), 0, str.length(), InetAddress.getByName("localhost"), 8000);
17         socket.send(packet);//发送
18         byte [] buff = new byte[100];
19         DatagramPacket packet2 = new DatagramPacket(buff, 100);
20         socket.receive(packet2);
21         System.out.println(new String(packet2.getData()));
22         socket.close();
23     }
24 
25 }

UDPDemo1后启动

 多线程Socket

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.ServerSocket;
 5 import java.net.Socket;
 6 
 7 public class ChatServer {
 8 
 9     public static void main(String[] args) throws IOException {
10         ServerSocket serverSocket = new ServerSocket(9999);
11         int number = 1;//保存客户端个数
12         while(true){
13             Socket socket = serverSocket.accept();
14             System.out.println("客户端"+number+"连接成功");
15             //服务端开启一个独立的线程来对客户端进行读写操作
16             new Thread(new ServerStream(socket, number)).start();;
17             number++;
18         }
19     }
20 
21 }

服务器端

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.io.PrintWriter;
 7 import java.net.Socket;
 8 
 9 public class ServerStream implements Runnable {
10     private Socket socket = null;
11     private int number;
12     
13     public ServerStream(Socket socket, int number) {
14         super();
15         this.socket = socket;
16         this.number = number;
17     }
18 
19     @Override
20     public void run() {
21         try {
22             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
23             PrintWriter pw  = new PrintWriter(socket.getOutputStream(),true);
24             while(true){
25                 String line = br.readLine();
26                 System.out.println("客户端"+number+":"+line);
27                 pw.println(line.toUpperCase());
28                 if(line.trim().equals("bye")){
29                     System.out.println("客户端:"+number+"断开连接");
30                     break;
31                 }
32             }
33             br.close();
34             pw.close();
35         } catch (IOException e) {
36             e.printStackTrace();
37         }
38         
39     }
40 
41 
42 }

服务器读写

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.Socket;
 5 import java.net.UnknownHostException;
 6 
 7 public class ChatClient {
 8 
 9     public static void main(String[] args) throws UnknownHostException, IOException {
10         Socket socket = new Socket("127.0.0.1", 9999);
11         new Thread(new ClirentOutputStream(socket)).start();
12         new Thread(new ClientInputStream(socket)).start();
13     
14     }
15 
16 }

客户端

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.io.PrintWriter;
 7 import java.net.Socket;
 8 
 9 public class ClirentOutputStream implements Runnable{
10     private Socket socket = null;
11     
12     public ClirentOutputStream(Socket socket) {
13         super();
14         this.socket = socket;
15     }
16 
17     @Override
18     public void run() {
19         try {
20             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
21             PrintWriter pw = new PrintWriter(socket.getOutputStream(),true);
22             while(true){
23                 String line = br.readLine();
24                 pw.println(line);
25                 if(line.trim().equals("bye")){
26                     break;
27                 }
28             }
29             br.close();
30             pw.close();
31             socket.close();
32         } catch (IOException e) {
33             e.printStackTrace();
34         }
35     }
36 
37 
38 
39 }

客户端读

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.net.Socket;
 7 import java.net.SocketException;
 8 
 9 public class ClientInputStream implements Runnable {
10 private Socket socket = null;
11 
12     public ClientInputStream(Socket socket) {
13     super();
14     this.socket = socket;
15 }
16 
17     @Override
18     public void run() {
19         try {
20             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
21             while(true){
22                 try {
23                     String line = br.readLine();
24                     System.out.println(line);
25                 } catch (SocketException e) {
26                     break;
27                 }
28             }
29             br.close();
30         } catch (IOException e) {
31             e.printStackTrace();
32         }
33     }
34 
35 }

客户端写

 URL类

U帕JeroL是统一财富定位器的简称,它代表Internet上有些财富的地点。通过UHavalL我们得以访问internet上的各样网络财富,比如大规模的www,FPT站点。浏览器通过分析给定的

U奥德赛L能够在互连网上找寻相应的文书或其他财富。

UPAJEROL的骨干组织由5有些组成:

  <传输协议>://<主机名>:<端口号>/<文件名>#<引用>

  http://www.comcat.com:80/Gamelan/network.html\#BOTTOM

为了表示U奇骏L,java.net包中落到实处了类UHavalL。我们能够透过上面包车型大巴构造方法来开头化3个U凯雷德L对象  

赢得UGL450L对象的性质  

 

 boolean equals(Object obj)
          比较此 URL 是否等于另一个对象。
 String getAuthority()
          获取此 URL 的授权部分。
 Object getContent()
          获取此 URL 的内容。
 Object getContent(Class[] classes)
          获取此 URL 的内容。
 int getDefaultPort()
          获取与此 URL 关联协议的默认端口号。
 String getFile()
          获取此 URL 的文件名。
 String getHost()
          获取此 URL 的主机名(如果适用)。
 String getPath()
          获取此 URL 的路径部分。
 int getPort()
          获取此 URL 的端口号。
 String getProtocol()
          获取此 URL 的协议名称。
 String getQuery()
          获取此 URL 的查询部分。
 String getRef()
          获取此 URL 的锚点(也称为“引用”)。
 String getUserInfo()
          获取此 URL 的 userInfo 部分。
 int hashCode()
          创建一个适合哈希表索引的整数。
 URLConnection openConnection()
          返回一个 URLConnection 对象,它表示到 URL 所引用的远程对象的连接。
 URLConnection openConnection(Proxy proxy)
          与 openConnection() 类似,所不同是连接通过指定的代理建立;不支持代理方式的协议处理程序将忽略该代理参数并建立正常的连接。
 InputStream openStream()
          打开到此 URL 的连接并返回一个用于从该连接读入的 InputStream
 boolean sameFile(URL other)
          比较两个 URL,不包括片段部分。
protected
 void
set(String protocol, String host,
int port, String file, String ref)

          设置 URL 的字段。
protected
 void
set(String protocol, String host,
int port, String authority, String userInfo, String path, String query, String ref)

          设置 URL 的指定的 8 个字段。
static void setURLStreamHandlerFactory(URLStreamHandlerFactory fac)
          设置应用程序的 URLStreamHandlerFactory
 String toExternalForm()
          构造此 URL 的字符串表示形式。
 String toString()
          构造此 URL 的字符串表示形式。
 URI toURI()
          返回与此 URL 等效的 URI

 U奥德赛L右二种方法能够访问Internet上能源

地理 50地理 51

 1 package com.asd.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 import java.io.InputStream;
 7 import java.io.OutputStream;
 8 import java.net.MalformedURLException;
 9 import java.net.URL;
10 import java.net.URLConnection;
11 
12 public class URLDemo {
13 
14     public static void main(String[] args) {
15         try {
16             DownloadUtil.download("http://scimg.jb51.net/allimg/121209/2-1212091UH0339.jpg", "my.jpg", "d:\\abcimage");
17         } catch (IOException e) {
18             e.printStackTrace();
19         }
20     }
21 
22 }
23 
24 
25 class DownloadUtil{
26     public static void download(String urlString,String fileName,String savePath) throws IOException{
27         URL url = new URL(urlString);
28         //URLConnection conn = url.openConnection();
29         //InputStream is = conn.getInputStream();
30         InputStream is = url.openStream();
31         byte[] buff = new byte[1024];
32         int len = 0;
33         File file = new File(savePath);
34         if(!file.exists()){
35             file.mkdirs();
36         }
37         OutputStream os = new FileOutputStream(file.getAbsolutePath()+"\\"+fileName);
38         while((len=is.read(buff))!=-1){
39             os.write(buff, 0, len);
40         }
41         //施放资源
42         os.close();
43         is.close();
44     }
45 }

UTucsonL网页下载图片

 XML定义

XML指可增加标记语言,适合Wed传输,类似HTML,区别的是它的安顿大旨是传输数据,而非展现数据。(不是显示数据)

XML提供联合的办法来讲述和交流独立于应用程序或供应商的结构化数据。XML标签没有被预订义,开发者要求活动定义标签。XML被规划为富有自个儿描述性,

是W3C的推荐介绍标准。

XML文书档案结构

  XML申明:<?xml version=”1.0″
standalone=”yes” encoding=”UTF-8″?>

  XML根成分定义:XML文书档案的树形结构供给必须有叁个根成分。根成分的开场标记要放在全部其余成分初叶标记在此之前,

  根成分的达成标记放在其余具有因素的告竣标记之后。

  XML元素:成分的主导构造由
发轫标记,数据内容,截至标记组成

  XML中的注释:<!–this is
comment–>

XML的语法规则

  全部的XML成分都不能不有关闭标签

  XML标签对大小写敏感

  XML必须正确嵌套

  XML文书档案必须有根成分

  XML的本性以名值对章程组成,值需加引号

  在XML中,空格会被保存,文书档案中的空格不会被删节

SAX解析器

  SAX(Simple API For
XML)是二个公共的依照事件的XML文书档案解析标准,能够因此2个简约的、迅速的法门来对XML文档实行拍卖,和DOM相比较它所占据的

系统财富更少

  SAX便是三个接口,也是四个软件包。作为接口,SAX是事件驱动型XML解析的贰个标准接口,对文书档案实行逐一扫描,当扫描到文书档案(document)开端、

要素(element)先导与结束、文书档案结束等地点时通报事件处理函数,由事件处理函数做相应动作,然后继续同样的扫描,直至文书档案结束。

SAX解析器API

  半数以上SAX会发生以下连串的事件

    在文书档案的开端和得了时接触文书档案处管事人件

地理,    在文书档案内每贰个XML成分接受解析的前后触发元素事件

    在任元数据一般由单独的数量来处理

  举例:

      <doc>

        <para>Hello,tom<para>

      <doc>

      其分析进度:1:satrt document 2:start
element:doc.. 3:start:element:para.. 4:characters:Hello… 5:end
element:para… 6:end element:doc 7:end document

  解析步骤:

    创设事件处理程序(即编写ContentHandler的贯彻类,一般持续自DefaultHandler类,采纳adapter格局)

    创建SAX解析器

    将事件处理程序分配到解析器

    对文书档案实行解析,将各样事件发送给事件处理程序

  常用接口:ContentHandler 接口

    ContentHandler是JAVA类包中贰个相当的SAX接口

    该接口封装了有的对事件处理的法门,当XML解析器初步解析XML输入文书档案时,它会赶上一些特殊的轩然大波,比如文书档案的始发与结束、成分的开首和停止、一级

    成分中的字符数据等事件。当遇到这么些事件时,XML解析器会调用ContentHandler接口中相应的点子来响应事件

    ContentHander接口常用方法:

      void
startDocument()//文档解析最先的处理

      void
endDocument()//文书档案解析结束的处理

      void startElement(String
uri,String localName,String qName,Attributes
atts)//ElementNode开首的拍卖

      void endElement(String
uri,String localName,String qName)//ElementNode结束的处理

      void characters(char[] ch,
int start,int lenght)//具体在某一节点中的拍卖

 

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图