单例模式,Filed类,递归,IO流,序列化与反序列化,TCP与UDP,反射

1.单例模式

单例模式:始终在内存中创建一个实例;
分为两种:
	饿汉式:永远不会出现问题的单例模式;
	懒汉式:可能出现问题的一种单例模式;
饿汉式:
	1)构造方法私有:保证外界不能直接创建当前类对象;
	2)在当前类的成员位置创建当前类实例;
	3)提供一个静态的功能,返回值就是当前类本身(需要当前类的实例)
懒汉式:
	1)构造方法私有化;
	2)在当前成员变量的位置声明变量:数据类型就是当前类(私有的,静态的);
	3)提供静态功能,返回值是当前类本身
		判断如果当前没有给当前类型变量为null,直接new当前类的实例;如果不为null,就返回当前类的变量
			可能出现延时加载或懒加载---出现安全问题

Runtime:当前获取的当前本地运行环境的实例;
public int availableProcessors():获取本地计算机的处理器数量
public Process exec(String command):开启某个软件的进程(参数为字符串命令)

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

        //获取当前类的实例:Runtime  利用单例模式
        Runtime runtime = Runtime.getRuntime();
        System.out.println(runtime.availableProcessors());
        Process notepad = runtime.exec("notepad");
        System.out.println(runtime.exec("QQ"));

        //利用关机
        //exec("shutdown -s"):立即关机
        //exec("shutdown -s -t 300"):立即关机
        //exec("shutdown -a"):取消关机

        System.out.println(runtime.exec("shutdown -s -t 300"));
        System.out.println(runtime.exec("shutdown -a"));

    }
}

2.File类

File文件和目录(文件夹)路径名的抽象表示
构造方法:
	File(String pathname) : 参数就是指定的路径/如果没有指定路径(默认是在当前项目下)
	通过将给定的路径名字符串转换为抽象路径来创建新的FIle实例
	File(File parent , String child):从父抽象路径名和子路径名字符串创建新的File实例;
	File(String parent, String child): 参数1:父目录地址  参数2; 具体的子文件地址;
成员方法:
	public boolean createNewFile()  throws IOExcepption:表示创建文件:如果不存在则创建;
	public boolean mkdir():创建文件夹,如果不存在,则创建;否则就返回false;
	public boolean mkdirs():创建多个文件,如果父目录不存在,则创建;
	public boolean delete():删除文件或者文件夹(如果删除文件夹,文件夹必须为空目录);
	public boolean renameTo(File dest):重命名,参数传递的修改的File对象;
判断方法:
	public boolean canRead()是否可读;
	public boolean canWrite()是否可写;
	public boolean exists():是否存在;
	public boolean isFile():是否是文件;
	public boolean isDirectory():是否是文件夹;
	public boolean isHidden():是否隐藏;
高级获取功能:
	public long length();
	public String getName():获取抽象路径 名所表示的文件或者目录的名称;
	public File[] listFiles():获取某个目录下的所有的文件以及文件夹的File数组;
	public String[] list():获取某个抽象路径名所表示的文件以及目录的字符串数组;

获取D盘下的所有文件夹及文件的名称

public class FileDemo2 {
   
    public static void main(String[] args) {
   

        //创建File对象,描述当前项目下的aaa.txt文件
        File file = new File("aaa.txt") ;
        System.out.println(file.canRead());
        System.out.println(file.canWrite());
        System.out.println(file.exists());
        System.out.println(file.isDirectory());//false
        System.out.println(file.isFile());
        System.out.println(file.isHidden());
        System.out.println(file.length());
        System.out.println(file.getName());
        System.out.println("------------------------");

        // public File[] listFiles():获取某个目录下的所有的文件以及文件夹的File数组
        //描述D盘
        File file2 = new File("d://") ;
        File[] fileArray = file2.listFiles();
        //防止空指针异常
        if(fileArray!=null){
   
            for(File f :fileArray){
   
                System.out.println(f.getName());
            }
        }
        System.out.println("----------------------------------");
        //public String[] list():获取某个抽象路径名所表示的文件以及目录的字符串数组
        String[] strArray = file2.list();
        if(strArray!=null){
   
            for(String s:strArray){
   
                System.out.println(s);
            }
        }
    }
}

public class FileDemo {
   
    public static void main(String[] args) throws IOException {
   
        //表示:E盘下的demo文件夹中的a.txt文件
        //File(String pathname) 方式1 (推荐)
       // File file = new File("e://demo//a.txt") ;只是表示这个路径,如果创建a.txt文件,系统找不到指定路径

        File file = new File("D:\\EE_2106\\day25\\code\\a.txt"); //绝对路径
        File file2 = new File("aaa.txt");//没有带路径,就默认在当前项目下(相对路径)
        File file3 = new File("D:\\EE_2106\\day25\\code\\demo") ;
        File file4 = new File("aaa\\bbb\\ccc\\ddd") ;
        System.out.println(file.createNewFile());
        System.out.println(file2.createNewFile());
        System.out.println(file3.mkdir());
        System.out.println(file4.mkdirs());
        System.out.println(file3.delete());
        System.out.println(file.delete());
        File srcFile = new File("D:\\EE_2106\\day25\\code\\mv.jpg") ;
        File destFile = new File("高圆圆.jpg") ;//当前项目路径下了
        System.out.println(srcFile.renameTo(destFile)) ;



    }
}

