java中for eatch循环_java笔记

第一天

1.helloworld 程序笔记

pubulic 1.修饰符：控制范围

class  2.关键字在：java中有特殊意义的单词

hello world

3.标识符：凡是在java中可以自己起名字的都是标识符；

注意：只能有字母大小写，数字_和$，其中数字不能开头

2.java 中对数字大小写敏感

一句话结束用；

System.out.print()不换行 输出

System.out.println();换行输出

字符串需要加引号，数字不需要；

3.从控制台输入信息

Scanner input new Scanner(System.in);

input.next();

4.变量

1)变量的声明：数据类型+变量名=初始值;

2)数据类型：

1.基本数据类型：byte short int long float double char boolean

2.引用数据类型：String Scanner

3)注意：1.byte与byte相加是Int

2.浮点型 默认是double类型声明float 时要加上F

5.运算符

1)算数运算符：+ - * %

2)赋值运算符：= += -=  (++a是先运算后赋值;

a++是先赋值后运算;

a+=3相当于a=a+3;)

3)比较运算符：> < >= <=  (==结果是布尔类型)

4)逻辑运算符：|| && | &  (||有一个true就是true;

&&有个false就是false;

||  && 是短路运算; | &

都得运算;)

5)位运算符：  (计算机二进制计算移位 2<<3的答案是16)

6)三元运算符(也叫三目运算符)：表达式？a:b  (a<3?8/4:8/2

如果a<3成立就执行第一个答案是2，如果a<3不成立执行第二个答案是4)

6.类型转换

1)自动类型转换：转换成最高位的数据类型

2)强制类型转换：int result=(int)23.45;

补充：产生一个随机数：Math.random()是个小数

7.if选择结构

1)if(){}

2)if(){}else

3)if(){}else if(){}else if(){}else{}

if嵌套使用

应用于多层判断

8.switch选择结构

1)switch

switch (表达式) {

case

常量 1:

语句;

break;

case

常量 2:

语句;

break;

…

default:

语句;

}

2)switch和if的区别

相同点：

都是用来处理多分支条件的结构

不同点：

switch选择结构

只能处理等值条件判断的情况，而且条件必须是整型变量或字符型变量

多重if选择结构

没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况

package java_02;

第二天

1.循环结构

1)while(){}

2)do{}while()

3)while和do while 的区别：一个是先判断后执行一个是先执行后判断

//叠代器

Iterator it=null;

while(it.hasNext()){

System.out.println(it.next());

}

4)for(int i=0;i<100;i++){}  双重for循环的使用************

5)break和continue的区别：

使用场合

break可用于switch结构和循环结构中

continue只能用于循环结构中

作用(循环结构中)

break语句终止某个循环，程序跳转到循环块外的下一条语句。

continue跳出本次循环，进入下一次循环

6)成员变量和局部变量的区别

第三天

1、数组的定义：多个相同数据类型的数据的组合

2、声明数组：

a)声明数组的三种方式：1、int[] as={1,2,3};2、int[]ss=new

int[3];3、int[]dd=new int[]{1,2,3};

1)声明数组类型

2)创建对象并划分内存空间

3、数组的赋值

1)声明数组的同时赋值

2)动态的赋值

4、访问一个数组

1)通过数组的下标去访问。数组的下标从0开始

数组异常：arrayIndexOutOfBoundsException 如果数组下标超过了个数抛出异常

2)数组的遍历  for循环打印出来

5、数组的复制

1)传统的for循环

for (int j=0 ; j

e[j]=ff[j]

}

System.out.println(ee[j]);

2)使用Arrays.copyOf(原数组名，新数组名的长度)

int[]gg=Arrays.copyOf(ff,5);

for(int k=0;k

System.out.println(gg[k]);

}

6、数组的排序

1)双重for循环

for(int j=0;j

for(int k=j;k

if

(ff[j]>ff[k]){

int a=f[k];

ff[k]=ff[j];//这个方法是选择排序，冒泡排序自己去看看

ff[j]=a;

}

}

}

2)Arrays.sort(数组名);

Arrays.sort(ff);

第四天

