一、使用I/O操作文件

1、java的流
流：是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道。
2、流分为输入流和输出流；这些输入/输出流类的对象称为对象流；
输入流：数据输入到内存——>关联的是源数据——>读取文件
输出流：内存中输出———>关联目标数据——->写入文件
image.png

3、创建目录与文件删除等方法

  1. public static void main(String[] args) {
  2.         Lianxi lx=new Lianxi();
  4.         lx.creatFile( "1.txt","D:/newFile");
  5.         lx.write("1.txt", "D:/newFile", "abcdefg");
  6.         lx.getSize("1.txt", "D:/newFile");
  7.         lx.read("1.txt", "D:/newFile");
  8.         lx.delete("3.txt", "D:/file2");
  9.         lx.deletePath("D:/file3");
  11.     }
  12.     //删除目录
  13.     private void deletePath(String path){
  14.         File file=new File(path);
  15.         if(file.exists()){
  16.             file.delete();
  17.         }
  18.     }
  20.     //删除文件
  21.     private void delete(String fileName,String path){
  22.         File file=new File(path+"/"+fileName);
  23.         if(file.exists()){
  24.             file.delete();
  25.         }
  26.     }
  28.     //读取字节
  29.     private void read(String fileName,String path){
  30.         FileInputStream fos=null;
  31.         try {
  32.             fos=new FileInputStream(path+"/"+fileName);
  33.             System.out.println("可读取的字节数是："+fos.available()+"个");
  34.             int a;
  35.             while((a=fos.read())!=-1){
  36.                 System.out.println((char)a);
  37.             }
  38.         } catch (FileNotFoundException e) {
  40.             e.printStackTrace();
  41.         } catch (IOException e) {
  43.             e.printStackTrace();
  44.         }finally{
  45.             if(fos!=null){
  46.                 try {
  47.                     fos.close();
  48.                 } catch (IOException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.         }
  53.     }
  54.     //获取修改时间
  55.     private void getDate(String fileName,String path){
  56.         File file=new File(path+"/"+fileName);
  57.         long l=file.lastModified();
  58.         Date date=new Date();
  59.         date.setTime(l);
  60.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  61.         System.out.println(sdf.format(date));
  62.     }
  63.     //获取文件大小
  64.     private void getSize(String fileName,String path){
  65.         File file=new File(path+"/"+fileName);
  66.         System.out.println("文件大小："+file.length());
  67.     }
  68.     //写入文件
  69.     private void write(String fileName,String path,String word){
  70.         FileOutputStream fos=null;
  71.         try {
  72.             fos=new FileOutputStream(path+"/"+fileName);
  73.             fos.write(word.getBytes(), 0, word.length());
  74.         } catch (FileNotFoundException e) {
  76.             e.printStackTrace();
  77.         } catch (IOException e) {
  79.             e.printStackTrace();
  80.         }finally{
  81.             if(fos!=null){
  82.                 try {
  83.                     fos.close();
  84.                 } catch (IOException e) {
  85.                     e.printStackTrace();
  86.                 }
  87.             }
  88.         }
  90.     }
  91.     //获得路径
  92.     private void getPath(String fileName,String path){
  93.         File filePath=new File(path+"/"+fileName);
  94.         System.out.println("相对"+filePath.getPath());
  95.         System.out.println("绝对"+filePath.getAbsolutePath());
  96.     }
  97.     //创建文件夹和文件
  98.     private void creatFile(String fileName,String path){
  99.         File filePath=new File(path);
  100.         if(!filePath.isDirectory()){
  101.             if(!filePath.exists()){
  102.                 //创建一个
  103.                 filePath.mkdirs();
  104.             }
  105.         }
  106.         File file=new File(path+"/"+fileName);
  107.         if(!file.exists()){
  108.             try {
  109.                 file.createNewFile();
  110.             } catch (IOException e) {
  111.                 e.printStackTrace();
  112.             }
  113.         }
  114.     }

二、字节流主方法读写文件

  1. /*
  2.      * 读取文件
  3.      */
  4.     public static void main(String[] args) {
  5.         FileInputStream fis=null;
  6.         //输入流读取文件
  7.         try {
  8.              fis=new FileInputStream("D:/file2/1.txt");
  9.              System.out.println("可读取的字节数："+fis.available());
  10.              //循环读取文件内容
  11.              int data;//data=-1,读取完成
  12.              while((data=fis.read())!=-1){
  13.                  System.out.println((char)data);
  14.              }
  15.         } catch (FileNotFoundException e) {    
  16.             e.printStackTrace();
  17.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }finally{
  20.             //关闭流
  21.             if(fis!=null){
  22.                 try {
  23.                     fis.close();
  24.                 } catch (IOException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.             }
  28.         }
  30.     }

5、主方法写入文件

  1. /*
  2.      * 写入文件
  3.      */
  4.     public static void main(String[] args) {
  5.         FileOutputStream fos=null;
  7.         try {
  8.             //true 表示追加内容，不写true就是直接覆盖
  10.          fos=new FileOutputStream("D:/file2/1.txt",true);
  11.             String s="def";
  12.             fos.write(s.getBytes(),0,s.length());
  13.         } catch (FileNotFoundException e) {
  14.             e.printStackTrace();
  15.         } catch (IOException e) {
  16.             e.printStackTrace();
  17.         }finally{
  18.             if(fos!=null){
  19.                 try {
  20.                     fos.close();
  21.                 } catch (IOException e) {
  22.                     e.printStackTrace();
  23.                 }
  24.             }
  25.         }
  27.     }

5、file2/1.txt复制到file2/3.txt

将某文件的内容复制到新开辟的文件夹的文件内

  1. public static void main(String[] args) {
  2.         FileInputStream fis=null;
  3.         FileOutputStream fos=null;
  4.         try {
  5.              fis=new FileInputStream("D:/file2/1.txt");
  6.              fos=new FileOutputStream("D:/file2/3.txt");    
  7.              //循环读取文件内容
  8.              int data;//data=-1,读取完成
  9.              while((data=fis.read())!=-1){
  11.              fos.write(data);
  12.              }
  13.         } catch (FileNotFoundException e) {    
  14.             e.printStackTrace();
  15.         } catch (IOException e) {
  16.             e.printStackTrace();
  17.         }finally{
  19.             if(fos!=null){
  20.                 try {
  21.                     fos.close();
  22.                 } catch (IOException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.             }
  26.             //关闭流
  27.             if(fis!=null){
  28.                 try {
  29.                     fis.close();
  30.                 } catch (IOException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.             }
  34.         }
  37.     }

三、字符流读写文件

QQ图片20210317150558.png
1、读文件

  1. public static void main(String[] args) {
  2.         FileInputStream fis=null;
  3.         InputStreamReader isr=null;
  4.         BufferedReader br=null;//自带缓冲区去读文件
  5.         try {
  6.             fis=new FileInputStream("D:/file/a.txt");
  7.              isr=new InputStreamReader(fis);//如果出乱码，在fis后面，“utf-8”或者“GBK”
  8.              br=new BufferedReader(isr);
  9.              //读取文件中一行数据
  10.              String s=br.readLine();
  11.              while(s!=null){
  12.                  System.out.println(s);
  13.                  s=br.readLine();
  14.              }
  15.              System.out.println("读取完毕");
  16.         } catch (FileNotFoundException e) {
  17.             e.printStackTrace();
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }finally{
  21.             try{
  22.                 if(br!=null){
  23.                     br.close();
  24.                 }
  25.                 if(isr!=null){
  26.                     isr.close();
  27.                 }
  28.                 if(fis!=null){
  29.                     fis.close();
  30.                 }
  32.             }catch(IOException e){
  33.                 e.printStackTrace();
  34.             }
  35.         }
  37.     }

2、写文件

  1. public static void main(String[] args) {
  2.         FileOutputStream fos=null;
  3.         OutputStreamWriter osw=null;
  4.         BufferedWriter bw=null;
  7.         try {
  8.             fos=new FileOutputStream("D:/file/b.txt");
  9.             osw=new OutputStreamWriter(fos);
  10.             bw=new BufferedWriter(osw);
  11.             bw.write("3.15");
  12.             bw.newLine();//另起一行换行在写
  13.             bw.write("名表维修-消磁天价收费");
  14.             bw.newLine();
  15.             bw.write("智联招聘企业账号可以随意下载");
  16.             //刷新缓冲区
  17.             bw.flush();
  18.             System.out.println("写入完成");
  19.         } catch (FileNotFoundException e) {
  20.             e.printStackTrace();
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         }finally{
  24.             try{
  25.                 if(bw!=null){
  26.                     bw.close();
  27.                 }
  28.                 if(osw!=null){
  29.                     osw.close();
  30.                 }
  31.                 if(fos!=null){
  32.                     fos.close();
  33.                 }
  34.             }catch(IOException e){
  35.                 e.printStackTrace();
  36.             }
  37.         }
  40.     }

1、复制文件的几种方法

  1. public static void main(String[] args) {
  2.         CopyFile cf=new CopyFile();
  3. //        String sourceFile="D:/file/b.txt";
  4. //        String targetFile="D:/file/6.txt";
  5.         String sourceFile="D:/myDoc/1.png";
  6.         String targetFile="D:/file/1-copy.png";
  7.         cf.copy6(sourceFile, targetFile);
  10.     }
  11.     //复制图片--->二进制流
  12.     private void copy6(String sourceFile,String targetFile){
  13.         FileInputStream fis=null;
  14.         DataInputStream dis=null;//二进制流
  16.         FileOutputStream fos=null;
  17.         DataOutputStream dos=null;
  18.         try {
  19.             //输入流读文件
  20.             fis=new FileInputStream(sourceFile);
  21.             dis=new DataInputStream(fis);
  22.             fos=new FileOutputStream(targetFile);
  23.             dos=new DataOutputStream(fos);
  24.             int data;
  25.             //读
  26.             while((data=dis.read())!=-1){
  27.                 //写
  28.                 dos.write(data);
  29.             }
  30.             System.out.println("图片复制成功");
  31.         } catch (FileNotFoundException e) {
  32.             e.printStackTrace();
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }finally{
  36.             try{
  37.                 if(dos!=null){
  38.                     dos.close();
  39.                 }
  40.                 if(fos!=null){
  41.                     fos.close();
  42.                 }
  43.                 if(dis!=null){
  44.                     dis.close();
  45.                 }
  46.                 if(fis!=null){
  47.                     fis.close();
  48.                 }
  49.             }catch(IOException e){
  50.                 e.printStackTrace();
  51.             }
  52.         }
  53.     }
  55.     //含有中文的复制
  56.     private void copy5(String sourceFile,String targetFile){
  57.         FileInputStream fis=null;
  58.         InputStreamReader isr=null;
  59.         BufferedReader br=null;//自带缓冲区去读文件
  60.         //
  61.         FileOutputStream fos=null;
  62.         OutputStreamWriter osw=null;
  63.         BufferedWriter bw=null;
  64.         try {
  65.              fis=new FileInputStream(sourceFile);
  66.              isr=new InputStreamReader(fis);//如果出乱码，在fis后面，“utf-8”或者“GBK”
  67.              br=new BufferedReader(isr);
  68.              //
  69.                 fos=new FileOutputStream(targetFile);
  70.                 osw=new OutputStreamWriter(fos);
  71.                 bw=new BufferedWriter(osw);
  72.              //读取文件中一行数据
  73.              String s=br.readLine();
  74.              while(s!=null){
  75.                  //写入
  76.                  bw.write(s);
  77.                  bw.newLine();
  78.                  s=br.readLine();     
  79.              }
  81.              bw.flush();
  82.              System.out.println("复制成功");
  83.         } catch (FileNotFoundException e) {
  84.             e.printStackTrace();
  85.         } catch (IOException e) {
  86.             e.printStackTrace();
  87.         }finally{
  88.             try{
  89.                 if(bw!=null){
  90.                     bw.close();
  91.                 }
  92.                 if(osw!=null){
  93.                     osw.close();
  94.                 }
  95.                 if(fos!=null){
  96.                     fos.close();
  97.                 }
  98.                 if(br!=null){
  99.                     br.close();
  100.                 }
  101.                 if(isr!=null){
  102.                     isr.close();
  103.                 }
  104.                 if(fis!=null){
  105.                     fis.close();
  106.                 }
  108.             }catch(IOException e){
  109.                 e.printStackTrace();
  110.             }
  111.         }
  112.     }
  113.     //文件大适合
  114.     private void copy4(String sourceFile,String targetFile){
  115.         FileInputStream fis=null;
  116.         FileOutputStream fos=null;
  117.         try {
  118.             fis=new FileInputStream(sourceFile);
  119.             fos=new FileOutputStream(targetFile);
  120.             byte[] b=new byte[1024];
  121.             int n=0;//去除占用空间
  122.             while((n=fis.read(b,0,b.length))!=-1){
  123.                 fos.write(b,0,n);
  125.             }
  126.             System.out.println("操作成功");
  127.         } catch (FileNotFoundException e) {
  128.             e.printStackTrace();
  129.         } catch (IOException e) {
  130.             e.printStackTrace();
  131.         }finally{
  132.             try{
  133.                 if(fos!=null){
  134.                     fos.close();
  135.                 }
  136.                 if(fis!=null){
  137.                     fis.close();
  138.                 }
  139.             }catch(IOException e){
  140.                 e.printStackTrace();
  141.             }
  142.         }
  146.     }
  147.     //文件居中适合
  148.     private void copy3(String sourceFile,String targetFile){
  149.         FileInputStream fis=null;
  150.         FileOutputStream fos=null;
  151.         StringBuffer s=new StringBuffer();
  152.         //读文件，读取到String
  153.         try {
  154.             fis=new FileInputStream(sourceFile);
  155.             int data;
  156.             //fis.read()读文件
  157.             while((data=fis.read())!=-1){
  158.                 s.append((char)data);
  159.             }
  160.         } catch (FileNotFoundException e) {
  162.             e.printStackTrace();
  163.         } catch (IOException e) {
  165.             e.printStackTrace();
  166.         }finally{
  167.             if(fis!=null){
  168.                 try {
  169.                     fis.close();
  170.                 } catch (IOException e) {
  171.                     e.printStackTrace();
  172.                 }
  173.             }
  174.         }
  175.         //写文件
  176.         try {
  177.             fos=new FileOutputStream(targetFile);
  178.             fos.write(s.toString().getBytes());
  179.         } catch (Exception e) {
  181.             e.printStackTrace();
  182.         }finally{
  183.             if(fos!=null){
  184.                 try {
  185.                     fos.close();
  186.                 } catch (IOException e) {
  187.                     e.printStackTrace();
  188.                 }
  189.             }
  190.         }
  191.     }
  193.     private void copy2(String sourceFile,String targetFile){
  194.         FileInputStream fis=null;
  195.         FileOutputStream fos=null;
  196.         String s="";
  197.         //读文件，读取到String
  198.         try {
  199.             fis=new FileInputStream(sourceFile);
  200.             int data;
  201.             //fis.read()读文件
  202.             while((data=fis.read())!=-1){
  203.                 s+=(char)data;
  204.             }
  205.         } catch (FileNotFoundException e) {
  207.             e.printStackTrace();
  208.         } catch (IOException e) {
  210.             e.printStackTrace();
  211.         }finally{
  212.             if(fis!=null){
  213.                 try {
  214.                     fis.close();
  215.                 } catch (IOException e) {
  216.                     e.printStackTrace();
  217.                 }
  218.             }
  219.         }
  220.         //写文件
  221.         try {
  222.             fos=new FileOutputStream(targetFile);
  223.             fos.write(s.getBytes());
  224.         } catch (Exception e) {
  226.             e.printStackTrace();
  227.         }finally{
  228.             if(fos!=null){
  229.                 try {
  230.                     fos.close();
  231.                 } catch (IOException e) {
  232.                     e.printStackTrace();
  233.                 }
  234.             }
  235.         }
  236.     }
  237.     //文件小适用
  238.     private void copy1(String sourceFile,String targetFile){
  239.         //读取文件
  240.         FileInputStream fis=null;
  241.         FileOutputStream fos=null;
  242.         try {
  243.             fis=new FileInputStream(sourceFile);
  244.             fos=new FileOutputStream(targetFile);
  245.             int data;
  246.             //fis.read()读文件
  247.             while((data=fis.read())!=-1){
  248.                 //fos.write(data)写入文件
  249.                 fos.write(data);
  250.             }
  251.             System.out.println("文件复制成功");
  252.         } catch (FileNotFoundException e) {
  254.             e.printStackTrace();
  255.         } catch (IOException e) {
  257.             e.printStackTrace();
  258.         }finally{
  259.             if(fos!=null){
  260.                 try {
  261.                     fos.close();
  262.                 } catch (IOException e) {
  263.                     e.printStackTrace();
  264.                 }
  265.             }
  266.             if(fis!=null){
  267.                 try {
  268.                     fis.close();
  269.                 } catch (IOException e) {
  270.                     e.printStackTrace();
  271.                 }
  272.             }
  273.         }
  275.     }

四、利用二进制字符流复制图片

  1. //复制图片--->二进制流
  2.     private void copy6(String sourceFile,String targetFile){
  3.         FileInputStream fis=null;
  4.         DataInputStream dis=null;//二进制流
  6.         FileOutputStream fos=null;
  7.         DataOutputStream dos=null;
  8.         try {
  9.             //输入流读文件
  10.             fis=new FileInputStream(sourceFile);
  11.             dis=new DataInputStream(fis);
  12.             fos=new FileOutputStream(targetFile);
  13.             dos=new DataOutputStream(fos);
  14.             int data;
  15.             //读
  16.             while((data=dis.read())!=-1){
  17.                 //写
  18.                 dos.write(data);
  19.             }
  20.             System.out.println("图片复制成功");
  21.         } catch (FileNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }finally{
  26.             try{
  27.                 if(dos!=null){
  28.                     dos.close();
  29.                 }
  30.                 if(fos!=null){
  31.                     fos.close();
  32.                 }
  33.                 if(dis!=null){
  34.                     dis.close();
  35.                 }
  36.                 if(fis!=null){
  37.                     fis.close();
  38.                 }
  39.             }catch(IOException e){
  40.                 e.printStackTrace();
  41.             }
  42.         }
  43.     }

五、序列化和反序列化

先写入再输出
FileOutputStream fos=null;
ObjectOutputStream oos=null;
FileInputStream fis=null;
ObjectInputStream ois=null;
1、首先类被实例化之前，要实现接口Serializable

  1. import java.io.Serializable;
  2. //
  3. /*要想Student被序列化，必须实现Serializable接口
  4.  * 
  5.  */
  6. public class Student implements Serializable {
  7.     /**
  8.      * -8173462577973577860L---->ID号
  9.      */
  10.     private static final long serialVersionUID = -8173462577973577860L;
  11.     private String name;
  12.     private Integer age;
  13.     //由transient 关键字修饰的属性不被序列化
  14.     private transient String pwd;
  16.     public Student(){
  18.     }
  19.     public Student(String name, Integer age, String pwd) {
  20.         super();
  21.         this.name = name;
  22.         this.age = age;
  23.         this.pwd = pwd;
  24.     }
  25.     public String getName() {
  26.         return name;
  27.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  31.     public Integer getAge() {
  32.         return age;
  33.     }
  34.     public void setAge(Integer age) {
  35.         this.age = age;
  36.     }
  37.     public String getPwd() {
  38.         return pwd;
  39.     }
  40.     public void setPwd(String pwd) {
  41.         this.pwd = pwd;
  42.     }
  43. }

2、序列化
程序（内存）———>（存储）文件
关键代码：实例化对象
//※序列化操作（自动加密）
oos.writeObject(list);
如果想要属性限制被序列化，用transient来修饰就可以

  1. public static void main(String[] args) {
  2.         FileOutputStream fos=null;
  3.         ObjectOutputStream oos=null;
  6.         try {
  7.             fos=new FileOutputStream("D:/file/stu.txt");
  8.             oos=new ObjectOutputStream(fos);
  9.             //实例化对象
  10.             Student stu1=new Student("莉莉",18,"123123");
  11.             Student stu2=new Student("明明",19,"123123");
  12.             Student stu3=new Student("壮壮",20,"123123");
  13.             List<Student> list=new ArrayList<Student>();
  14.             list.add(stu1);
  15.             list.add(stu2);
  16.             list.add(stu3);
  17.             //※序列化操作（自动加密）
  18.             oos.writeObject(list);
  19.             System.out.println("序列化完成");
  20.         } catch (FileNotFoundException e) {
  21.             e.printStackTrace();
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }finally{
  25.             try{
  26.                 if(oos!=null){
  27.                     oos.close();
  28.                 }
  29.                 if(fos!=null){
  30.                     fos.close();
  31.                 }
  32.             }catch(IOException e){
  33.                 e.printStackTrace();
  34.             }
  35.         }
  38.     }

3、反序列化
文件中的对象——>程序（内存）
//※反序列化操作
List list=(ArrayList)ois.readObject();

  1. public static void main(String[] args) {
  2.         FileInputStream fis=null;
  3.         ObjectInputStream ois=null;
  5.         try {
  6.             fis=new FileInputStream("D:/file/stu.txt");
  7.             ois=new ObjectInputStream(fis);
  8.             //※反序列化操作
  9.             List<Student> list=(ArrayList<Student>)ois.readObject();
  11. //            Student stu=(Student)ois.readObject();
  12.             for (Student stu1 : list) {
  13.                 System.out.println("学生姓名："+stu1.getName());
  14.                 System.out.println("年龄："+stu1.getAge());
  15.                 System.out.println("密码："+stu1.getPwd());
  16.             }
  18.         } catch (FileNotFoundException e) {
  19.             e.printStackTrace();
  20.         } catch (IOException e) {
  21.             e.printStackTrace();
  22.         } catch (ClassNotFoundException e) {
  23.             e.printStackTrace();
  24.         }finally{
  25.             try{
  26.                 if(ois!=null){
  27.                     ois.close();
  28.                 }
  29.                 if(fis!=null){
  30.                     fis.close();
  31.                 }
  32.             }catch(IOException e){
  33.                 e.printStackTrace();
  34.             }
  35.         }
  37.     }

六、java反射机制

1、/
 (记住这句话即可)java的反射 可以动态的创建类，并且动态的获得类的属性和方法
还可以动态的调用和执行相应的方法
/
2、stu. eclipse 动态获取该类的属性和方法
3、//获取反射类的方法
（1）、getClass()—->创建了对象的情况（了解即可）
（2）、类名.class——>不创建对象的情况
（3）、(用的更多).Class.forName(“全类名”);
4、//获取clazz对象的属性和方法（私有属性无法获取）
Field[] fields=clazz.getFields();//返回属性数组,私有属性反射获取不到
5、clazz=Class.forName(“cn.bdqn.reflect.Student”);括号里面是类所在的全部地址
6、

  1. /*
  2.      * (记住这句话即可)java的反射 可以动态的创建类，并且动态的获得类的属性和方法
  3.      * 还可以动态的调用和执行相应的方法
  4.      */
  5.     public static void main(String[] args) {
  6.         // 
  7.         //Object o=new Object();
  9.         //stu.  eclipse 动态获取该类的属性和方法
  11.         //获取反射类的方法
  12.         //(了解即可)1.getClass()--->创建了对象的情况
  13. //        Student stu=new Student();
  14. //        Class clazz=stu.getClass();
  16.         //2.类名.class---->不创建对象的情况
  17. //        Class clazz=Student.class;
  19.         //(用的更多)3.Class.forName("全类名");
  20.         Class clazz=null;
  21.         try {
  22.             clazz=Class.forName("cn.bdqn.reflect.Student");
  23.         } catch (ClassNotFoundException e) {
  24.             e.printStackTrace();
  25.         }
  29.         System.out.println("---------获取属性---------");
  30.         //获取clazz对象的属性和方法（私有属性无法获取）
  31.         Field[] fields=clazz.getFields();//返回属性数组,私有属性反射获取不到
  32.         for (Field field : fields) {
  33.             System.out.println(field.getName());
  34.         }
  35.         System.out.println("----------获取方法--------------");
  36.         //获取方法
  37.         Method[] methods=clazz.getMethods();
  38.         for (Method method : methods) {
  39.             System.out.println(method.getName());
  40.         }
  43.     }

7、反射还可以动态的调用和执行相应的方法
例如：setName再getName
image.png

  1.     /*
  2.      * 反射还可以动态的调用和执行相应的方法
  3.      */
  4.     public static void main(String[] args) {
  5.         // 1Student反射类创建好
  6.         Class clazz=null;
  7.         clazz=Student.class;
  9.         //getMethod("方法名", 参数)
  10.         try {
  12.             //2newInstance  获取clazz的实例对象
  13.             Student stu=(Student)clazz.newInstance();
  14.             //3
  15.             Method m=clazz.getMethod("setName", String.class);
  16.             //4调用方法
  17.             m.invoke(stu, "李雷");
  18.             //setName需要传参，getName不需要传参，所以是null
  19.             Method m1=clazz.getMethod("getName", null);
  20.             //调用方法
  21.             Object o=m1.invoke(stu, null);
  22.             System.out.println(o);
  23.         } catch (NoSuchMethodException e) {
  24.             e.printStackTrace();
  25.         } catch (SecurityException e) {
  26.             e.printStackTrace();
  27.         } catch (IllegalAccessException e) {
  28.             e.printStackTrace();
  29.         } catch (IllegalArgumentException e) {
  30.             e.printStackTrace();
  31.         } catch (InvocationTargetException e) {
  32.             e.printStackTrace();
  33.         } catch (InstantiationException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }

8、拓展
main方法内{
T2.a(“a”,”b”);
}
private static void a(String…s){
//拓展，…表示可以传入1个或者多个参数
System.out.println(s[0]);
System.out.println(s[1]);
}
9、线程安全性

  1. public static void main(String[] args) {
  2.         //HashMap线程不安全
  3.         Map map1=new HashMap();
  4.         //Hashtable线程安全（全锁）
  5.         Map map2=new Hashtable();
  6.         //ConcurrentHashMap线程安全 （1.7分段锁，1.8自旋锁CAS+synchronized）
  7.         Map map3=new ConcurrentHashMap();
  9.     }