＜5＞第五期

七、AVA反射

1.-反射的基本概念

一般情况下，我们知道一个类，那可以通过这个类创建对象；

但是如果要求通过一个对象找到一个类，这时候反射就派上用场了。

java反射实现的核心就是Class类 java.lang包下的。

2.java反射-java Class基本使用

// 这里对象.getClass() 调用的是Object类的getClass()
//得到Class对象 然后再调用Class里的getName()方法，获取到完整包路径类；
public class Test01 {
public static void main(String[] args) {Student stu=new Student();System.out.println( stu.getClass().getName());
}
}
// 
public class Student {private String name;private Integer age;@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + "]";}public Student(String name, Integer age) {super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}	
}
//  
public class Test02 {public static void main(String[] args) {//通过完整包路径类型来实例化Class对象：try {//此时需要用到泛型  光标放到对应class位置上，就可以看到所需的泛型一般通用符  ？Class<?> c=Class.forName("com.java1234_7.Student");System.out.println(c.getName()); } catch (ClassNotFoundException e) {e.printStackTrace();}}}
//  
public class Test03 {public static void main(String[] args) {Class<?> c=null;try {//此时需要用到泛型  光标放到对应class位置上，就可以看到所需的泛型一般通用符  ？c=Class.forName("com.java1234_7.Student");System.out.println(c.getName()); 	} catch (ClassNotFoundException e) {e.printStackTrace();}// 因为返接收回的泛型，可以直接用Student/*** 此时访问的是Student的无参 */Student s=null;try {c.newInstance();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}s.setAge(23);s.setName("sss");System.out.println(s);}
}
//
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Test04 {public static void main(String[] args) {Class<?> c=null;try {c=Class.forName("com.java1234_7.Student");  System.out.println(c.getName());} catch (ClassNotFoundException e) {e.printStackTrace();}Student s=null;Constructor<?>[] cons=c.getConstructors();try {s=(Student) cons[0].newInstance("四史",68);} catch (Exception e) {e.printStackTrace();}System.out.println(s);}
}

3.通过反射获取类的基本结构

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;public class Test05 {public static void main(String[] args) {Class<?> c=null;try {c=Class.forName("com.java1234_7.Student");  System.out.println(c.getName());} catch (ClassNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("---------------------------------------------");//获取所有构造方法//1.通过getConstructors()方法Constructor<?>[] cons= c.getConstructors();//增强for循环for(Constructor<?> con :cons){System.out.println("构造方法："+con);}System.out.println("--------------------------------------------");//2，通过getMethods()方法获取所有方法Method[]  mts= c.getMethods();for(Method m:mts){System.out.println(m);}System.out.println("--------------------------------------------");// 3，通过getDeclaredFields()方法获取所有属性Field[] fd=c.getDeclaredFields();for(Field f:fd){System.out.println(f);}}
}

4.通过反射调用方法和操作属性

1，通过反射调用方法，主要通过invoke方法

package com.java1234_7;import java.lang.reflect.Method;public class Test06 {public static void main(String[] args) {Class<?> c=null;try {c=Class.forName("com.java1234_7.Student");  //反射获取类所实现的所有接口用到c=Class.forName("com.java1234_7.Student2");  System.out.println(c.getName());} catch (ClassNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("---------------------------------------------");try {// 获取单个方法实现调用  getClass（）.getMethod()Object obj=c.newInstance();Method m2=obj.getClass().getMethod("setName", String.class);m2.invoke(obj, "小锋");Method m=obj.getClass().getMethod("getName");String name=(String) m.invoke(obj);System.out.println("name="+name);} catch (Exception e) {e.printStackTrace();}}
}

2，通过反射操作属性，java里反射可以操作私有属性，只需要设置下


import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test07 {public static void main(String[] args) {Class<?> c=null;try {//反射获取类所实现的所有接口用到c=Class.forName("com.java1234_7.Student2");  System.out.println(c.getName());} catch (ClassNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("---------------------------------------------");try {Object obj=c.newInstance();Field f1= c.getDeclaredField("name");//反射提供的方法，可以去访问私有属性f1.setAccessible(true);f1.set(obj, "协商");System.out.println(f1.get(obj));} catch (Exception e) {e.printStackTrace();}}
}

八、JAVA集合

1.集合的引入

方法接口祖先级别：Collection

在对数据进行操作时候，数组也可以，但是存在一些问题，数组必须先定义好长度，也就是数组的长度是固定，不能根据我们的需求自动变长或者变短。

假如我们定义一个长度为3的数组，此时已经存储了3个，再想加一个时候就比较麻烦，用集合就可以解决好这个问题。

2.List集合

Collection接口是集合的老祖宗

List接口的主要实现类有ArrayList，和LinkedList。

上才艺：具体那个方法的使用用api工具查询

ArrayList

import java.util.ArrayList;
public class TestArrayList {public static void print(ArrayList<String> arraylist){System.out.println("当前输出的元素:");for(int i=0;i<arraylist.size();i++){System.out.print(arraylist.get(i)+" ");}System.out.println();}public static void main(String[] args) {ArrayList<String> arraylist=new ArrayList<String>();//对这个集合的增删改查//增arraylist.add("张1");arraylist.add("张2");arraylist.add("张3");arraylist.add("张4");arraylist.add("张5");print(arraylist);// 删除arraylist.remove(0);print(arraylist);//改arraylist.set(2, "测试");print(arraylist);//查System.out.println(arraylist.get(3));}
}

LinkedList：

import java.util.LinkedList;
public class TestLinkedList {public static void print(LinkedList<String> linkedlist){System.out.println("输出的集合是：");for(int i=0;i<linkedlist.size();i++){System.out.print(linkedlist.get(i)+" ");}System.out.println();}public static void main(String[] args) {LinkedList<String> linkedlist=new LinkedList<String>();linkedlist.add("张三");linkedlist.add("李四");linkedlist.add("王五");linkedlist.add("李四");linkedlist.add("赵六");print(linkedlist);System.out.println("-------------对数据进行操作---------------");// 返回集合的长度System.out.println(linkedlist.size());//向集合索引为2位置中插入一个值linkedlist.add(2, "测试");print(linkedlist);//从此列表中移除第一次出现的指定元素linkedlist.remove("李四");print(linkedlist);//indexOf 寻找位置System.out.println(linkedlist.indexOf("李四"));//peekFirst 获取第一个元素System.out.println(linkedlist.peekFirst());//peekFirst 获取最后的元素System.out.println(linkedlist.peekLast());}
}

3.集合的遍历

Iterator和foreach；

lterator:

// 先创一个Student类
package com.java1234_8;public class Student {private String name;private Integer age;public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + "]";}public Student(String name, Integer age) {super();this.name = name;this.age = age;}public Student() {super();}
}
// lterator 
import java.util.Iterator;
import java.util.LinkedList;
public class LteratorTest {public static void main(String[] args) {LinkedList<Student>  linkedlist=new LinkedList<Student>();linkedlist.add(new Student("张三",30));linkedlist.add(new Student("李四",20));linkedlist.add(new Student("王二",60));linkedlist.add(new Student("麻子",50));// 	System.out.println(linkedlist);/*** 用Iterator遍历集合*/Iterator<Student> it=linkedlist.iterator();  // 返回一个迭代器//has.Next判断有没有值while(it.hasNext()){// .next为取值Student s=it.next();   // 返回迭代的下一个元素。System.out.println("姓名："+s.getName()+"年龄："+s.getAge());}}
}
//

HashSet:

Set集合是Collection接口的子接口，没有对Collection接口进行扩展，里面不允许存在重复的内容；

import java.util.HashSet;
import java.util.Iterator;public class TestHashSet {public static void main(String[] args) {/*** 1，HashSet是无序* 2，不循序有重复的值*/HashSet<String> hs=new HashSet<String>();hs.add("21221");hs.add("112");hs.add("312");hs.add("421");hs.add("312");/*** 用Iterator遍历集合*/Iterator<String> it=hs.iterator();while(it.hasNext()){String s=it.next();System.out.println(s+" ");}}
}

HashMap集合：

是存放一对值的最大接口，即接口中的每一个元素都是一对，以key->value键值对的形式保存；

import java.util.HashMap;
import java.util.Iterator;public class TestHashMap {public static void main(String[] args) {HashMap<String,Student> hashMap=new HashMap<String,Student>();hashMap.put("1号", new Student("张三",10));hashMap.put("2号", new Student("李四",20));hashMap.put("3号", new Student("王五",30));// 通过key，获取valueStudent s=hashMap.get("1号");System.out.println(s.getName()+":"+s.getAge());Iterator<String> it=hashMap.keySet().iterator(); // 获取key的集合，再获取迭代器while(it.hasNext()){String key=it.next();  // 获取keyStudent student=hashMap.get(key);  // 通过key获取valueSystem.out.println("key="+key+" value=["+student.getName()+","+student.getAge()+"]");}}
}

九、Java多线程

1.Java多线程-多线程的引入

什么是多线程呢，我可以简单的理解成一边吃饭，一边听音乐这个是多线程；假如吃完饭再听音乐，或者先听音乐再吃饭，这个是单线程。

程序里同时执行多个任务并且加以控制这个是java多线程的含义。同时干多个事，能充分利用cpu 内存等硬件设备，提高程序运行效率。

public class Test01 {/*** 听音乐*/private static void music(){for(int i=0;i<100;i++){System.out.println("听音乐");}}/*** 吃饭*/private static void eat(){for(int i=0;i<100;i++){System.out.println("吃饭");}}public static void main(String[] args) {music();eat();}
}
//我们用上多线程，一般吃饭，一边听音乐， 
//Eat线程类：
public class Eat extends Thread{@Overridepublic void run() {for(int i=0;i<100;i++){try {Thread.sleep(100);System.out.println("吃饭");} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}//Music类：
public class Music extends Thread{@Overridepublic void run() {for(int i=0;i<100;i++){try {Thread.sleep(100);System.out.println("听音乐");} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}
//测试
public class Test02 {public static void main(String[] args) {Music musicThread=new Music();Eat eatThread=new Eat();musicThread.start();eatThread.start();}
}

2.Java多线程-Java多线程实现

1,继承Thread类

2,实现Runnable接口

3,多线程实现数据共享

// 1,继承Thread类
public class Thread1 extends Thread{private int baoZi=1;private String threadName;public Thread1(String threadName) {super();this.threadName = threadName;}@Overridepublic void run() {while(baoZi<=10){System.out.println(threadName+" 吃"+baoZi+"第个包子");baoZi++;}}public static void main(String[] args) {// 张三 李四一起吃包子 每人吃10个Thread1 t1=new Thread1("张三线程");Thread1 t2=new Thread1("李四线程");t1.start();t2.start();}  
}
//2,实现Runnable接口
public class Thread2 implements Runnable{private int baoZi=1;private String threadName;public Thread2(String threadName) {super();this.threadName = threadName;}@Overridepublic void run() {while(baoZi<=10){System.out.println(threadName+" 吃"+baoZi+"第个包子");baoZi++;}}public static void main(String[] args) {// 张三 李四一起吃包子 每人吃10个Thread2 t1=new Thread2("张三线程");Thread2 t2=new Thread2("李四线程");Thread t11=new Thread(t1);Thread t12=new Thread(t2);t11.start();t12.start();}}
//3,多线程实现数据共享
public class Thread3 implements Runnable{private int baoZi=1;private String threadName;public Thread3(String threadName) {super();this.threadName = threadName;}@Overridepublic synchronized void run() {while(baoZi<=10){System.out.println(threadName+" 吃"+baoZi+"第个包子");baoZi++;}}public static void main(String[] args) {Thread3 t1=new Thread3("超级张三线程");Thread t11=new Thread(t1);Thread t12=new Thread(t1);Thread t13=new Thread(t1);t11.start();t12.start();t13.start();}}

3.Java多线程-线程的状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gUQtXx9I-1657878648851)(D:\java1234\java1234笔记\java1234笔记截图\image-20220714212750489.png)]

1，创建状态

在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的

内存空间和其他资源，但还处于不可运行状态。新建一个线程对象可采用Thread 类的构造方法来实现，例

如，“Thread thread=new Thread();”。

2，就绪状态

新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，

线程将进入线程队列排队，等待CPU 服务，这表明它已经具备了运行条件。

3，运行状态

当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象

的run()方法。run()方法定义了该线程的操作和功能。

4，堵塞状态

一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作时，将让出

CPU 并暂时中止自己的执行，进入堵塞状态。堵塞时，线程不能进入排队队列，只有当引起堵塞的原因被

消除后，线程才可以转入就绪状态。

5，死亡状态

线程调用stop()方法时或run()方法执行结束后，即处于死亡状态。处于死亡状态的线程不具有继续运

行的能力。

4.Java多线程-线程常用方法

1，getName(); 返回该线程的名称。

2，currentThread()；返回对当前正在执行的线程对象的引用。

3，isAlive()；测试线程是否处于活动状态。

4，sleep()；线程休眠。

5，setPriority(int newPriority)；更改线程的优先级。

6，yield()；暂停当前正在执行的线程对象，并执行其他线程。

public class Demo1 implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubfor(int i=0;i<10;i++){// 获取当前线程Thread t=Thread.currentThread();System.out.println(t.getName()+":"+i); // 返回线程的名称}}public static void main(String[] args) {Demo1 demo1=new Demo1();new Thread(demo1).start();new Thread(demo1).start();new Thread(demo1,"线程3").start();}}
//
public class Demo2 implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubfor(int i=0;i<10;i++){// 获取当前线程Thread t=Thread.currentThread();System.out.println(t.getName()+":"+i); // 返回线程的名称}}public static void main(String[] args) {Demo2 demo2=new Demo2();Thread t1=new Thread(demo2);System.out.println("t1是否活动:"+t1.isAlive());t1.start();System.out.println("t1是否活动:"+t1.isAlive());}
}
//
public class Demo3 implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubfor(int i=0;i<10;i++){try {Thread.sleep(1000);// 获取当前线程Thread t=Thread.currentThread();System.out.println(t.getName()+":"+i); // 返回线程的名称} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {Demo3 demo1=new Demo3();new Thread(demo1).start();}}
//
public class Demo4 implements Runnable{@Overridepublic void run() {// TODO Auto-generated method stubfor(int i=0;i<10;i++){try {Thread.sleep(1000);// 获取当前线程Thread t=Thread.currentThread();System.out.println(t.getName()+":"+i); // 返回线程的名称} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {Demo4 demo4=new Demo4();Thread t1=new Thread(demo4,"线程A");Thread t2=new Thread(demo4,"线程B");Thread t3=new Thread(demo4,"线程C");t1.setPriority(Thread.MAX_PRIORITY);t2.setPriority(Thread.MIN_PRIORITY);t3.setPriority(Thread.NORM_PRIORITY);t3.start();t1.start();t2.start();}}
//
public class Demo5 implements Runnable{@SuppressWarnings("static-access")@Overridepublic void run() {// TODO Auto-generated method stubfor(int i=0;i<10;i++){try {Thread.sleep(100);// 获取当前线程Thread t=Thread.currentThread();System.out.println(t.getName()+":"+i); // 返回线程的名称if(i==5){System.out.println("线程礼让：");Thread.currentThread().yield();}} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {Demo5 demo1=new Demo5();new Thread(demo1,"线程A").start();new Thread(demo1,"线程B").start();}}

5.Java多线程-线程同步

public class Thread1 implements Runnable{private int baoZi=1;private String threadName;public Thread1(String threadName) {super();this.threadName = threadName;}@Overridepublic void run() {while(baoZi<=10){System.out.println(threadName+" 吃第"+baoZi+"个包子");baoZi++;}}public static void main(String[] args) {Thread1 t1=new Thread1("超级张三线程");Thread t11=new Thread(t1);Thread t12=new Thread(t1);Thread t13=new Thread(t1);t11.start();t12.start();t13.start();}}
// 我们发现 会有多个线程同时进入方法吃包子的情况发生，这时候，就引入了线程同步。可以给方法加同步，同一时刻，只允许一个线程进入方法；// 关键字 synchronized
public class Thread3 implements Runnable{private int baoZi=1;private String threadName;public Thread3(String threadName) {super();this.threadName = threadName;}@Overridepublic synchronized void run() {while(baoZi<=10){System.out.println(threadName+" 吃第"+baoZi+"个包子");baoZi++;}}public static void main(String[] args) {Thread3 t1=new Thread3("超级张三线程");Thread t11=new Thread(t1);Thread t12=new Thread(t1);Thread t13=new Thread(t1);t11.start();t12.start();t13.start();}}
//
public class Thread4 implements Runnable{private int baoZi=1;private String threadName;public Thread4(String threadName) {super();this.threadName = threadName;}@Overridepublic void run() {/*** 同步块*/synchronized (this) {while(baoZi<=10){System.out.println(threadName+" 吃第"+baoZi+"个包子");baoZi++;}}}public static void main(String[] args) {Thread4 t1=new Thread4("超级张三线程");Thread t11=new Thread(t1);Thread t12=new Thread(t1);Thread t13=new Thread(t1);t11.start();t12.start();t13.start();}}

十、JavaIO流

1.IO 流简介**

定义：流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QMB4F0mj-1657878648852)(D:\java1234\java1234笔记\java1234笔记截图\image-20220714221038141.png)]

IO 流的分类

根据处理数据类型的不同分为：字符流和字节流

根据数据流向不同分为：输入流和输出流

2.文件操作File 类

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

2，public boolean createNewFile() 创建一个文件

3，public boolean delete() 删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录

必须为空才能删除。

4，public boolean exists() 测试此抽象路径名表示的文件或目录是否存在。

5，public File[] listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文

件。

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

//创建文件目录和文件 
import java.io.File;
import java.io.IOException;public class Demo1 {public static void main(String[] args) throws IOException {File file=new File("c://java创建的目录");boolean b=file.mkdir();  // 创建虚拟目录if(b){System.out.println("目录创建成功！");file=new File("c://java创建的目录//java创建的文件.txt");boolean b2=file.createNewFile();  // 创建文件if(b2){System.out.println("文件创建成功！");}else{System.out.println("文件创建失败！");}}else{System.out.println("目录创建失败！");}}
}
// 删除文件和文件目录
import java.io.File;
import java.io.IOException;public class Demo2 {public static void main(String[] args) throws IOException {File file=new File("c://java创建的目录//java创建的文件.txt");if(file.exists()){  // 假如文件存在boolean b=file.delete();  // 删除文件if(b){System.out.println("删除文件成功！");}else{System.out.println("删除文件失败！");}}file=new File("c://java创建的目录");if(file.exists()){boolean b=file.delete();  // 删除目录if(b){System.out.println("删除目录成功！");}else{System.out.println("删除目录失败！");}}}
}
//遍历目录
import java.io.File;public class Demo3 {public static void main(String[] args) {File file=new File("C://apache-cxf-3.1.5");File files[]=file.listFiles();  // 遍历目录for(int i=0;i<files.length;i++){System.out.println(files[i]);}}
}
//递归遍历所有文件
import java.io.File;public class Demo4 {/*** 打印文件* @param file*/public static void listFile(File file){if(file!=null){if(file.isDirectory()){  // 是目录System.out.println(file);  // 打印下目录File f[]=file.listFiles();  // 遍历目录if(f!=null){for(int i=0;i<f.length;i++){listFile(f[i]);  // 递归调用}}}else{   // 是文件System.out.println(file);  // 是文件，直接打印文件的路径}}}public static void main(String[] args) {File file=new File("C://apache-tomcat-7.0.63");listFile(file);}
}

3.Java IO流-InputStream和OutputStream

InputStream是输入流 OutputStream是输出流；

InputStream输入流可以把文件从硬盘读取到内存；

OutputStream输出流可以把文件从内存写入到硬盘；

我们实际使用的都是InputStream和OutputStream的子类；

比如文件操作方面用的是FileInputStream和FileOutputStream；

准备工作，我们在C盘建一个txt文件测试文件.txt ，随便加点内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AsP8GYTY-1657878648853)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220714222708236.png)]

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;public class Demo1 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");InputStream inputStream=new FileInputStream(file);  // 实例化FileInputStreambyte b[]=new byte[1024];int len=inputStream.read(b);inputStream.close(); // 关闭输入流System.out.println("读取的内容是："+new String(b,0,len));}
}//上面那个是定义了固定字节数组 一批读取的，我们现在改进下，获取文件长度，然后定义指定字节数组的长度；
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;public class Demo2 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");InputStream inputStream=new FileInputStream(file);  // 实例化FileInputStreamint fileLength=(int)file.length();byte b[]=new byte[fileLength];inputStream.read(b);inputStream.close(); // 关闭输入流System.out.println("读取的内容是："+new String(b));}
}
//我们再来一种方式 一个字节一个字节读取；
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;public class Demo3 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");InputStream inputStream=new FileInputStream(file);  // 实例化FileInputStreamint fileLength=(int)file.length();byte b[]=new byte[fileLength];int temp=0;int len=0;while((temp=inputStream.read())!=-1){// 一个字节一个字节读取，放到b字节数组里b[len++]=(byte)temp;}inputStream.close(); // 关闭输入流System.out.println("读取的内容是："+new String(b));}
}//输出流；
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;public class Demo4 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");OutputStream out=new FileOutputStream(file);String str="你好，我好，大家好，Java好";byte b[]=str.getBytes();out.write(b); //  将b字节数组写入到输出流out.close();  // 关闭输出流}
}
//我们把指定文件写入到文件；
//上面那种是直接覆盖的，我们再来一个追加的；
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;public class Demo5 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");OutputStream out=new FileOutputStream(file,true);String str="你好，我好，大家好，Java好";byte b[]=str.getBytes();out.write(b); //  将b字节数组写入到输出流out.close();  // 关闭输出流}
}

4.Java IO流-BufferedInputStream和BufferedOutputStream

带缓冲的输入和输出流；

这里缓冲的概念，就是在A,B之间建立内存缓冲区，读取得快，就先放缓冲区，然后再从缓冲区写入指定目标，和没有缓冲比，效率快很多。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;public class Demo6 {/*** 缓冲* @throws Exception*/public static void bufferStream()throws Exception{// 定义了一个带缓冲的字节输入流BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream("C://《一头扎进J2SE》V2.0视频笔录2.doc"));// 定义了一个带缓冲的字节输出流BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("C://复制的《一头扎进J2SE》V2.0视频笔录2.doc"));int b=0;long startTime=System.currentTimeMillis(); // 开始时间while((b=bufferedInputStream.read())!=-1){bufferedOutputStream.write(b);}bufferedInputStream.close();bufferedOutputStream.close();long endTime=System.currentTimeMillis();  // 结束时间System.out.println("缓冲花费的时间是："+(endTime-startTime));}/*** 非缓冲* @throws Exception*/public static void stream() throws Exception{InputStream inputStream=new FileInputStream("C://《一头扎进J2SE》V2.0视频笔录.doc");  // 定义一个输入流OutputStream outputStream=new FileOutputStream("C://复制的《一头扎进J2SE》V2.0视频笔录.doc");int b=0;long startTime=System.currentTimeMillis(); // 开始时间while((b=inputStream.read())!=-1){outputStream.write(b);}inputStream.close();outputStream.close();long endTime=System.currentTimeMillis();  // 结束时间System.out.println("非缓冲花费的时间是："+(endTime-startTime));}public static void main(String[] args)throws Exception {stream();bufferStream();}
}
//把文件从A地址复制到B地址，运行输出：//非缓冲花费的时间是：2368   缓冲花费的时间是：31//我们明显发现 带缓冲的效率高；

5.Java IO流-Reader和Writer

主要用于文本的读取和写入，一般使用的实现类是FileReader和FileWriter；


import java.io.File;
import java.io.FileReader;
import java.io.Reader;public class Demo1 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");Reader reader=new FileReader(file);char c[]=new char[1024]; // 字符数组int len=reader.read(c);reader.close();  // 关闭输入流System.out.println("读取的内容是："+new String(c,0,len));}
}
// 直接读取；import java.io.File;
import java.io.FileReader;
import java.io.Reader;public class Demo2 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");Reader reader=new FileReader(file);char c[]=new char[1024]; // 字符数组int temp=0;int len=0;while((temp=reader.read())!=-1){c[len++]=(char)temp;}reader.close();  // 关闭输入流System.out.println("读取的内容是："+new String(c,0,len));}
}
// 一个一个字符读取；import java.io.File;
import java.io.FileWriter;
import java.io.Writer;public class Demo3 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");Writer out=new FileWriter(file);String str="我爱中华";out.write(str);  // 将字符串写入输出流out.close();  // 关闭输出流}
}
// 写入文件；import java.io.File;
import java.io.FileWriter;
import java.io.Writer;public class Demo4 {public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");Writer out=new FileWriter(file,true);String str="我爱中华2";out.write(str);  // 将字符串写入输出流out.close();  // 关闭输出流}
}
//追加写入；

解决eclipse控制台信息显示不全问题

eclipes控制台有默认的显示行数或者大小；

我们可以设置下，来增大显示行数；

菜单->windows->preferences

搜索console

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k0zFmrRG-1657878648859)(D:\java1234\java1234笔记\java1234笔记截图\image-20220714224611125.png)]

十一、java debug断点调试的重要性

java debug断点调试的重要性

以掌握好debug断点调试，我们无需搞输出语句直接打断点，程序执行到断点处停止，我们可以直接观察变量的值，以及表达式的值，我们甚至可以

动态修改变量的值来调试，非常方便，然后我们可以控制调试的执行，主要有F6 执行下一步，F8执行完成或者执行到下一个断点，F5进入方法内部；

1.eclipse debug使用基本操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BVVHhEBf-1657878648860)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220714225400501.png)]

2.eclipse debug常见调试 F6 单步 F8完成 F5进入方法

eclipse 里debug调试主要三个快捷方式

F6 单步执行执行到下一行代码

F8是执行完假如后面还有断点执行到下一个断点处

F5是进入方法里执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MPAGdief-1657878648861)(D:\java1234\java1234笔记\java1234笔记截图\image-20220714225516462.png)]

3.eclipse debug ctrl+shift+i查看表示式值

eclipse debug ctrl+shift+i查看表示式值

在eclipse里debug断点调试的时候，当我们需要查看某个表达式的时候，可以用ctrl+shift+i快捷方式；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nmdW5r4X-1657878648862)(D:\java1234\java1234笔记\java1234笔记截图\image-20220714225642044.png)]

4.eclipse debug 运行时动态修改变量值

这里讲一个高级点的debug功能，就是可以运行时候，动态修改变量的值。在企业级开发中，往往搞点测试数据麻烦，

所以直接debug的时候随便改数据，来进行各种测试，比较方便；

import java.io.File;
import java.io.FileWriter;
import java.io.Writer;

public class Demo4 {

public static void main(String[] args) throws Exception {File file=new File("C://测试文件.txt");Writer out=new FileWriter(file,true);String str="我爱中华2";out.write(str);  // 将字符串写入输出流out.close();  // 关闭输出流
}

}
//追加写入；


#### **解决eclipse控制台信息显示不全问题**解决eclipse控制台信息显示不全问题eclipes控制台有默认的显示行数或者大小；我们可以设置下，来增大显示行数；菜单->windows->preferences搜索console[外链图片转存中...(img-k0zFmrRG-1657878648859)]#### 十一、**java debug断点调试的重要性**java debug断点调试的重要性以掌握好debug断点调试，我们无需搞输出语句 直接打断点，程序执行到断点处停止，我们可以直接观察变量的值，以及表达式的值，我们甚至可以动态修改变量的值来调试，非常方便，然后我们可以控制调试的执行，主要有F6 执行下一步，F8执行完成或者执行到下一个断点，F5进入方法内部；##### 1.**eclipse debug使用基本操作**[外链图片转存中...(img-BVVHhEBf-1657878648860)]##### 2.**eclipse debug常见调试 F6 单步 F8完成 F5进入方法**eclipse 里debug调试主要三个快捷方式 F6 单步执行 执行到下一行代码F8是执行完 假如后面还有断点 执行到下一个断点处F5是进入方法里执行[外链图片转存中...(img-MPAGdief-1657878648861)]##### 3.**eclipse debug ctrl+shift+i查看表示式值**eclipse debug ctrl+shift+i查看表示式值在eclipse里debug断点调试的时候，当我们需要查看某个表达式的时候，可以用ctrl+shift+i快捷方式；[外链图片转存中...(img-nmdW5r4X-1657878648862)]##### 4.**eclipse debug 运行时动态修改变量值**这里讲一个高级点的debug功能，就是可以运行时候，动态修改变量的值。在企业级开发中，往往搞点测试数据麻烦，所以直接debug的时候随便改数据，来进行各种测试，比较方便；[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q30gmBb3-1657878648863)(D:\java1234\java1234笔记\java1234笔记截图\image-20220714225754486.png)]