二维数组：

声明数组的三种方式：int[][]astwo=new

int[][]{(1,2,3),(3,4,5),(4,5,6)}

;int [][]astwo=new int[4][5];

int astwo={(1,2,3),(3,4,5),(4,5,6)};

练习：

int [][]a=new int[4][];

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

a[i]=new

int[2*i+1];

}

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

for(int j=0;j<2*i+1;j++){

a[i][j]=2*i*j;

System.out.print(a[i][j]+"\t");

}

System.out.println();

}

方法和类的设计

1、定义属性：声明一个变量

声明方法：

修饰符+返回值类型+方法名(参数){方法体}

使用new关键字来创建这个对象

创建对象的步骤：类名 对象名=new 类名()；

调用属性：对象名.属性

调用方法：对象名.方法名()

传参：方法传参在()定义参数 注意：有参数和无参数是两个方法

public void eat(String bone){

System.out.println("小狗爱吃"+bone);

}

String bone="肉";

dog.eat(bone);

有返回值的方法声明： public 返回值类型 方法名(){ return }用return关键字返回值

第五天：

引用类型如果我不重新创建对象，那这个对象就是原先的那个对象

public static void main(String[]args){

MathClass mc=new MathClass();

int x=5;

changeMath(mc);

System.out.println(mc.x);

}

public static void changeMath(MathClass mc){

mc.x=3;

}

//这个输出是3；

public static void main(String[]args){

MathClass mc=new MathClass();

int x=5;

changeMath(mc);

System.out.println(mc.x);

}

public static void changeMath(MathClass mc){

mc=new MathClass();

mc.x=3;

}

//这个输出是5

System.out.println(mc);

输出的是地址

字符串：

String s = "Hello World";

String s = new String();

String s = new String("Hello World");

1.String:类里面输出长度调用的是length方法，与数组 不同

，数组中输出长度调用的是length属性。

调用的时候点的时候没有括号的是属性，有括号的是方法

2.String是不可变的字符序列

String str=str1.replace('s','a');将S替换成A

System.out.println(str);输出的还是原数组

System.out.println(str1);除非给一个新的数组

3.缓冲池:定义字符串时，会在缓冲池里找有没有这个字符串，若有指向同一个地址

String str2="123";

String str3="123";

System.out.println(str2==str3);

输出的是true

String str4=new String("123");

String str5=new String("123");

System.out.println(str4==str5);

输出的是false

4.字符串的常用方法

1)equeals 比较字符串的值是否相等，==比较的是地址是否相等。

equalsIgnoreCase()方法 忽略大小写

toLowerCase()方法 全部转换成小写

toUpperCase( )方法 全部转换成大写

2)字符串的连接

A.concat(B)：B字符串将被连接到A字符串后面

或者用+

3)字符串的提取

public int indexOf(int ch) 搜索第一个出现的字符ch

public int indexOf(String value)(或字符串value)

public int lastIndexOf(int ch) 搜索最后一个出现的字符ch

public int lastIndexOf(String value)(或字符串value)

//输出的是字符串的位置，如果没有找到就返回-1

//返回出现第一个匹配的位置， 如果没有找到字符或字符串，则返回-1

4)字符串的截取substring()：[beginIndex,endIndex]包前不包后

public String substring(int index)提取从位置索引开始的字符串部分

public String substring(int beginindex, int

endindex)提取begingindex和endindex之间的字符串部分

public String trim()返回一个前后不含任何空格的调用字符串的副本

5)字符串的拆分split();

String str10="青-春-无-悔";

String[]str11=str10.split("-");

for(inti=0;i

System.out.println(str11[i]);

}

5.

String str="123456789";

//1.创建StringBuffer对象输入参数即可把String转成StringBuffer

StringBuffer sbf=new StringBuffer(str);

//2.StringBuffer和StringBuilder

1)共同点：都是可变的字符序列

2)区别：StringBuffer是线程安全，效率低。StringBuilder是线程不安全，效率高。

StringBuilder  sdf=new

StringBuilder(str);

sbf.replace(3,5,"dddd");把位置三到五的数换成dddd

