java基础--连载7

Jdk5.0新特性：

Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。

--------------------------------------------------

增强for循环：foreach语句，foreach简化了迭代器。

格式：// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器

for( 元素类型 变量名 :Collection集合 & 数组 ) {

  …

}

高级for循环和传统for循环的区别：

高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

 

高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用foreach语句。

 

1)、作用：对存储对象的容器进行迭代： 数组  collection  map

2)、增强for循环迭代数组：

String[] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候

for(Strings : arr) {

  System.out.println(s); 

}

3)、单列集合 Collection：

Listlist = new ArrayList();

list.add("aaa");

// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能

for(Object obj : list) {

  String s = (String) obj;

  System.out.println(s);

}

4)、双列集合 Map：

Map map= new HashMap();

map.put("a","aaa");

// 传统方式：必须掌握这种方式

Setentrys = map.entrySet(); // 1.获得所有的键值对Entry对象

iter =entrys.iterator(); // 2.迭代出所有的entry

while(iter.hasNext()){

  Map.Entry entry = (Entry) iter.next();

  String key = (String) entry.getKey(); // 分别获得key和value

  String value = (String) entry.getValue();

  System.out.println(key + "=" +value);

}

// 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。

for(Object obj : map.entrySet()) {

  Map.Entryentry = (Entry) obj;  // obj 依次表示Entry

  System.out.println(entry.getKey()+ "=" + entry.getValue());

}

5）、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。

6)、增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；

int[]arr = {1,2,3};

for(intnum : arr) {

  num = 0; //不能改变数组的值

}

System.out.println(arr[1]);//2

--------------------------------------------------

可变参数（...）：用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。

 

和以前接收数组不一样的是：

以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。

如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。

如果要获取多个int数的和呢？可以使用将多个int数封装到数组中，直接对数组求和即可。

---------------------------------------------------

静态导入：导入了类中的所有静态成员，简化静态成员的书写。

import static java.util.Collections.*;  //导入了Collections类中的所有静态成员

---------------------------------------------------

枚举：关键字enum

问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个；

解决办法：

1）、在setGrade方法中做判断，不符合格式要求就抛出异常；

2）、直接限定用户的选择，通过自定义类模拟枚举的方式来限定用户的输入，写一个Grade类，私有构造函数，对外提供5个静态的常量表示类的实例；

3)、jdk5中新定义了枚举类型，专门用于解决此类问题；

4)、枚举就是一个特殊的java类，可以定义属性、方法、构造函数、实现接口、继承类；

------------------------------------------------------------------------------

自动拆装箱：java中数据类型分为两种 ： 基本数据类型   引用数据类型(对象)

在 java程序中所有的数据都需要当做对象来处理，针对8种基本数据类型提供了包装类，如下：

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

 

jdk5以前基本数据类型和包装类之间需要互转：

基本---引用  Integer x = new Integer(x);

引用---基本  int num = x.intValue();

1)、Integer x =1; x = x + 1;  经历了什么过程？装箱 à 拆箱 à 装箱；

2)、为了优化，虚拟机为包装类提供了缓冲池，Integer池的大小 -128~127一个字节的大小；

3)、String池：Java为了优化字符串操作 提供了一个缓冲池；

----------------------------------------------------------

泛型：jdk1.5版本以后出现的一个安全机制。表现格式：<>

好处：

1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。

2：避免了强制转换的麻烦。

 

只要带有<>的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给<>中传递一个具体的引用数据类型。

 

泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。

为什么? 因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。

在运行时，如何知道获取的元素类型而不用强转呢？

泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。

 

什么时候用泛型类呢？

当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。

----------------------------------------------------------

泛型在程序定义上的体现：

//泛型类：将泛型定义在类上。

class Tool<Q> {

    private Q obj;

    public  void setObject(Q obj) {

        this.obj = obj;

    }

    public Q getObject() {

        return obj;

    }

}

//当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上。

    public <W> voidmethod(W w) {

        System.out.println("method:"+w);

    }

