javaSE_2

来源：互联网发布：unity3d 3dsmax 编辑：程序博客网时间：2024/05/20 04:11

多种布局管理器例子

DMEO

DEMO2

DMEO3

金山词霸界面 DEMO

Qq聊天界面 DMEO

学生管理简单系统 JTable的使用 DEMO

学生管理简单系统连接数据库 DEMO 数据库建立代码

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

GUI编程 （尚学版） DEMO

Component:所有可以显示出来的元素父类

两种常用的Container：

Window 其对象表示自由停泊的顶级窗口

Panel 其对象可作为容纳其它Component对象，但不能独立存在，必须被添加到其它Container中（如window或Applet）

pack();

Frame Frame高级

Panel Panel高级

TextField +Action DEMO DEMO2

DEMO3 "持有对方引用" "内部类"(这种方法最有用) [W1]

DEMO4

内部类给我们的最大的好处就是，能非常方便地访问到外部类的成员。

AWT 5种布局管理器：(见上)

事件监听 DEMO1 DEMO2

鼠标事件 DEMO DEMO2

f.repaint(); //重画

鼠标适配器 DEMO DEMO2

每个Compnent都有一个paint(Graphics g)，

每次重画此Compnent时都自动调用paint()方法 DEMO

WIndow事件 DEMO (使用了匿名类)

键盘事件 DEMO

Netbeans提供一个布局管理器：LayoutManager接口

通过在容器上单击右键，然后选择弹出菜单中的“设置布局”

按产生事件的物理操作和GUI组件的表现效果进行分类：

MouseEvent

WindowEvent

ActionEvent

绘图操作：

Jpanel对象方法有一个方法paintComponent (Graphicx g) ,每当该组件中所包含的内容需要重新显示时，它会被自动调用

自动装箱的功能跟版本有关，是jdk1.5版本之后新增的功能。在 J2SE 5.0之后提供了自动装箱的功能，您可以直接使用以下语句来打包基本数据类型：Integer integer = 10;

integer与int不同，它是对象，用一个引用指向这个对象。正确的定义为Integer i = new Integer（n） //J2SE 5.0之前的做法

System.Exit(0) //程序正常退出，如果为其他错误退出的，就用其他参数，不用0，一般情况很少这种激烈手段

Math类的两个特别有用的常量：

Math.PI (大约为3.14159)

Math.E (大约为2.71828，自然对数的底)

对char执行算术运算： ‘c’-’a’ = 2

3%4 3.0%4.0

栈的“数据共享” --引用

栈的存取速度比堆要快

堆——用new建立，垃圾自动回收负责回收

缺点是：因为在运行时动态分配内存，所以内存的存取速度较慢。

实例化对象的两种方法

对于String这个类来说，它可以用两种方法来建立。

String s = new String("asdf");

和

String s = "asdf";

用这两个形式创建的对象是不同的，第一种是用new()来创建对象的，它是在堆上开辟空间，每调用一次都会在堆上创建一个新的对象。

而第二种的创建方法则是先在栈上创建一个String类的对象引用，然后再去查找栈中有没有存放asdf。如果没有，则将asdf存放进栈，并让str指向asdf；如果已有asdf ，则直接把str指向abc。

在比较两个String是否相等时，一定是用equals()方法，而当测试两个包装类的引用是否指向同一个对象时，应该用“= =”。

因此，可以通过“= =”判断是否相等来验证栈上面的数据共享的问题。

例1：

String s1 = "asdf";

String s2 = "asdf";

System.out.println(s1==s2);

该程序的运行结果是true，那么这说明s1和s2都是指向同一个对象的。

例2：

String s1 =new String ("asdf");

String s2 =new String ("asdf");

System.out.println(s1==s2);

该程序的运行结果是false，这说明用new的方式是生成的对象，每个对象都指向不同的地方。

常用格式控制字符：

/uxxx 以十六进制指定Unicode字符输出 /u0048

/xxx 以八进制指定Unicode字符输出

/b 倒退一个字符

/f 换页

/n 换行

/r 光标移到行首

/t Tab

在输出数值时，默认以十进制显示数值，下面使用java.lang.Ineger所提供的各种toxxx()方法来显示不同进制数值：