System.out.println(sdf)

3.几个常用的方法：

1).append()拼接StringBuffer

2).toString()将StringBuffer转化为String

3).insert(int offer a, char c);在某个地方插入某个符号

4).reverse();倒序输出

5).delete(int begingIndex,int endIndex);

sbf.appand("abcd");//效果是字符串直接连载sbf后面

reverse()//反转

String str1=sbf.toString();//转换回String类型

for(int i=sbf.length-3;i<0;i=i-3){

sbf.insers(i，‘，');

insert的用法

String a="abcdefghijklmnopqrstuvwxyz";

Scanner input=new Scanner(System.in);

System.out.println("请输入用户名：");

String b=input.next();

StringBuffer stf=new StringBuffer(b);

for(int

i=b.length()-3;i>0;i=i-3){

stf.insert(i,

',');

System.out.println(stf);

第六天

System.out.println(new date().toLocaleString())

DateFormat df=new SimpleDateFormant("YYYY--MM--dd

hh:mm:ss")

javaoop

第一天

1.public 类名(){};

2.创建对象的时候就开始调用构造方法

//this关键字表示当前类的属性或方法

//注意：一个类中，如果没写构造方法，就默认了一个无参的构造方法，如果自己定义了一个构造方法无参的构造方法就没有了。

3.构造方法的的方法名必须跟类名一致

4.为了保护属性，使用private关键字  封装

//提供了一对public set get方法来实现对属性的赋值和访问

5.方法的重载

函数的重载就是同一个类中允许同时存在一个以上的同名函数，只要它们的参数个数或类型不同即可。

6.static

1)static可以用来修饰属性、方法和代码块

2)static修饰的属性和方法称为类属性(类变量)、类方法

3)不使用static修饰的属性和方法，属于单个对象，通常称为实例属性(变量属性)、实例方法

4)static修饰的变量和方法可以通过类名和对象名访问，而不用static修饰的变量和方法只能通过对象名访问

7.final

1)final可以用来修饰属性、方法和类

2)用final修饰的变量成为常量，其值固定不变

///Person.java

package oop;

public class Person {

//private封装

private int age;

String name;

int shengao;

//final关键字，其值固定不变

final int tizhong=50;

//static关键字

static String name1;

static int shengao1;

//创建对象构造方法

public Person(){}

public Person(String name){

//this关键字

this.name=name;

}

public Person(String name,int shengao){

this.name=name;

this.shengao=shengao;

}

//public set get方法来实现对属性的赋值和访问

public void setAge(int age){

if(age>0){

this.age=age;

}

}

public int getAge(){

return age;

}

public void lei(){

System.out.println("我是谁");

}

public void lei(String name){

System.out.println("我的名字是："+name);

}

public String TIZHON(){

return "我的体重是："+tizhong;

}

public String toString(){

return "我的名字是："+name+"\t"+"我的身高是："+shengao;

}

//static关键字

public static String tostring(){

return "我的名字是："+name1+"\t"+"我的身高是："+shengao1;

}

}

///Personceshi.java///

package oop;

public class Personceshi {

public static void main(String[]ags){

Person p=new Person();

p.setAge(20);

int age=p.getAge();

System.out.println(age);

p.lei();

p.lei("郑某某");

String h=p.toString();

System.out.println(h);

String w=p.TIZHON();

System.out.println(w+"*******");

Person g=new Person("zhu");

String i=g.toString();

System.out.println(i);

Person k=new Person("wang",80);

String m=k.toString();

System.out.println(m);

Person.name1="姗姗";

Person.shengao1=190;

System.out.println(Person.tostring());

}

}

//运行结果

我是谁

我的名字是：郑某某

我的名字是：null 我的身高是：0

我的体重是：50*******

我的名字是：zhu 我的身高是：0

我的名字是：wang 我的身高是：80

我的名字是：姗姗 我的身高是：190

//

第二天

1.使用extends关键字实现类与类之间的继承关系

注意：子类继承父类所有成员变量和成员方法，但不继承父类的构造方法 但可以调用

1)基本语法：