//静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

    public static<Q> void function(Q t) {

        System.out.println("function:"+t);

    }

//泛型接口.

interface Inter<T> {

    void show(T t);

}

class InterImpl<R> implements Inter<R> {

    public void show(R r) {

        System.out.println("show:"+r);

    }

}

------------------------------------------------------------

泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

 

泛型限定：

    上限：？extends E：可以接收E类型或者E的子类型对象。

    下限：？super E：可以接收E类型或者E的父类型对象。

 

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

 

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

 

泛型的细节：

1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；

2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；

    原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；

3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList<String>al = new ArrayList<Object>();  //错

//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。

ArrayList<?extends Object> al = new ArrayList<String>();

al.add("aa");  //错

//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extendsObject 代表Object的子类型不确定，怎么能添加具体类型的对象呢？

public static voidmethod(ArrayList<? extends Object> al) {

al.add("abc");  //错

  //只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。

}

------------------------------------------------------------------------------------------------------------------------------------------------

API--- java.lang.System:属性和行为都是静态的。

longcurrentTimeMillis(); // 返回当前时间毫秒值

exit(); // 退出虚拟机

Properties getProperties() ;  // 获取当前系统的属性信息

 

Properties prop = System.getProperties(); //获取系统的属性信息，并将这些信息存储到Properties集合中。

 

System.setProperty("myname","毕老师"); //给系统属性信息集添加具体的属性信息

//临时设置方式：运行jvm时，可以通过jvm的参数进行系统属性的临时设置，可以在java命令的后面加入 –D<name>=<value>  用法：java –Dmyname=小明 类名。

 

String name = System.getProperty("os.name");//获取指定属性的信息

 

//想要知道该系统是否是该软件所支持的系统中的一个。

Set<String> hs = new HashSet<String>();

hs.add("Windows XP");

hs.add("Windows 7");

if(hs.contains(name))

    System.out.println("可以支持");

else

    System.out.println("不支持");

--------------------------------------------------------------------------------------------------------------------

API--- java.lang.Runtime:类中没有构造方法，不能创建对象。

但是有非静态方法。说明该类中应该定义好了对象，并可以通过一个static方法获取这个对象。用这个对象来调用非静态方法。这个方法就是 static Runtime getRuntime();

 

这个Runtime其实使用单例设计模式进行设计。

 

class RuntimeDemo {

       publicstatic void main(String[] args) throws Exception {

              Runtimer = Runtime.getRuntime();

              Processp = r.exec("notepad.exe SystemDemo.java");  //运行指定的程序

              Thread.sleep(4000);

              p.destroy();  //杀掉进程

       }

}

--------------------------------------------------------------------------------------------------------------------

API--- java.util.Math:用于数学运算的工具类，属性和行为都是静态的。该类是final不允许继承。

 

static double ceil(double a) ; //返回大于指定数值的最小整数

static double floor(double a) ; //返回小于指定数值的最大整数

static long round(double a) ; //四舍五入成整数

static double pow(double a, double b) ; //a的b次幂

static double random(); //返回0~1的伪随机数

 

       publicstatic void main(String[] args) {

              Randomr = new Random();

              for(intx=0; x<10; x++) {

                     //doubled = Math.floor(Math.random()*10+1);

                     //intd  = (int)(Math.random()*10+1);

                     intd = r.nextInt(10)+1;

                     System.out.println(d);

              }

       }

--------------------------------------------------------------------------------------------------------------------

API--- java.util.Date：日期类，月份从0-11；

       /*

       日期对象和毫秒值之间的转换。

       1，日期对象转成毫秒值。Date类中的getTime方法。

       2，如何将获取到的毫秒值转成具体的日期呢？

              Date类中的setTime方法。也可以通过构造函数。

       */

              //日期对象转成毫秒值

              Dated = new Date();

              longtime1 = d.getTime();

              longtime2 = System.currentTimeMillis(); / /毫秒值。

             

              //毫秒值转成具体的日期

              longtime = 1322709921312l;

              Dated = new Date();

              d.setTime(time);