Integer.toBinaryString(19) //十进制19转为二进制

Integer.toHexString(19) //转为十六进制

Integer.toOctalString(19) //转为八进制

printf("...%s",...)

println(...) //直接写变量，因为之前已经定义了其变量的类型

常用格式转换字符：

%e, %E 将浮点数以十进制的方式输出，并使用科学记数法

%a, %A 使用科学记数法输出浮点数，以十六进制输出整数部分，以十进制指数部分

%o 八进制输出

%x, %X 十六进制输出

%s, %S 字样符

%c, %C 以字符方式输出，提供的数必须是Byte、Short、Integer、Character

%b, %B 将true或false输出，另外，非null值输出是true,null值输出是false

%t, %T 输出日期时间的前置。详情请查看JAVA API

要存取private成员，就要通过setXXX()与getXXX()等公开方法来进行设置或存取。

This可以引用另一个重载的构造函数实例this(10); // 预设 10 个元素另一对比实例

静态成员属于类，而不属于对象

当调用静态方法时，并不会传入对象的参考，即静态方法中不会有this参考名称，。由于没有this 参考名称，所以在参考方法中不允许使用非静态成员。

Main()方法就是静态方法，如果要直接在mian()中调用其他方法，则此方法必须是静态的。实例

可以使用static定义一个静态区块，就是类载入时的初始化动作。实例实例

递归求解最大公因子（辗转相除法）

递归的代码比较简单，但会有方法调用的负担，有时会比使用循环时效率低

JAVA SE6基本新功能：新增功能

isEmpty() 测试字符串是否为空

copyOf() 可直接返回一个新的数组对象

Java.io包 System类新增的console()方法来返回一个java.io.console对象,

使用console对象的readLine()方法可以直接读取命令行模式的用户文字输入，

使用readPassword()方法时，用户输入的文字将不会显示在画面中

实例1 实例2

对于File类新增了几个方法：

getTotalSpace()取得文件所在的磁盘驱动器之总容量

getUsableSpace()取得文件所在的磁盘驱动器之可用容量实例

加入了系统工具栏图标的支持。

使用SystemTray类的isSupported()方法，测试目前的系统是否支持工具栏图标，如果支持可以使用getSystemTray()取得SystemTray实例，使用add()加入TrayIcon实例。实例

如果想在系统工具栏图标上按右键时弹出窗口，可以指定一个PopupMenu实例给它。实例

Ant构建工具：

下载地址：http://ant.apache.org/

新建JAVA_HOME变量（JDK bin）；新建ANT_HOME变量（ant目录）;新建path变量（ant bin）

Ant项目属性（Property）任务目标（Target）

默认<project>的进入点为run任务，而run任务的完成依赖于compile任务的完成，compile任务的完成依赖于prepare任务的完成。所以在构建开始时，会先执行prepare任务，完成后再执行compile任务，最后执行run任务

实例（在编译前先建立所需要的目录，如果目录已经存在就自动路过这项工作，然后复制前一次编译的.class文件到bak目录。接下来进行纺译）

（在文字模式下直接执行ant 就可以开始构建项目，ant默认会读取同一目录下的build.xml。如果打算单独执行某个任务，则在执行ant指令时写出指定的任务名即可，ant compile）

任务（Task）

可以在一个buildfile中调用另一个buildfile。例如：

...

</ant>

</target>

...

</project>

在<project>中设置value为true，当另一个buildfile中有目标使用了条件（if或unless），这可以给予该条件

一个true的特性

也可以仅仅调用另一个buildfile中的某一个目标。例如：

属性（Property）

属性都是由name/value组成

也可以设置一个.properties文件，之后在buildfile指定运行ant时加载它。方法如下：

还有一些方法可以取得系统属性。例如下面的方式可以取得用户目录：

路径（Path）

使用Ant可以轻易地管理Classpath的设置问题

使用<path>来管理路径参考，

使用<pathelement>来指定目录或jar文件。例如：

</path>

上面的例子也可以使用分号设置一系列位置：

也可以使用<fileset>来指定某个目录下的文件。例如：

</fileset>

</path>