class Animal{

int age;

boolean sex;

public void eat(){

System.out.println("Animal eat");

}

public void sleep(){

System.out.println("sleep 8 hours");

}

}

class Dog extends Animal{

public void lookAfterHouse(){

System.out.println("look after house");

}

}

2)类继承语法规则：

修饰符 CLASS 子类名称

3)一个子类只能继承一个父类，一个父类可以多分支几个子类

4)

5)构造方法不能被继承

执行顺序：先执行父类的构造方法，再执行子类

重载(overloading)

2.方法的(重写、覆盖)

1)定义：在子类中根据需要对父类中继承来的方法惊醒改造-覆盖的方法(方法的重置、重写overiding)，在程序执行时，子类的方法将覆盖父类的方法。

2)语法：覆盖方法必须和被覆盖方法具有像同的方法名称、参数列表和返回值类型

3)注意：覆盖方法不能使用比被覆盖方法更严格的访问权限

//

package oop_02;

//1 . 使用extends 关键字实现类与类之间的继承关系

//2.  注意: 子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法

但可以调用父类的构造方法

public class Student extends Person {

String school;

//1. 定义:

在子类中可以根据需要对从父类中继承来的方法进行改造—覆盖方法(方法的重置、重写(overiding))，

//在程序执行时，子类的方法将覆盖父类的方法。

重载(overloading)

//2. 语法: 覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。

//3. 注意: 覆盖方法不能使用比被覆盖方法更严格的访问权限。

public void run(){

System.out.println("学生跑操");

}

public void study(){

System.out.println("学生学习");

}

public void print(){

System.out.println(super.sex);

}

public Student (){

super("Tom",19);

System.out.println("student 构造方法");

}

}

//

3.

1)声明一个Animal类

2)声明一个dog类来继承Animal

4. 多态：

1)语法： 父类名 对象名=new 子类名

2)特点：一个引用类型变量可能指向(引用)多种不同类型的对象

5.编译时多态  运行时多态

1)编译时多态只能调用父类中的属性和方法，调用子类中的属性和方法报错

//一个引用类型变量如果声明为父亲的类型，但实际引用的是子类对象，那么该变量就不能在访问子类中添加类型的属性和方法

2)运行时多态调用的是实际类型中的属性或方法

注意：方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

5.对象的类型转换

注意：从子类到父类的类型转换可以自动转换

从父类到子类的类型转换必须通过造型(强制类型转换)实现

无继承关系之间的引用类型间的转换是非法的

6.instanceof用于判断引用类型的实际类型是什么？

x instanceOf A 必须有继承关系

//

package oop_02;

public class TestDog {

public static void method(Animal animal){

}

public static void main(String[] args) {

Dog dog = new Dog();

//1. 语法  多态  : 父类名  对象名 = new 子类名()

//2. 特点: 一个引用类型变量可能指向(引用)多种不同类型的对象

Animal animal = new Dog();

method(animal);

animal.name = "蛇";

animal.run();

// 注意: 方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

Dog dog1 = new Dog();

method(dog1);

//

//3 . 编译时多态  运行时多态

//1. 编译时多态 只能调用父类中的属性和方法

,调用子类中的属性和方法报错

//

(一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法)

//2. 运行时多态 调用的是实际类型中的属性或方法

int a =(int)2.3;

//4. 对象的类型转换

// 注意: 从子类到父类的类型转换可以自动进行

// 从父类到子类的类型转换必须通过造型(强制类型转换)实现

// 无继承关系的引用类型间的转换是非法的

Animal animal2 = new Dog();

Dog dog2 = (Dog)animal2;

// Cat cat2 = (Cat)animal2;

//instanceof 用于判断 引用类型的实际类型是什么? A instanceof B 必须是继承关系

System.out.println(animal2 instanceof Dog);

System.out.println(animal2 instanceof Cat);

if(animal2 instanceof Dog){

Dog dog3 = (Dog)animal2;

System.out.println("转成狗");

}else if(animal2 instanceof Cat){

Cat cat3 = (Cat)animal2;

System.out.println("转成猫");

}

}

}

第三天

static

final

abstract