/*

       将日期字符串转换成日期对象：使用的就是DateFormat方法中的 Date parse(String source)；

       */

       publicstatic void method() throws Exception {

              Stringstr_time = "2011/10/25";

              DateFormat df = new SimpleDateFormat("yyyy/MM/dd");//SimpleDateFormat作为可以指定用户自定义的格式来完成格式化。

              Date d = df.parse(str_time);

       }

       /*

       如果不需要使用特定的格式化风格，完全可以使用DateFormat类中的静态工厂方法获取具体的已经封装好风格的对象。getDateInstance();getDateTimeInstance();

       */

              Dated = new Date();

              DateFormatdf = DateFormat.getDateInstance(DateFormat.LONG);

              df= DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);

              Stringstr_time = df.format(d);

 

       //将日期对象转换成字符串的方式：DateFormat类中的format方法。

           //创建日期格式对象。

              DateFormat df = new SimpleDateFormat(); //该对象的建立内部会封装一个默认的日期格式。11-12-1 下午1:48

              //如果想要自定义日期格式的话。可使用SimpleDateFormat的构造函数。将具体的格式作为参数传入到构造函数中。如何表示日期中年的部分呢？可以必须要参与格式对象文档。

              df = newSimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

              //调用DateFormat中的format方法。对已有的日期对象进行格式化。

              String str_time = df.format(d);

--------------------------------------------------------------------------------------------------------------------

API--- java.util. Calendar：日历类

       publicstatic void method(){

              Calendarc = Calendar.getInstance();

              System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"

                                          +getNum(c.get(Calendar.DAY_OF_MONTH))+"日"

                                          +"星期"+getWeek(c.get(Calendar.DAY_OF_WEEK)));

       }

       publicstatic String getNum(int num){

              returnnum>9 ? num+"" : "0"+num;

       }

       publicstatic String getWeek(int index){

       /*

       查表法：建立数据的对应关系.

       最好：数据个数是确定的，而且有对应关系。如果对应关系的一方，是数字，而且可以作为角标，那么可以通过数组来作为表。

       */

              String[]weeks = {"","日","一","二","三","四","五","六"};

              returnweeks[index];

       }

------------------------------------------------------------------------------------------------------------------------------------------------

IO流：★★★★★，用于处理设备上数据。

流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。

流也进行分类：

1：输入流（读）和输出流（写）。

2：因为处理的数据不同，分为字节流和字符流。

 

字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

 

那么为什么要有字符流呢？因为字符每个国家都不一样，所以涉及到了字符编码问题，那么GBK编码的中文用unicode编码解析是有问题的，所以需要获取中文字节数据的同时+ 指定的编码表才可以解析正确数据。为了方便于文字的解析，所以将字节流和编码表封装成对象，这个对象就是字符流。只要操作字符数据，优先考虑使用字符流体系。

 

注意：流的操作只有两种：读和写。

 

流的体系因为功能不同，但是有共性内容，不断抽取，形成继承体系。该体系一共有四个基类，而且都是抽象类。

 

字节流：InputStream  OutputStream

字符流：Reader  Writer

 

在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称。

--------------------------------------------------------------------------------------------------------------------

public static void main(String[] args)throws IOException { //读、写都会发生IO异常

       /*

       1：创建一个字符输出流对象，用于操作文件。该对象一建立，就必须明确数据存储位置，是一个文件。

       2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存储数据的文件。

       3：如果指定位置，出现了同名文件，文件会被覆盖。

       */

       FileWriterfw = new FileWriter("demo.txt"); // FileNotFoundException

       /*

       调用Writer类中的write方法写入字符串。字符串并未直接写入到目的地中，而是写入到了流中，(其实是写入到内存缓冲区中)。怎么把数据弄到文件中？

       */

       fw.write("abcde");

       fw.flush(); // 刷新缓冲区，将缓冲区中的数据刷到目的地文件中。

       fw.close();// 关闭流，其实关闭的就是java调用的系统底层资源。在关闭前，会先刷新该流。

}

 