<include>或<exclude>用来包括或排除文件（或是可以使用includes、excludes属性设置），可以在上面使用*

表示零个或多个字符，？表示符合一个字符

常用任务（Task）

提供<javac>或<junit>等任务时可直接使用<pathelement>标签来指定Classpath

</classpath>

</javac >

</target>

提供help信息

<echo><![CDTAT[

Here is help info.

Write you own information here.

]]></echo>

</target>

CDATA表示提供字符信息（Character Data），在![CDATA[ 与 ]] 之间的文字可以使用自由格式编写，

适用长信息文字显示

在执行ant时加上 -p 就会自动显示help这个target上的内容

Ant help 显示详细信息

文件的复制、建立与删除

在每一次构建程序前，会备份前一次的构建结果，可以使用<copy>标签来指定要复制的文件。例如：

</copy>

</target>

在构建程序时，可以使用<mkdir>建立必要的目录。如：

</target>

编译程序

还可以在编译的时候，加入一些Classpath的指定，方便的功能

</fileset>

</classpath>

</javac>

</target>

执行程序

</java>

</target>

制作jar文件

可以将编译完的文件打包成 .jar 文件（Java Archive File），并可以指定MANIFEST文件。例如：

<jar jarfile="${libDir}/${jarFile}"

manifest="META-INF/MANIFEST.MF"

basedir="${classes.dir}"/>

</target>

如果提供有MANIFEST.MF文件，才需要设置manifest属性。为了完成jar打包的任务，可以在METS-INF

目录下提供一个MANIFEST.MF文件，例如：

Manifest-Version: 1.0

Created-By: caterpillar

Main-Class: onlyfun.caterpillar.HelloWorld

Class-Path: HelloWorld.jar

制作war文件

对于网站应用程序的部署，可以使用<war>标签将所有相关的文件包装为war(Web Application Archive)

文件，例如：

</target>

Junit测试（见上的JAVA测试）