1、抽象方法  abstract关键字用来表示抽象

有抽象方法的类必须是抽象类

具体说明：用abstract修饰的类叫做抽象类，用abstract修饰的方法叫做抽象方法

2、//注意点：含有抽象方法的的类必须是抽象类

3、抽象类不能被实例化：不能被NEW

4、抽象类中可以有普通方法

5、抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体

6、不能用abstract修饰私有方法，构造方法，静态方法

interface

implements

接口：使用interface关键字，定义一个接口

接口是抽象方法和常量值的定义的集合

接口中所有方法默认public abstract

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现

接口的特点：

用interfaca来定义

接口中的所有成员变量都默认是由 public abstract final修饰的

接口中的所有方法都默认是有public abstract修饰的，接口没有构造方法

一个类可以实现多个无关接口

多个无关的类可以实现同一个接口

实现接口的类中必须提供接口中所有方法的具体实现

与继承关系类似，接口是实现类之间存在多态性

接口也可以继承另一个接口，使用extends关键字.

实现接口的类中必须提供接口中所有方法的具体实现内容

多个无关的类可以实现同一个接口

一个类可以实现多个无关的接口

与继承关系类似，接口与实现之间存在多态性

如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类

抽象和接口的区别

第一点． 接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。

第二点． 接口可以多继承，抽象类不行

第三点． 接口定义方法，不能实现，而抽象类可以实现部分方法。

第四点． 接口中基本数据类型为static 而抽类象不是的。

理解内容:

1. 当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。

2. 抽象类的功能要远超过接口，但是，定义抽象类的代价高。

因为高级语言来说(从实际设计上来说也是)每个类只能继承一个类。

在这个类中，你必须继承或编写出其所有子类的所有共性。

虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。

而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

第四天

一、常见异常

1、java.lang.ArithmeticException算术异常

2、java.lang.NullPointerExcepetion:空指针异常

3、java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常

4、java.lang.NumberFormatException:数字格式化异常

二、异常处理

1、抓取异常 try{

int i=10/0;

//下面的括号里面还可以写  ArithmeticException

}catch(Exception e){

e.printStackTrace();

}finally{

//无论是否有异常finally中的代码都会被执行

System.out.println("ccccc");

}

2、声明异常 通过throws关键字

注意：如果这个方法被调用，调用的方法也要有异常处理

3、手动抛出异常

public void test1(){

if (i!=0){

int j=10/i;

}else {

throws new Exception("除数不为零")

}

}

Exception异常层次结构的根类

ArithmeticException算术错误情形，如以下零作除数

ArraylndexOutOfBoundsException数组下标越界

NullPointerException尝试访问null对象成员

ClassNotFoundException不能加载所需的类

InputMismatchException欲得到数据类型与实际输入类型不匹配

IIIegalArgumentException方法接受到非法参数

ClassCastException对象强制类型转换出错

NumberFormatException数字格式转换异常，如果把“abc”转换成数字

package oop_04;

public class TestException {

public static void main(String[] args) throws Exception

{

//一. 抓取异常

//1. java.lang.ArithmeticException: 算术异常

//int i = 10/0;

System.out.println("ddd");

//2. java.lang.NullPointerException : 空指针异常

String name = null;

//System.out.println(name.equals("张三"));

//3. java.lang.ArrayIndexOutOfBoundsException: 数组下标越界异常

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

//System.out.println(as[3]);

//4> java.lang.NumberFormatException:数字的格式化异常

String age="abc";

//int age1 = Integer.parseInt(age);

test1(1);

}

//二. 声明异常 通过throws关键字

// 注意:　如果这个方法被调用,调用的方法也要有异常处理

public void test() throws ClassNotFoundException{

Class.forName("ddd");

}

//三. 手动抛异常

public static void test1(int i) throws Exception{

if(i != 0){

int j = 10/i;

}else{

throw new Exception("除数不为零");

}

}

}

/

Collection接口存储一组不唯一，无序的对象

List接口存储一组不唯一，有序(插入顺序)的对象

Set接口存储一组唯一，无序的对象