close()和flush()的区别：

flush()：将缓冲区的数据刷到目的地中后，流可以使用。

close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。

--------------------------------------------------------------------------------------------------------------------

io异常的处理方式：io一定要写finally；

 

FileWriter写入数据的细节：

1：window中的换行符：\r\n两个符号组成。 linux：\n。

2：续写数据，只要在构造函数中传入新的参数true。

3：目录分割符：window \\  /

 

public static void main(String[] args) {

              FileWriterfw = null;

              try{

                     fw= new FileWriter("demo.txt",true);

                     fw.write("abcde");

              }

              catch(IOException e ){

                     System.out.println(e.toString()+"....");

              }

              finally{

                     if(fw!=null)

                            try{

                                   fw.close();

                            }

                            catch(IOException e){

                                   System.out.println("close:"+e.toString());

                            }

              }

}

--------------------------------------------------------------------------------------------------------------------

FileReader：使用Reader体系，读取一个文本文件中的数据。返回 -1，标志读到结尾。

import java.io.*;

class FileReaderDemo {

       publicstatic void main(String[] args) throws IOException {

              /*

              创建可以读取文本文件的流对象，FileReader让创建好的流对象和指定的文件相关联。

              */

              FileReader fr = new FileReader("demo.txt");

              intch = 0;

              while((ch =fr.read())!= -1) { //条件是没有读到结尾

                     System.out.println((char)ch); //调用读取流的read方法，读取一个字符。

              }

              fr.close();

       }

}

--------------------------------------------------------------------------------------------------------------------

读取数据的第二种方式：第二种方式较为高效，自定义缓冲区。

import java.io.*;

class FileReaderDemo2 {

       publicstatic void main(String[] args) throws IOException {

              FileReaderfr = new FileReader("demo.txt"); //创建读取流对象和指定文件关联。

              //因为要使用read(char[])方法，将读取到字符存入数组。所以要创建一个字符数组，一般数组的长度都是1024的整数倍。

              char[]buf = new char[1024];

              intlen = 0;

              while((len=fr.read(buf)) != -1) {

                     System.out.println(newString(buf,0,len));

              }

              fr.close();

       }

}

--------------------------------------------------------------------------------------------------------------------

IO中的使用到了一个设计模式：装饰设计模式。

装饰设计模式解决：对一组类进行功能的增强。

包装：写一个类(包装类)对被包装对象进行包装；

 * 1、包装类和被包装对象要实现同样的接口；

 * 2、包装类要持有一个被包装对象；

 * 3、包装类在实现接口时，大部分方法是靠调用被包装对象来实现的，对于需要修改的方法我们自己实现；

--------------------------------------------------------------------------------------------------------------------

字符流：

Reader：用于读取字符流的抽象类。子类必须实现的方法只有 read(char[],int, int) 和 close()。

     |---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

       |---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法setLineNumber(int)和 getLineNumber()，它们可分别用于设置和获取当前行号。

     |---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

       |---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

     |---CharArrayReader：

     |---StringReader：

-------------------------------------------------

Writer：写入字符流的抽象类。子类必须实现的方法仅有 write(char[],int, int)、flush() 和 close()。

     |---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

     |---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

       |---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

     |---PrintWriter：

     |---CharArrayWriter：

     |---StringWriter：

---------------------------------

字节流：

InputStream：是表示字节输入流的所有类的超类。

     |--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。

     |--- FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。

       |--- BufferedInputStream：该类实现缓冲的输入流。

       |--- Stream：

     |--- ObjectInputStream：

     |--- PipedInputStream：

-----------------------------------------------