内部类：(嵌套类

包含内部类的外部类也叫宿主类

大部分时候，内部类都被作为成员内部类定义，而不是局部内部类，

成员内部类是一种与属性、方法、构造器和初始化块相似的类成员，局部内部类和匿名内部类则不是类成员

成员内部类 = 静态内部类 + 非静态内部类

内部类作为其外部类的成员，因此可以使用任意访问控制符如private、protected、public等修饰

内部类可以在方法里定义，但内部类不可以访问方法的局部变量，除非那个局部变量是final

如果外部类属性、内部类属性与内部类方法里的局部变量同名，则可通过this、外部类类名.this 作为限定来区分。 DEMO

内部类成员可以直接访问外部类的私有数据[X1] ，因为内部类被当成是外部类成员，同一个类的成员之间可以互相访问。

非静态内部类里可以直接访问外部类的private成员

但外部类不能访问内部类的实现细节，例如内部类的属性。

如果外部类需要访问非静态内部类成员，则必须显式创建非静态内部类对象来调用访问其实例成员，DEMO

匿名内部类适合使用一次的...

根据静态成员不能访问非静态成员的规则。

不允许在外部类的静态成员中直接使用非静态内部类。比如main方法里。

非静态内部类里不能有静态方法、静态属性、静态初始化块。

静态内部类：

静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

静态内部类里可以包含静态成员，也可以包含非静态成员

静态内部类不能访问外部类的实例成员，只能访问外部类的类成员 DEMO

外部类依然不能直接访问静态内部类成员，但可以使用静态内部类的类名作为调用者来访问静态内部类的类成员，也可使用静态内部类的对象作为调用者来访问静态内部类的实例成员。 DEMO

除此之外，还允许在接口里定义内部类，接口里定义的内部类默认使用public static修饰，也就是说，接口内部类只能是静态内部类。但用处不大

static内部类        Parcel10   也称类内部类
(1) 为创建一个static内部类的对象，我们不需要一个外部类对象。
(2) 不能从static内部类的一个对象中访问一个外部类对象。
但在存在一些限制：由于static成员只能位于一个类的外部级别，所以内部类不可拥有static数据或static内部类。

在本书早些时候，我建议大家在每个类里都设置一个main()，将其作为那个类的测试床使用。这样做的一个缺点就是额外代码的数量太多。若不愿如此，可考虑用一个static内部类容纳自己的测试代码。如下所示：         TestBed
这样便生成一个独立的、名为TestBed$Tester的类（为运行程序，请使用“java TestBed$Tester”命令）。可将这个类用于测试，但不需在自己的最终发行版本中包含它。
从内部类继承         InheritInner

局部内部类：
       把一个内部类放到方法里定义，局部内部类仅在上方法里有效。因此，局部内部类不能在外部类以外的地方使用，也不能使用访问控制符和static修饰符修饰。
匿名内部类：
         适用于只使用一次的类
匿名的内部类不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

为什么需要内部类：
每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响
如果拥有的是抽象的类或具休的类，而不是接口，那就只能使用内部类才能实现多重循环
1.          内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立
2.          在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类
3.          创建内部类对象的时刻并不依赖于外围类对象的创建
4.          内部类并没有令人类或的“ia-a”关系，它是一个独立的实体

使用内部类：
使用内部类：
         在外部类内部使用内部类                             一般的，通过new
         在外部类以外使用非静态内部类        Out.In in = new Out().new In() ;
         在外部类以外使用静态内部类            StaticOut.StaticIn in = new StaticOut.StaticIn() ;


闭包(closure)与回调：
       闭包（Closure）是一种能被调用的对象，它保存了创建它的作用域的信息。
java并不能显式把支持闭包，但对于非静态内部类而言，它不仅记录了其外部类的详细信息，
还保留了一个创建非静态内部类对象的引用，并且可以直接调用外部类的private成员，因此
可以把非静态内部类当成面向对象领域的闭包。
方便实现回调功能(就是允许客户类通过内部类引用来调用其外部类的方法)
Teachable接口和Programmer父类里包含了相同的work方法，闭包区别开来 DEMO
对象的引用：
         强引用      StrongReference
         软引用       SoftReference
         弱引用       WeakReference
         虚引用       PhantomReference

Import static语法：      实例2

静态工厂方法：实例     http://book.csdn.net/bookfiles/49/100491554.shtml
假如类需要进一步封装创建自身实例的细节，并且控制自身实例的数目，那么可以提供静态工厂方法。
提供了静态工厂方法forName(String name)，它的使用方式如下：
Class c=Class.forName("Sample"); //返回代表Sample类的实例
静态工厂方法的方法名可以是任意的，这一特性的优点是可以提高程序代码的可读性，在方法名中能体现与实例有关的信息。
缺点是与其他的静态方法没有明显的区别，使用户难以识别类中到底哪些静态方法专门负责返回类的实例。
目前比较流行的规范是把静态工厂方法命名为valueOf或者getInstance。
静态工厂方法最主要的特点是：每次被调用的时候，不一定要创建一个新的对象。
利用这一特点，静态工厂方法可用来创建以下类的实例。

Import static语法：      实例2

静态工厂方法：实例     http://book.csdn.net/bookfiles/49/100491554.shtml
假如类需要进一步封装创建自身实例的细节，并且控制自身实例的数目，那么可以提供静态工厂方法。
提供了静态工厂方法forName(String name)，它的使用方式如下：
Class c=Class.forName("Sample"); //返回代表Sample类的实例
静态工厂方法的方法名可以是任意的，这一特性的优点是可以提高程序代码的可读性，在方法名中能体现与实例有关的信息。
缺点是与其他的静态方法没有明显的区别，使用户难以识别类中到底哪些静态方法专门负责返回类的实例。
目前比较流行的规范是把静态工厂方法命名为valueOf或者getInstance。
静态工厂方法最主要的特点是：每次被调用的时候，不一定要创建一个新的对象。
利用这一特点，静态工厂方法可用来创建以下类的实例。
l 单例类：只有惟一的实例的类。 [W1]
l 枚举类：实例的数量有限的类。   DEMO
l 具有实例缓存的类：能把已经创建的实例暂且存放在缓存中的类。
L具有实例缓存的不可变类：不可变类的实例一旦创建，其属性值就不会被改变。

这种类的实例通常会占用较多的内存，或者实例的初始化过程比较冗长，因此随意创建这些类的实例会影响系统的性能。

Tips
熟悉Struts和Hibernate软件的读者会发现，Struts框架的ActionServlet类就是单例类，此外，Hibernate的SessionFactory和Configuration类也是单例类。

JAVA 枚举类型：（enumerated types）
默认继承了java.lang.ENUM类
枚举类的构造器只能使用private访问控制符，默认也是使用private访问控制符

J2SE 5.0之前的常数设置：     例1                    例2
手动实现枚举类： DEMO

如果只在类内部使用常数，声明其为private或protected就可以了
枚举使用enum关键字：    定义枚举类型    应用枚举类型
在一个独立的文件中声明枚举值，或是在某个类中声明枚举成员。实例
每个被枚举的成员其实就是一个实例，默认为final、public、static
将枚举成员显示出来

valueOf()            指定的字符串尝试转换为枚举实例,Enum.valueOf( , ) 获取指定枚举类的枚举值
compareTo()        比较两个枚举对象在枚举时的顺序     实例
compareTo如果返回正值，表示设置为变量的枚举对象的顺序在比较的枚举对象之前
Ordinal()依枚举顺序得到位置索引，默认以0开始       实例           实例2
Values()方法取得所有枚举成员实例，并以数组方式返回，方便地访问各值

枚举上的方法：       定义实例，应用实例

枚举类的构函数 (不能为public)          实例           非公开的构造函数最常见的例子是singleton模式的应用
枚举时也可以一并实现接口（操作一个统一的getDescript方法）                   接口例子   枚举实现接口
实例接口，每个枚举实例实现自己的getDescription方法               实例          测试实例
也可以用抽象方法实现上例：    结果是一样的。         实例

         枚举类的属性、方法和构造器；         DEMO
         实现接口的枚举类：                       DEMO
         包含抽象方法的枚举类：              DEMO

如果枚举只有一个成员，就可以作为一种单例的实现方式。

JAVA 泛型：（generics）（GJ）   增强程序的可读性和稳定性
定义泛型实例    应用实例
自定义泛型类时，类型持有者名称可以使用T(type)，如果是容器的元素可以使用E(element)，
若键值匹配可以使用K(key)、V(value)，Annotation时可以使用A
定义多类型持有者     实例
可以声明数组类型     实例           但不可以使用泛型来建立数组的实例
已经定义了一个泛型类，若要用这个类在另一个泛型类中声明成员     实例
泛型高级语法：
限制泛型可用类型
向下限制extends     实例          实际编写更复杂的例子
向上限制 supe
/
类型通配符      GenericFoo<? Extends List>         表示未知类型，只知道是实现List接口的类
使用<?>或<? Extends SomeClass>的声明方式，只能通过此名称来取得所参考实例的信息，或者是删除信息，但不能增加它的信息。
扩充泛型类      与类的继承相同原理    泛型例        扩充实例
实现泛型接口与接口相同原理            泛型接口例                   泛型实现接口实例

泛型参数化类型与原始类型的兼容性：
参数化类型可以引用一个原始类型的对象，编译报告警告，如：
Collecyion<String> v = new Vector() ;
原始类型可以引用一个参数化类型的对象，编译报告警告，如：
Collecyion v = new Vector<String>() ;
参数化类型不考虑继承关系的：（如，下面的都是错的）
Vector<String> v = new Vector<Object>() ;         //不写Object没错，写了就错误
Vector<Object> v = new Vector<String>() ;
创建数组集合实例时，数组的元素不能使用参数化的类型，（如下面是错误的）
Vector<Integer> vectorList[] = new Vector<Integer>[10] ;

泛型方法                   public <T> void set(T aa)...    //在返回值之前设置一个<>
泛型的 ? 通配符 Collection<?> 任意类型
对异常采用泛型
使用泛形时，泛形类型须为引用类型，不能是基本数据类型
ArrayList<String> list = new ArrayList<Object>();                //no
ArrayList<Object> list = new ArrayList<String>();               //no
ArrayList<String> list = new ArrayList ();          //yes
ArrayList list = new ArrayList<String>();           //yes

自定义泛型：
在类上定义的泛型只对类的非静态成员有效
public class Demo3<T> {
         //在类上定义的泛形只对类的非静态成员有效
         public void run(T t){
         }
         public void eat(T t){
         }
         public static <T> void test(T t){
         }
}

命令行输入：
         直接在java处添加一个传入 args[] 里
System.in.read(); //只能读一个数字
Scanner           scanner.nextInt()           scanner.nextLine()        ScannerDemo
BufferReader               BufferedReaderDemo

正常情况读写文件（字符流）利用FileWriter   DEMO
高级读写文件      利用RandomAccessFile

IO输入/输出：(台湾版)
File类      实例
RamdomAccessFile类实例样本类

位流：
inputSteam与OutputSteam         （所有表示位输入输出流的类之父类）
标准输入流in就是inputSteam类型的实例
FileInputSteam与FileOutputSteam是它们的子类 DEMO    清晰版DEMO
BufferedInputStream与BufferedOutputStream可以为inputStream等增加缓冲区功能 DEMO
BufferedInputStream的数据成员buf是一位数组，默认为512字节。
DataInputStream 与 DataOutputStream 可提供一些对java基本数据类型写入的方法，像读写int、                  double、boolean（成员数据的类型假设都是基本数据类型，则最好用这个）        类例 DEMO
ObjectInputStream 与 ObjectOutputStream 直接将内存中的整个对象存储至文件，而不是只存储           对象中的某些基本类型成员信息，而在下次程序运行时，可以从文件读出数据并还原为对象
类例 DEMO Serializable 序列化。
SequenceInputStream 可以看作是数个InputStream对象的组合。当一个InputStream对象的内容读取         完毕后，它就会取出下一个InputStream对象，直到所有都读取完毕为止。    DEMO
PrintStream 若不用PrintStream例 DEMO
ByteArrayStream   可以直接以程序来指定文件中位的位置来修改所指定的字符。 DEMO
PushbackInputStream 从PushbackInputStream 读出数据后，只要PushBack缓冲区没有满，就可以            使用unread()将数据推回流的前端 DEMO （读写字符）
字符流：

Reader 与 Writer
InputStreamReader 改写上节的PushbackInputStream读写字符例 DEMO
StreamReaderWriterDemo
FileReader 与 FileWriter 如果想要存取的是一个文本文件，可以直接使用。它们分别继承自                   InputStreamReader..可以直接指定文件名称或File对象来打开指定的文本文件，并读入流转换后的               字符，字符的转换会根据系统默认的编码（若要指定编码，则还是使用InputStreamReader等）
DEMO       （在Windows下编写的文本其断行是/r与/n两个连续字符，在Linux下是/n）
BufferReader 与BufferWriter （输入字符quit字符即可退出）DEMO
PrintWriter    上面的PrintStream （将基本类型数据直接转换系统默认编码下对应的字符，再输出至                  OutputStream中）。而这里的PrintWriter在功能上与类似，除了接受OutputStream作为变量外，                还接受Writer对象作为输出的对象     DEMO
CharArrayReader 与 CharArrayWriter 与ByteArrayStream类似，它们是位数组，这具是字符数           组     DEMO
PushbackReader 类似上面的 PushbackInputStream ，都拥有一个PushBack缓冲区，只不过                         PushbackReader 所处理的是字符     DEMO
IO输入输出流（尚学堂版）
不同角度的分类
按数据流的方向分为输入流和输出流 (在程序的角度)
按处理数据单位分为字节流和字符流
按功能不同分为         节点流和处理流

字节流
字符流
输入流
InputStream
Reader
输出流
OutputStream
writer

继承自InputStream的流数据的单位为字节（8bit）；下图中深色为节点流浅色为处理流
编程习惯：先写flush ，再写close()

继承自Reader下图中深色为节点流浅色为处理流的流，数据的单位为字符（16bit）；下图中深色为节点流浅色为处理流

节点流类型： DEMO

处理流类型： DEMO

缓冲流:
前面四种缓冲流，缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新方法。TestBufferStream1 TestBufferStream2
缓冲输入流支持其父类的mark和reset方法。
BufferReader提供了readLine方法用于读取一行字符串（以/r或/n结束）
BufferWriter提供了readLine方法用于写入一个行分隔符。
对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法会将内存中的数据立刻写出
转换流： TestTransForm1 TestTransForm2
InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换
构造时可以指定其编码集合
数据流： TestDataStream
Print流：DEMO TestPrintStream1 2 3
PrintWriter和PrintStream都属性输出流，分别对应于字符流和字节流
不会抛出异常
自动的flush功能
Object流：TestObjectIO
transient关键字                  标记是透明的
serialzable接口                 标记序列化
exstenalizable接口              标记外部化
IO输入输出流（传智版） demo
速度快，断电数据丢失                   速度慢，断电数据还存在
非持久化的数据（RAM-内存）   ←→    持久保存的数据（硬盘/磁带/U盘）

File工具类   它既可代表文件、也可代表目录。 DEMO
File类，它可以访问文件或者目录，但它不能读取文件的内容。
1. 列出当前目录下的所有文件。
2. 静态方法，可列出当前系统下的所有根目录。

用Java实现文件搜索功能？ DEMO
1. 先列出系统的所有根路径。
2. 通过递归不停地搜索。

RandomAccessFile工具类        DEMO 追加DEMO 插入DEMO
RAM （ Random Access Memory ）
功能很强大：即可输入、也可输出。还可以向已有的文件追加内容、插入内容都行。
Random －想访问哪个点的数据，就可直接访问哪个点。
RandomAccessFile 它比普通输入、输出流多了两个功能：
1. 多了一个读写标识。—————构造RandomAccessFile时已经传入了
2. 多了一个文件指针，这个文件指针标识接下来将要读、写的位置。
但它只能读、写文件！！！
RandomAccessFile既包含了InputStream的方法，也包含了OutputStream的方法。
移动文件指针： void seek(long pos)
获取文件指针的位置： long getFilePointer()

输入流“取水”的三个方法
read() －> 返回实际所取的一滴“水”。
read(buff) －> 返回实际所取的水滴的数量。

输出流“输出水”的三个方法
write(int) －> 将单独的一滴“水”输出到输出流
write(buff) －> 将buff中所有“水滴”输出到输出流。
write(buff , off , length) －> 将buff中从off开始，长度为length的“水滴”输出到输出流。

以Stream结尾的都是字节流，以Writer/Reader结尾的是字符流
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+-------
|      InputStream      |     OutputStream       |        Reader       |         Writer     | 抽象基类
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+------
|   FileInputStream     |   FileOutputStream     |      FileReader     |       FileWriter      | 读写文件
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+------
| ByteArrayInputStream | ByteArrayOutputStream |   CharArrayReader   |    CharArrayWriter    | 读写数组
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+-------
|                      |                     |     StringReader    |     StringWriter       | 读写字符串
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+------
|   PipedInputStream    |    PipedOutputStream   |      PipedReader    |     PipedWriter     | 管道流(线程)
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+------
| FilterInputStream    | FilterOutputStream   |     FilterReader   |      FilterWriter   | 处理流的抽象基类
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+-----
| BufferedInputStream   | BufferedOutputStream   |    BufferedReader      |     BufferedWriter | 增加缓冲功能
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+------
|                       |      PrintStream       |                   |       PrintWriter    | 打印流
+-----------------------+------------------------+---------------------+-----------------------+-----------------------+------
|                       |                      | InputStreamReader | OutputStreamWriter [W1] | 转换流（将字节流转换为字符流）

用OutputStreamWriter包住FileOutputStream效果好像相当于FileWriter

最后都能用到了字符流

输出时，一般包装成PrintStream就够了，因为它用起来很方便。
输入时，一般包装BufferedReader就够了，因此它包含一个readLine的方法，可以每次读取一行。

重定向标准输入/输出：
默认情况下，
标准输入：由System.in代表，通常由机器上的键盘代表。
       也就是说，当程序通过System.in来读取时，其实就是通过键盘来读取。
标准输出：由System.out代表，通常由机器上的显示器代表。
       也就是说，当程序通过System.out来输出时，其实就是通过就是输出到显示器。

在某些情况下，我们可以改变标准输入/输出，这就是所谓的重定向标准输入/输出：
System类里提供了如下两个方法：
setOut : 重定向标准输出 DEMO
setIn : 重定向标准输入   DEMO

读取其他进程的输出数据。
Java程序可以运行外部进程，用Runtime的exec方法。   DEMO
通过IO可以读取其他进程的输入、输出。

比如读文件：
new BufferedReader(new InputStreamReader(new FileInputStream(...)));
读键盘
new BufferedReader(new InputStreamReader(System.in));
读网络
new BufferedReader(new InputStreamReader(socket.getInputStream()));
生成空文件，如迅雷下载 DEMO
模枋CMD命令行工具 DEMO

新IO ：
传统IO都是阻塞式的
传统IO是面向流的，一次只能处理一个字节
NIO采用内存映射文件的方式来处理输入／输出，NIO将文件或文件的一段区域映射到内存上，这样就可以像访问内存一样来访问文件（这种方式模拟了操作系统上的虚拟内存概念）。
Channel（通道）/Buffer(缓冲) 是NIO中的两个核心对象。
Charset类（用于将UNICODE字符串映射成字节队列，以及逆映射）
Selector类（支持非阻塞式IO）

使用Buffer抽象类：        DEMO
常用子类：ByteBuffer CharBuffer
几个重要概念：
容量（capacity）
界限（limit）
位置（position）
Mark
0 < mark < position < limit < capacity

Buffer的主要作用是装入数据，然后输入数据，开始时buffer的pofition为0/limit为capacity ，程序调用put不断向Buffer中放入数据（或者从Channel中获取一些数据），每放入一些数，Buffer的position相应地向后移动一些位置。
         当Buffer装入数据结束后，调用Buffer的flip方法，将limit设置为position所在的位置，将position设置为0，这样使得从buffer中读数据时总是从0开始，读完刚刚装入的数据即结束，clear方法仅仅是将position设置为0，将limit设置为capaticy，这样为再次向Buffer放入数据做好准备。

使用Channel抽象类：    DEMO
Channel类似于传统的流对象，但与传统对象不同的是，有两个主要区别：
Channel可以直接将文件的部分或全部直接映射成Buffer
程序不能直接访问Channel中的数据，包括读取、写入都不行，Channel只能与Buffer进行交互。
Pipe.SinkChanel、Pile.SourceChanel用于支持线程之间通信的管道；
ServerSocketChanel、SocketChanhel用于支持TCP网络通信的Channel

编码集和 Charset
文件锁

使用NIO实例非阻塞Socket通信：
Selector:
         是SelectableChanel对象的多路复用器，所有希望采用非阻塞方式进行通信的Channel都应该注册到Selector对象。可通过调用此类的静态open()方法来创建Selector实例，此方法使用系统默认的Selector来返回新的Selector
SelectableChannel:
         代表可以支持非阻塞IO操作的的Channel对象，可以将其注册到Selector上，这种注册的关系由SelectionKey实例表示。Selector对象提供一个selector方法，此方法允许应用程序同时监控多个Channel
/

网络编程（尚）： Socket DEMO

ICP/IP模型中，
网络层相当于IP层
传输层相当于TCP/UDP层（好像是）

TCP(transmission control protocol) （慢、可靠）
是专门设计用于在不可靠的因特网上提供可靠的端到端的字节流通信的协议。
它是一种面向连接的协议。TCP连接是字节流而非报文流。
UDP(user data protocol)        （快、不可靠）
UDP向应用程序提供了一种发送封闭的原始IP数据包的方法，并且发送时无需建立连接，是一种不可靠的连接。

两个java应用程序可通过一个双向的网络通信连接实现数据交换，这个双向链路的一端称为一个Socket。
Sock通常用来实现client-server连接
jsvs.net包里的两个类：Socket ServerSocket,实现双向连接的client和server端
建立连接时所需的寻址信息为远程计算机的IP地址和端口号（Port number）
TCP端口与UDP端口分开的，每有65536个端口，   （32位系统）
DatagramSocket       DatagramPacket (UDP)

数据结构（对象容器）：集合
习惯写法：        Collection ee = new ArrayList() ;