获取D盘下所有的以.jpg结尾的文件

 /*      提供了另一个重载功能:
 *              public File[] listFiles(FilenameFilter filter)
 *              String[] list(FilenameFilter filter)
 *          参数为:文件名称过滤器FilenameFilter:接口
 *                  成员方法:
 *                  boolean accept(File dir,String name):测试指定文件是否包含在文件列表中
 *                          返回如果true,将文件添加到文件列表中
 *                     1)描述下D盘
 *                   2)  public  File[]listFiles(FilenameFilterfilenamefilter):
 *                              获取D盘下的File数组的时候,就已经指定文件进行过滤...
 */
public class FileTest {
   
    public static void main(String[] args) {
   
        //1)描述D盘
        File file = new File("D://") ;

        //2)获取盘符下的所有的文件以及文件夹的File数组
        File[] fileArray = file.listFiles();//这一步并没有直接获取到要的.jpg文件
        //后面一些判断
        if(fileArray!=null){
   
            for(File f:fileArray){
   

                //判断f是文件
                if(f.isFile()){
   
                    //是文件
                    //判断它的名称是否以.jpg结尾
                    if(f.getName().endsWith(".jpg")){
   
                        System.out.println(f.getName());
                    }
                }
            }
        }

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

        //描述下D盘
        File srcFile = new File("D://") ;

        //获取当前D盘下的所有文件以及文件夹File数组,并进行文件名过滤
        //public File[] listFiles(FilenameFilter filter)
        File[] files = srcFile.listFiles(new FilenameFilter() {
   //接口的匿名内部类
            @Override
            public boolean accept(File dir, String name) {
   
                //返回true:表示将指定文件添加列表文件中
                //描述文件所表示抽象路径File
                File file = new File(dir, name);

                //两个条件:file是文件并且file的文件名称以".jpg结尾"
                return file.isFile() && file.getName().endsWith(".jpg");
            }
        });
        if(files!=null){
   
            for(File f :files){
   
                System.out.println(f.getName());
            }
        }
    }
}

3.递归

方法递归:方法调用方法本身的一种现象,并非是方法嵌套方法;
前提条件:
	1)必须有一个成员方法;
	2)必须有方法递归的出口条件(结束条件),如果没有出口条件,就是死递归;
	3)还存在一定规律
注意事项:构造方法不存在递归

//使用递归方式删除D盘某个demo文件夹中有很多个目录,每个目录中还可能有目录,删除所有的以.java结尾的文件
public class DiGuiTest {
   
    public static void main(String[] args) {
   

         //描述D盘的demo文件夹
         File srcFloder = new File("d://demo") ;
         //调用递归删除的方法
        deleteFloder(srcFloder) ;
    }


    public static void deleteFloder(File srcFloder) {
   
        //获取srcFloder下的所有的文件以及文件的File数组
        File[] fileArray = srcFloder.listFiles();
        if(fileArray!=null){
   
            for(File file:fileArray){
   
                //获取到每一个file对象
                //如果file是文件夹,继续回到deleteFloder(srcFloder) ; 删除文件夹
                if(file.isDirectory()){
   
                    deleteFloder(file) ;
                }else{
   
                    //判断是文件,必须以.java结尾 文件
                    if(file.getName().endsWith(".java")){
   
                        //删除的同时----获取名称
                        System.out.println(file.getName()+"------------"+file.delete());
                    }
                }

            }
            //删除文件夹
            System.out.println(srcFloder.getName()+"----"+srcFloder.delete());
        }
    }
}

4.IO流

IO流的分类

按流的方向:
	输入流和输出流;
按类型分:
	字节流和字符流:字节流先出现,后面才有字符流;
	再按流的方向划分:
		字节输入流:InputStream:表示输入字节流的所有类的超类;
		字节输出流:OutputStream:表示字节输出流的所有类的超类
		字符输入流:Reader:表示输入字符流的抽象类;
		字符输出流:Writer:表示输出字符流的抽象类;

字节输出流:OutputStream抽象类子类进行实例化FileOutputStream:将指定的内容写到文件中
实现步骤:
	1)创建文件输出流对象:FileOutputStream(String name):可以指定参数地址,FileOutputStream(File file);
	2)写数据:
		public void write(int b) throws IOException 写一个字节;
		public void write(byte[] bytes) throws IOException 写一个字节数组;
		public void write(byte[] bytes,int off,int len) throws IOException:写一部分字节数组;
	3)关闭资源;

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

        //创建文件输出流对象
        //指向某个盘符下的文件中(或者当前项目下)
        FileOutputStream fos = new FileOutputStream("my.txt") ;//文件需要被创建当前项目下

        //2)写数据
       /* fos.write(97);
        fos.write(98);
        fos.write(99);*/

       //写一个字节数组
      /*  byte[] bytes = {97,98,99,100,101,102} ;
       // fos.write(bytes);
        fos.write(bytes,2,2);*/
      for(int x = 0 ; x < 10 ; x ++){
   
          fos.write(("hello"+x).getBytes());

          //windows操作系统  "\r\n"代表换换行
          fos.write("\r\n".getBytes());
      }
        //3)关闭资源
        fos.close(); //释放fos流对象所指向的my.txt的系统资源
    }
}

在字节输出流中加入异常处理(捕获异常)

public class FileOutputStreamDemo2 {
   

    public static void main(String[] args) {
   

       // method1() ;
        method2() ;//
    }

    //标准方式:try...catch...finally
    //统一处理
    private static void method2() {
   
        FileOutputStream fos = null ;
        //alt+ctrl+t--->
        try {
   
           fos = new FileOutputStream("fos2.txt") ;
            //写数据
            fos.write("hello,我来了".getBytes());
        } catch (IOException e) {
   
            e.printStackTrace();
        }finally {
   
            //释放资源

                if(fos!=null){
   
                    try {
   
                        fos.close();
                    } catch (IOException e) {
   
                        e.printStackTrace();
                    }
                }
        }
    }
}