OutputStream：此抽象类是表示输出字节流的所有类的超类。

     |--- FileOutputStream：文件输出流是用于将数据写入File 或 FileDescriptor 的输出流。

     |--- FilterOutputStream：此类是过滤输出流的所有类的超类。

       |--- BufferedOutputStream：该类实现缓冲的输出流。

       |--- PrintStream：

       |--- DataOutputStream：

     |--- ObjectOutputStream：

     |--- PipedOutputStream：

--------------------------------

缓冲区是提高效率用的，给谁提高呢？

BufferedWriter：是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。

    FileWriter fw = newFileWriter("bufdemo.txt");

    BufferedWriter bufw =new BufferedWriter(fw);//让缓冲区和指定流相关联。

    for(int x=0; x<4;x++){

        bufw.write(x+"abc");

        bufw.newLine(); //写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。

        bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。

    }

    bufw.close();//关闭缓冲区，其实就是在关闭具体的流。

-----------------------------

BufferedReader：

    FileReader fr = newFileReader("bufdemo.txt");

    BufferedReaderbufr  = new BufferedReader(fr);

    String line = null;

    while((line=bufr.readLine())!=null){  //readLine方法返回的时候是不带换行符的。

        System.out.println(line);

    }

    bufr.close();

-----------------------------

//记住，只要一读取键盘录入，就用这句话。

BufferedReader bufr = new BufferedReader(newInputStreamReader(System.in));

BufferedWriter bufw = new BufferedWriter(newOutputStreamWriter(System.out));//输出到控制台

String line = null;

while((line=bufr.readLine())!=null){

    if("over".equals(line))

        break;

    bufw.write(line.toUpperCase());//将输入的字符转成大写字符输出

    bufw.newLine();

    bufw.flush();

    }

bufw.close();

bufr.close();

------------------------------

流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。

 

流的操作规律：

1，明确源和目的。

       数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

       数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

2，操作的数据是否是纯文本数据？

       如果是：数据源：Reader

                  数据汇：Writer

       如果不是：数据源：InputStream

                    数据汇：OutputStream

3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？

       明确操作的数据设备。

       数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)

       数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。

4，需要在基本操作上附加其他功能吗？比如缓冲。

       如果需要就进行装饰。

 

转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

 

转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。

 

发现转换流有一个子类就是操作文件的字符流对象：

InputStreamReader

       |--FileReader

OutputStreamWriter

       |--FileWrier

 

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

 

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。

FileReader fr = newFileReader("a.txt");

InputStreamReader isr = newInputStreamReader(new FileInputStream("a.txt"),"gbk");

以上两句代码功能一致，

如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。

 

如果需要制定码表，必须用转换流。

转换流 = 字节流+编码表。

转换流的子类File = 字节流 + 默认编码表。

 

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

-----------------------------------------------------------------------------------------------

File类：将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。

 

File类常见方法：

1：创建。

    boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。

    boolean mkdir()：创建此抽象路径名指定的目录。

    boolean mkdirs()：创建多级目录。

2：删除。

    boolean delete()：删除此抽象路径名表示的文件或目录。

    void deleteOnExit()：在虚拟机退出时删除。

注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

    window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。

3：获取.

    long length()：获取文件大小。

    String getName()：返回由此抽象路径名表示的文件或目录的名称。

    String getPath()：将此抽象路径名转换为一个路径名字符串。

    String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

    String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。

long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。

File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。

4：判断：

    boolean exists()：判断文件或者文件夹是否存在。

    boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。

    boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。

    boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

    boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。

5：重命名。

     boolean renameTo(Filedest)：可以实现移动的效果。剪切+重命名。

 

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

------------------------------------------------------------------------------------------------

递归：就是函数自身调用自身。

什么时候用递归呢？

当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。

简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

 

递归的注意事项：

1：一定要定义递归的条件。

2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。

其实递归就是在栈内存中不断的加载同一个函数。

------------------------------------------------------------------------------------------------

Java.util.Properties：一个可以将键值进行持久化存储的对象。Map--Hashtable的子类。

Map

       |--Hashtable

              |--Properties：用于属性配置文件，键和值都是字符串类型。