boolean add(Object o)在列表的末尾顺序添加元素，其实索引位置从0开始

void add(intindex,Object

o)在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间

int size()返回列表中的元素个数

Object get(int

index)返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换

boolean contains(Object o)判断列表中是否存在指定元素

boolean remove(Object o)从列表中删除元素

Object remove(int index)从列表中删除指定位置元素，起索引位置从0开始

/

package oop_04;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.junit.Test;

public class testConnection {

Dog dog1 = new Dog("欧欧",3);

Dog dog2 = new Dog("亚亚",4);

Dog dog3 = new Dog("菲菲",2);

Dog dog4 = new Dog("美美",1);

//创建集合

List dogs = new ArrayList();

//List

@Test

public void test(){

//添加信息  add()

dogs.add(dog1);

dogs.add(dog2);

dogs.add(dog3);

dogs.add(dog4);

System.out.println("共有:"+dogs.size()+"条狗");

//通过下标删除对象

dogs.remove(0);

System.out.println("共有:"+dogs.size()+"条狗");

//contains()判断是否包含特定对象

if(dogs.contains(dog1)){

System.out.println("有欧欧这条狗!");

}else{

System.out.println("没有欧欧这条狗!");

}

//使用for循环遍历打印

//iterator迭代器遍历集合

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

Iterator it = dogs.iterator();

while(it.hasNext()){

Dog dog = it.next();

System.out.println(dog.name+"\t"+dog.age);

}

}

//Map

@Test

public void testMap(){

//创建Map集合

Map Cat = new HashMap();

//添加信息(通过key  value)

Cat.put("cat1", "1号猫");

Cat.put("cat2", "2号猫");

Cat.put("cat3", "3号猫");

Cat.put("cat4", "4号猫");

Cat.put("cat5", "5号猫");

System.out.println("共有: "+Cat.size()+"条猫!");

//通过key取出value值

String catName = (String) Cat.get("cat2");

System.out.println(catName);

//通过键值删除

Cat.remove("cat2");

System.out.println("共有: "+Cat.size()+"条猫");

//可以通过键或值 判断是否包含特定对象

if(Cat.containsValue("2号猫")){

System.out.println("包含CAT2");

}else{

System.out.println("不包含CAT2");

}

//获取键集  值集  键值集

System.out.println(Cat.keySet());

System.out.println(Cat.values());

System.out.println(Cat);

}

}

//

package oop_05;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.Reader;

import java.io.Writer;

import org.junit.Test;

public class File {

//缓冲流字节输入输出流

@Test

public void testBufferInputStream() throws IOException{

//创建缓冲的字节输入流

InputStream inputStream = new

FileInputStream("file.txt");

BufferedInputStream bufferedInputStream = new

BufferedInputStream(inputStream);

//创建缓冲的字节输出流

OutputStream outputStream = new

FileOutputStream("d:\\file1.txt");

BufferedOutputStream bufferedOutputStream = new

BufferedOutputStream(outputStream);

byte[] buffer = new byte[1024*10];

int len = 0 ;

while((len = bufferedInputStream.read(buffer))!= -1){

for (int j = 0; j < buffer.length; j++) {

bufferedOutputStream.write(buffer[j]);

}

}

//关闭流资源

bufferedInputStream.close();

bufferedOutputStream.close();

}

//缓冲的字符输入输出流

@Test

public void testBufferReader() throws IOException{

//创建缓冲的字符输入流

Reader reader = new FileReader("file.txt");

BufferedReader bufferedReader = new

BufferedReader(reader);

//创建缓冲的字符输出流

Writer writer = new FileWriter("e:\\file1.txt");

BufferedWriter bufferedWriter = new

BufferedWriter(writer);

String str = null;

while((str = bufferedReader.readLine()) != null){

bufferedWriter.write(str);

bufferedWriter.write("\n");

}

bufferedReader.close();

bufferedWriter.close();

}

//转换流

@Test

public void testInputStreamReader() throws IOException{

InputStream inputStream = new

FileInputStream("file.txt");

//使用InputStreamReader()把字节流转成字符流

Reader reader = new InputStreamReader(inputStream);

//转成缓冲的字符输入流

BufferedReader bufferedReader = new

BufferedReader(reader);

char[] buffer = new char[1024*10];

int len=0;

while((len = bufferedReader.read(buffer)) != -1){

for(int i=0 ; i

System.out.print(buffer[i]);

}

}

//关闭流资源

bufferedReader.close();

}

//对象流(输出)

@Test

public void testObject() throws IOException{

//输出的位置

OutputStream out = new

FileOutputStream("e:\\Person.txt");

//创建对象输出流

ObjectOutputStream objectOutputStream = new

ObjectOutputStream(out);

//创建要输出的对象

Person person = new Person("李四",18);

//输出对象

objectOutputStream.writeObject(person);

objectOutputStream.close();

}

//对象流(输入)

@Test

public void testObject1() throws

Exception{

InputStream in = new FileInputStream("e:\\Person.txt");

ObjectInputStream objectInputStream = new

ObjectInputStream(in);

Object object = objectInputStream.readObject();

System.out.println(object);

objectInputStream.close();

}

}