特点：1：可以持久化存储数据。2：键值都是字符串。3：一般用于配置文件。

 

|-- load()：将流中的数据加载进集合。

原理：其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过= 对该行数据进行切割，左边就是键，右边就是值，将键、值存储到properties集合中。

|-- store()：写入各个项后，刷新输出流。

|-- list()：将集合的键值数据列出到指定的目的地。

-------------------------------------------------------------------------------------------------

以下介绍IO包中扩展功能的流对象：基本都是装饰设计模式。

Java.io.outputstream.PrintStream：打印流

1：提供了更多的功能，比如打印方法。可以直接打印任意类型的数据。

2：它有一个自动刷新机制，创建该对象，指定参数，对于指定方法可以自动刷新。

3：它使用的本机默认的字符编码.

4：该流的print方法不抛出IOException。

 

该对象的构造函数。

PrintStream(File file)  ：创建具有指定文件且不带自动行刷新的新打印流。

PrintStream(File file, String csn) ：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。

PrintStream(OutputStream out) ：创建新的打印流。

PrintStream(OutputStream out, boolean autoFlush) ：创建新的打印流。

PrintStream(OutputStream out, boolean autoFlush, Stringencoding) ：创建新的打印流。

PrintStream(String fileName) ：创建具有指定文件名称且不带自动行刷新的新打印流。

PrintStream(String fileName, String csn)

 

PrintStream可以操作目的：1：File对象。2：字符串路径。3：字节输出流。

前两个都JDK1.5版本才出现。而且在操作文本文件时，可指定字符编码了。

 

当目的是一个字节输出流时，如果使用的println方法，可以在printStream对象上加入一个true参数。这样对于println方法可以进行自动的刷新，而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串，而且都对IO异常进行了内部处理。

 

既然操作的数据都转成了字符串，那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类，可以直接操作字符数据，同时也可以指定具体的编码。

--------------------------------------------------------

PrintWriter：具备了PrintStream的特点同时，还有自身特点：

该对象的目的地有四个：1：File对象。2：字符串路径。3：字节输出流。4：字符输出流。

 

开发时尽量使用PrintWriter。

 

方法中直接操作文件的第二参数是编码表。

直接操作输出流的，第二参数是自动刷新。

 

//读取键盘录入将数据转成大写显示在控制台.

BufferedReader bufr = new BufferedReader(newInputStreamReader(System.in));//源：键盘输入

//目的：把数据写到文件中，还想自动刷新。

PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);//设置true后自动刷新

String line = null;

while((line=bufr.readLine())!=null){

    if("over".equals(line))

        break;

    out.println(line.toUpperCase());//转大写输出

}

    //注意：System.in，System.out这两个标准的输入输出流，在jvm启动时已经存在了。随时可以使用。当jvm结束了，这两个流就结束了。但是，当使用了显示的close方法关闭时，这两个流在提前结束了。

out.close();

bufr.close();

------------------------------------------------------------------------------------------------

SequenceInputStream：序列流，作用就是将多个读取流合并成一个读取流。实现数据合并。

表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。

该对象的构造函数参数是枚举，想要获取枚举，需要有Vector集合，但不高效。需用ArrayList，但ArrayList中没有枚举，只有自己去创建枚举对象。

但是方法怎么实现呢？因为枚举操作的是具体集合中的元素，所以无法具体实现，但是枚举和迭代器是功能一样的，所以，可以用迭代替代枚举。

 

合并原理：多个读取流对应一个输出流。

切割原理：一个读取流对应多个输出流。

 

import java.io.*;

import java.util.*;

class  SplitFileDemo{

    private static final String CFG = ".properties";

    private static final String SP =".part";

    public static void main(String[] args)throws IOException{

        File file = newFile("c:\\0.bmp");

        File dir = newFile("c:\\partfiles");

        meger(dir);

    }

    //数据的合并。

    public static void meger(File dir)throwsIOException{

        if(!(dir.exists() &&dir.isDirectory()))

            throw new RuntimeException("指定的目录不存在，或者不是正确的目录");

        File[] files = dir.listFiles(newSuffixFilter(CFG));

        if(files.length==0)

            throw new RuntimeException("扩展名.proerpties的文件不存在");

        //获取到配置文件

        File config = files[0];

        //获取配置文件的信息。

        Properties prop = new Properties();

        FileInputStream fis = newFileInputStream(config);

        prop.load(fis);

        String fileName =prop.getProperty("filename");

        int partcount =Integer.parseInt(prop.getProperty("partcount"));

        //--------------------------

        File[] partFiles = dir.listFiles(newSuffixFilter(SP));

        if(partFiles.length!=partcount)

            throw new RuntimeException("缺少碎片文件");

        //---------------------

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

        for(int x=0; x<partcount; x++){

            al.add(new FileInputStream(newFile(dir,x+SP)));

        }

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

        SequenceInputStream sis = newSequenceInputStream(en);

        File file = new File(dir,fileName);

        FileOutputStream fos = newFileOutputStream(file);

        byte[] buf = new byte[1024];

        int len = 0;

        while((len=sis.read(buf))!=-1){

            fos.write(buf,0,len);

        }

        fos.close();

        sis.close();

    }

    //带有配置信息的数据切割。

    public static void splitFile(Filefile)throws IOException{

        //用一个读取流和文件关联。

        FileInputStream fis = newFileInputStream(file);

        //创建目的地。因为有多个。所以先创建引用。

        FileOutputStream fos = null;

        //指定碎片的位置。

        File dir = newFile("c:\\partfiles");

        if(!dir.exists())

            dir.mkdir();

        //碎片文件大小引用。

        File f = null;

        byte[] buf = new byte[1024*1024];

        //因为切割完的文件通常都有规律的。为了简单标记规律使用计数器。

        int count = 0;

        int len = 0;

        while((len=fis.read(buf))!=-1){

            f = newFile(dir,(count++)+".part");

            fos = new FileOutputStream(f);

            fos.write(buf,0,len);

            fos.close();

        }

        //碎片文件生成后，还需要定义配置文件记录生成的碎片文件个数。以及被切割文件的名称。

        //定义简单的键值信息，可是用Properties。

        String filename = file.getName();

        Properties prop = new Properties();

        prop.setProperty("filename",filename);

        prop.setProperty("partcount",count+"");

        File config = newFile(dir,count+".properties");

        fos = new FileOutputStream(config);

        prop.store(fos,"");

        fos.close();

        fis.close();

    }

}

class SuffixFilterimplements FileFilter{

    private String suffix;

    SuffixFilter(String suffix){

        this.suffix  = suffix;

    }

    public boolean accept(File file){

        return file.getName().endsWith(suffix);

    }

}

-----------------------------------------------------------------------------------------------

RandomAccessFile:

特点：

1：该对象即可读取，又可写入。

2：该对象中的定义了一个大型的byte数组，通过定义指针来操作这个数组。

3：可以通过该对象的getFilePointer()获取指针的位置，通过seek()方法设置指针的位置。

4：该对象操作的源和目的必须是文件。

5：其实该对象内部封装了字节读取流和字节写入流。

注意：实现随机访问，最好是数据有规律。

 

class RandomAccessFileDemo{

    public static voidmain(String[] args) throws IOException{

        write();

        read();

        randomWrite();

    }

    //随机写入数据，可以实现已有数据的修改。

    public static voidrandomWrite()throws IOException{

        RandomAccessFileraf = new RandomAccessFile("random.txt","rw");

        raf.seek(8*4);

        System.out.println("pos:"+raf.getFilePointer());

        raf.write("王武".getBytes());

        raf.writeInt(102);

        raf.close();

    }