-------------------------------moxie.java-----------------------------------

package javaIO;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import org.junit.Test;

public class moxie {

@Test

public void testFile(){

File file=new File("file.txt");

System.out.println(file.getName());

file.renameTo(new

File("e:\\file.txt"));//将file文件另存为到e盘

System.out.println(file.getAbsolutePath());

System.out.println(file.getPath());

boolean y=file.exists();

System.out.println(y);

}

@Test

public void testOutputStream() throws Exception{

OutputStream outputStream=new

FileOutputStream("file3.txt");

String context="fagfasgageqkgewngkewngqlmglka";

byte[]buffer=context.getBytes();

outputStream.write(buffer);

outputStream.close();

}

@Test

public void testInputStream() throws Exception{

InputStream inputstream=new

FileInputStream("file3.txt");

String context="222222";

byte[]buffer=new byte[1024*10];

int len=0;

while((len=inputstream.read(buffer))!=-1){

for(int i=0;i

System.out.println((char)buffer[i]);

}

}

}

}

---------------------------javaIO.java-----------------------------------------------

package javaIO;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.Reader;

import java.io.Writer;

import org.junit.Test;

public class javaIO {

@Test

public void testFile(){

File file=new File("file.txt");

System.out.println(file.getName());

file.renameTo(new File("d:\\file.txt"));

System.out.println(file.getAbsolutePath());

System.out.println(file.getPath());

boolean b=file.exists();

System.out.println(b);

}

@Test

public void testInputStream() throws IOException{

InputStream inputStream=new FileInputStream("file.txt");

byte[]buffer=new byte[1024*10];

int len=0;

while((len=inputStream.read(buffer))!=-1){

for(int i=0;i

System.out.println((char)buffer[i]);

}

}

inputStream.close();

}

@Test

public void testReader() throws IOException{

Reader reader=new FileReader("file.txt");

char[] buffer=new char[1024*10];

int len=0;

while((len=reader.read(buffer))!=-1){

for(int i=0;i

System.out.print(buffer[i]);

}

}

reader.close();

}

@Test

public void testOutputStream() throws IOException{

OutputStream outputStream=new

FileOutputStream("file1.txt");

String

context="html-javaoop-javascript-sql-sqlserver-oracle-mysql-jdbc-jsp";

byte[]buffer=context.getBytes();

outputStream.write(buffer);

outputStream.close();

}

@Test

public void testWriter() throws IOException{

Writer writer=new FileWriter("abcd.txt");

String

context="html-javaoop-javascript-sql-sqlserver-oracle-mysql-jdbc-jsp";

char[]buffer=context.toCharArray();

writer.write(buffer);

writer.close();

}

@Test

public void testCopy() throws IOException{

Reader reader = new FileReader("file.txt");

Writer writer = new FileWriter("file2.txt");

char[] buffer = new char[1024*10];

int len=0;

while((len = reader.read(buffer)) != -1){

for (int j = 0; j < len; j++) {

writer.write(buffer[j]);

}

}

reader.close();

writer.close();

}

}