    public static voidread()throws IOException{

        RandomAccessFileraf = new RandomAccessFile("random.txt","r");//只读模式。

        //指定指针的位置。

        raf.seek(8*1);//实现随机读取文件中的数据。注意：数据最好有规律。

        System.out.println("pos1:"+raf.getFilePointer());

        byte[] buf = newbyte[4];

        raf.read(buf);

        String name = newString(buf);

        int age =raf.readInt();

        System.out.println(name+"::"+age);

        System.out.println("pos2:"+raf.getFilePointer());

        raf.close();

    }

    public static voidwrite()throws IOException{

        //rw：当这个文件不存在，会创建该文件。当文件已存在，不会创建。所以不会像输出流一样覆盖。

        RandomAccessFileraf = new RandomAccessFile("random.txt","rw");//rw读写模式

        //往文件中写入人的基本信息，姓名，年龄。

        raf.write("张三".getBytes());

        raf.writeInt(97);

        raf.close();

    }

}

------------------------------------------------------------------------------------------------

管道流：管道读取流和管道写入流可以像管道一样对接上，管道读取流就可以读取管道写入流写入的数据。

注意：需要加入多线程技术，因为单线程，先执行read，会发生死锁，因为read方法是阻塞式的，没有数据的read方法会让线程等待。

public static void main(String[] args) throws IOException{

    PipedInputStream pipin= new PipedInputStream();

    PipedOutputStreampipout = new PipedOutputStream();

    pipin.connect(pipout);

    new Thread(newInput(pipin)).start();

    new Thread(newOutput(pipout)).start();

}

------------------------------------------------------------------------------------------------

对象的序列化：目的：将一个具体的对象进行持久化，写入到硬盘上。

注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。

 

如何将非静态的数据不进行序列化？用transient 关键字修饰此变量即可。

 

Serializable：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。

 

import java.io.*;

class ObjectStreamDemo {

    public static voidmain(String[] args) throws Exception{

        writeObj();

        readObj();

    }

    public static voidreadObj()throws Exception{

        ObjectInputStream ois = newObjectInputStream(new FileInputStream("obj.txt"));

        Object obj =ois.readObject();//读取一个对象。

        System.out.println(obj.toString());

    }

    public static voidwriteObj()throws IOException{

        ObjectOutputStreamoos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

        oos.writeObject(newPerson("lisi",25)); //写入一个对象。

        oos.close();

    }

}

class Person implements Serializable{

    private static finallong serialVersionUID = 42L;

    private transient Stringname;//用transient修饰后name将不会进行序列化

    public int age;

    Person(String name,intage){

        this.name = name;

        this.age = age;

    }

    public StringtoString(){

        returnname+"::"+age;

    }

}

-----------------------------------------------------------------------------------------------

DataOutputStream、DataInputStream：专门用于操作基本数据类型数据的对象。

DataOutputStream dos =  new DataOutputStream(newFileOutputStream("data.txt"));

    dos.writeInt(256);

    dos.close();

 

    DataInputStream dis =new DataInputStream(new FileInputStream("data.txt"));

    int num = dis.readInt();

    System.out.println(num);

    dis.close();

-----------------------------------------------------------------------------------------------

ByteArrayInputStream：源：内存

ByteArrayOutputStream：目的：内存。

这两个流对象不涉及底层资源调用，操作的都是内存中数组，所以不需要关闭。

直接操作字节数组就可以了，为什么还要把数组封装到流对象中呢？因为数组本身没有方法，只有一个length属性。为了便于数组的操作，将数组进行封装，对外提供方法操作数组中的元素。

 

对于数组元素操作无非两种操作：设置（写）和获取（读），而这两操作正好对应流的读写操作。这两个对象就是使用了流的读写思想来操作数组。

//创建源：

    ByteArrayInputStreambis = new ByteArrayInputStream("abcdef".getBytes());

    //创建目的：

    ByteArrayOutputStreambos = new ByteArrayOutputStream();

    int ch = 0;

    while((ch=bis.read())!=-1){

        bos.write(ch);

    }

    System.out.println(bos.toString());