Java基础

---

提示：以下是本篇文章正文内容，下面案例可供参考

File

是文件和目录【路径名】的抽象表示

1.File类的构造方法

public static void construction_Method(){
    //构造方法1，格式：new File("路径");
    File file1 = new File("E:\\test\\java.txt");
    System.out.println(file1);

    //构造方法2，格式：new File("父路径", "子路径");
    File file2 = new File("E:\\test", "java.txt");
    System.out.println(file2);

    //构造方法1，格式：格式1+格式2
    File file3 = new File("E:\\test");
    File file4 = new File(file3, "java.txt");
    System.out.println(file4);
}

2.File类的创建

public static boolean create_Method() throws IOException {
    boolean flag = false;

    //方法1：createNewFile()，【文件】不存在则创建(返回Boolean值)
    File file1 = new File("E:\\test\\java.txt");
    if (file1.createNewFile()){
        flag = true;
        System.out.println("文件创建成功");
    }else {
        System.out.println("文件创建失败");
        return flag;
    }

    //方法2：mkdir()，【目录】不存在则创建(返回Boolean值)
    File file2 = new File("E:\\testFile");
    if (file2.mkdir()){
        flag = true;
        System.out.println("目录创建成功");
    }else {
        System.out.println("目录创建失败");
        return flag;
    }

    //方法3：mkdirs()，【目录】不存在则创建(可创建多级目录，返回Boolean值)
    File file3 = new File("E:\\testFile\\testJAVA\\test");
    if (file3.mkdirs()){
        flag = true;
        System.out.println("目录创建成功");
    }else {
        System.out.println("目录创建失败");
        return flag;
    }
    return flag;
}

3.File类的常用方法

public static void common_Method(){
    File file = new File("myFile\\java.txt");

    //判断该【抽象路径】表示的【File】是否为【目录】：isDirectory()
    System.out.println("是否为目录" + file.isDirectory());

    //判断该【抽象路径】表示的【File】是否为【文件】：isFile()
    System.out.println("是否为文件" + file.isFile());

    //判断该【抽象路径】表示的【File】是否【存在】：exists()
    System.out.println("是否为存在" + file.exists());

    //获取该【抽象路径】的【绝对路径名】字符串：getAbsolutePath()
    System.out.println("绝对路径为：" + file.getAbsoluteFile());

    //获取该【抽象路径】的【路径名】字符串：getPath()
    System.out.println("路径为：" + file.getPath());

    //获取该【抽象路径】所表示的【文件名】或【目录名】：getName()
    System.out.println("名称为：" + file.getName());

    //获取该【抽象路径】所表示的【目录】中的文件名和目录名【字符串数组】：list()
    File file2 = new File("E:\\test");
    String[] strArr = file2.list();
    for (String str:strArr)
        System.out.println(str);
        
    //获取该【抽象路径】所表示的【目录】中的文件和目录【File对象数组】：listFiles()
    File[] fileArr = file2.listFiles();
    for (File filetest:fileArr)
        //只取文件
        if (filetest.isFile())
            //打印文件名和文件路径
            System.out.println(filetest.getName() + "的路径为：" + filetest.getPath());

    //删除文件或目录：delete()
    File dir = new File("E:\\myFileTest\\test");
    File file3 = new File(dir, "java.txt");
    try {
        dir.mkdirs();
        if (file3.createNewFile()){
            System.out.println("文件创建成功，所在路径为：" + file3.getPath());
        }else {
            System.out.println("文件创建失败");
        }
        //要删除myFileTest目录得先删完目录内的文件
        file3.delete();
        if (dir.delete()) {
            System.out.println("删除成功，删除的目录为：" + dir.getName());
        }

    } catch (IOException e) {
        e.printStackTrace();
    }
}

4.练习

遍历某个目录下的所有内容

public static void getAllFile(File srcFile){
    File[] filesArr = srcFile.listFiles();
    //判断该目录下是否为空
    if (filesArr != null){
        //遍历获取文件
        for (File file:filesArr){
            //判断是否还有目录，若有目录则递归调用继续遍历
            if (file.isDirectory()){
                getAllFile(file);
            }else {
                System.out.println(file.getAbsoluteFile());
            }
        }
    } else {
        System.out.println("该目录下无内容");
    }
}

复制多级文件夹

public static void main(String[] args) {
    File srcFile = new File("E:\\myFileTest");
    File destFile = new File("F:\\");
    copyFolder(srcFile, destFile);
}

//复制文件夹
public static void copyFolder(File srcFile, File destFile){
    // 对源文件进行判断
    if (srcFile.isDirectory()){             //对目录的操作
        // 1.在目的盘下创建源目录
        // 获取源目录名
        String srcFileName = srcFile.getName();
        // 在目的盘上拼接文件名：destFile:\\srcFileName
        File newFolder = new File(destFile, srcFileName);
        // 判断目的盘是否已存在该文件
        if (!newFolder.exists()){
            newFolder.mkdirs();
        } else {
            System.out.println("该目录已存在，请删除后再进行操作");
        }
        // 2.获取源File下的所有内容
        File[] fileArr = srcFile.listFiles();
        // 3.递归判断源File下的所有内容
        for (File file : fileArr) {
            copyFolder(file, newFolder);
        }
    } else {                                //对文件的操作
        // 1.在目的盘拼接文件名：destFile:\\*\\srcFile.xx
        File newFile = new File(destFile, srcFile.getName());
        // 2.调用函数进行文件复制
        copyFile(srcFile, newFile);
    }
}
//复制文件
public static void copyFile(File srcFile, File destFile){
    BufferedInputStream bIps = null;
    BufferedOutputStream bOps = null;

    try {
        bIps = new BufferedInputStream(new FileInputStream(srcFile));
        bOps = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bIps.read()) != -1){
            bOps.write(bys, 0, len);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (bIps != null){
            try {
                bIps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bOps != null){
            try {
                bOps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

IO流

IO实际上就是数据传输，常见应用：文件上传、下载、复制(O用来写，I用来读)
分类(默认按数据类型来分)：字节流(又称为万能流)、字符流

字节流

1.输入流

public static void FileInPuttest(){
    //读简单字节文件
    FileInputStream fileInputStream = null;
    FileInputStream fileInputStream2 = null;
    try {
        fileInputStream = new FileInputStream("E:\\myInputTest\\java.txt");

        //读数据(得一个字符一个字符的读)
//            int read = fileInputStream.read();
//            System.out.println(read);
//            System.out.println((char)read);
//            read = fileInputStream.read();
//            System.out.println(read);
//            System.out.println((char)read);

        //遍历整个字节文本数据
        int read = 0;
        while ((read=fileInputStream.read()) != -1){        
        //read=fileInputStream.read())即相当于上面一个一个的读
            System.out.println((char)read);
        }
        
    	//读一个字节数组的数据
		fileInputStream2 = new FileInputStream("E:\\myInputTest\\web.txt");
        byte[] bys = new byte[1024];
        int len;
        while ((len=fileInputStream2.read(bys)) != -1){
            System.out.println(new String(bys, 0, len));
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (fileInputStream != null){
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.输出流

public static void FileOutPuttest(){
    //通过字节流创建文件对象，会自动创建文件
    /*
        字节流操作过程：
            调用系统功能创建了文件；创建字节流对象；将字节流对象指向文件
     */
    //true表示写入的内容插入末尾
    FileOutputStream fileInputStream = null;
    try {
        fileInputStream = new FileOutputStream("myByteStream\\test1.txt", true);
        //写入字节，写入非字节内容时，要调用getBytes()方法
        fileInputStream.write(92);
        //插入换行符
        fileInputStream.write("\r\n".getBytes());
        fileInputStream.write("hello".getBytes());
        byte[] bys = {1,14,65,86};
        fileInputStream.write(bys);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (fileInputStream != null){
            //关闭流
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.字节缓冲流

BufferedOutputStream、BufferedInputStream。作用：提高读写数据的效率

//BufferedOutputStream
public static void BufferOpS(){
    FileOutputStream fOpS = null;
    BufferedOutputStream bfOpS = null;

    try {
        //写法一
        //fOpS = new FileOutputStream("myByteStream\\test1.txt", true);
        //bfOpS = new BufferedOutputStream(fOpS);

        //写法二
        bfOpS = new BufferedOutputStream(new FileOutputStream("myByteStream\\test1.txt", true));

        //写数据
        bfOpS.write("hello".getBytes());
        bfOpS.write("world".getBytes());

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (fOpS != null){
            try {
                fOpS.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if ( bfOpS != null){
            try {
                bfOpS.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//BufferedInputStream
public static void BufferIpS(){
    FileInputStream fIpS = null;
    BufferedInputStream bfIpS = null;

    try {
        //写法一
        //fIpS = new FileOutputStream("myByteStream\\test1.txt", true);
        //bfIpS = new BufferedOutputStream(fOpS);

        //写法二
        bfIpS = new BufferedInputStream(new FileInputStream("myByteStream\\test1.txt"));

        //读数据
        int by;
        while ((by=bfIpS.read()) != -1){
            System.out.println((char)by);
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (fIpS != null){
            try {
                fIpS.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if ( bfIpS != null){
            try {
                bfIpS.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

练习

复制文本文件

public static void copyFileTest(){
    //把E:\\myFiltest\\java.txt文件的内容，复制到项目目录下的java.txt中
    FileInputStream fileIpS = null;
    FileOutputStream fileOpS = null;
    try {
        fileIpS = new FileInputStream("E:\\myFiletest\\java.txt");
        fileOpS = new FileOutputStream("myByteStream\\java.txt");

        //读取数据
        int file = 0;
        while ((file=fileIpS.read()) != -1){
            fileOpS.write(file);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (fileIpS != null){
            try {
                fileIpS.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fileOpS != null){
            try {
                fileOpS.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

复制图片文件

public static void copyImgTest(){
    FileInputStream fileIps = null;
    FileOutputStream fileOps = null;
    try {
        fileIps = new FileInputStream("E:\\myFiletest\\md.png");
        fileOps = new FileOutputStream("myByteStream\\md.png");

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len=fileIps.read(bys)) != -1){
            fileOps.write(bys, 0, len);
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (fileIps != null){
            try {
                fileIps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fileOps != null){
            try {
                fileOps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

复制视频

public static void copyVedio(){
    //记录开始时间
    long startTime = System.currentTimeMillis();

    //复制视频
    FileInputStream fIps = null;
    FileOutputStream fOps = null;
    BufferedInputStream bfIps = null;
    BufferedOutputStream bfOps = null;

    try {
        fIps = new FileInputStream("E:\\test\\test.avi");
        fOps = new FileOutputStream("myByteStream\\test.avi");

        // 1.普通方式
//            int by;
//            while ((by=fIps.read()) != -1){
//                fOps.write(by);
//            }
        // 2.字节数组方式
//            byte[] bys = new byte[1024];
//            int len;
//            while ((len=fIps.read(bys)) != -1){
//                fOps.write(bys, 0, len);
//            }
        // 3.使用字节缓冲流的普通方式
//            bfIps = new BufferedInputStream(fIps);
//            bfOps = new BufferedOutputStream(fOps);
//            int by;
//            while ((by=bfIps.read()) != -1){
//                bfOps.write(by);
//            }
        // 4.使用字节缓冲流读字节数组的方式，最推荐
        bfIps = new BufferedInputStream(fIps);
        bfOps = new BufferedOutputStream(fOps);
        byte[] bys = new byte[1024];
        int len;
        while ((len=bfIps.read(bys)) != -1){
            bfOps.write(bys, 0, len);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (fOps != null){
            try {
                fOps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fOps != null){
            try {
                fOps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bfIps != null){
            try {
                bfIps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bfOps != null){
            try {
                bfOps.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //记录结束时间
    long endTime = System.currentTimeMillis();
    System.out.println("共耗时：" + (endTime-startTime) + "毫秒");;
}

字符流

解决字节流操作中文乱码问题，适合纯文本文件，字符流=字节流+编码表
一个汉子在GBK中占2个字节，在UTF8中占3个字节

1.字符输入流

Reader：FileReader、BufferedReader

public static void ReaderTest(){
   //FileReader
//        FileReader fileReader = null;
//        try {
//            fileReader = new FileReader("E:\\test\\java.txt");
//
//            //读文件
//            char[] chars = new char[1024];
//            int len = 0;
//            while ((len=fileReader.read(chars)) != -1){
//                //将字符数组转成字符串
//                String str = new String(chars, 0, len);
//                System.out.println(str);
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            if (fileReader != null){
//                try {
//                    fileReader.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }

    //BufferedReader
    BufferedReader bufferedReader = null;
    try {
        bufferedReader = new BufferedReader(new FileReader("E:\\test\\java.txt"));
        //按行读数据
        String line;
        while ((line=bufferedReader.readLine()) != null){
            System.out.println(line);
        }

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

2.字符输出流

Writer：FileWriter、BufferedWriter

public static void WriterTest(){
    //FileWriter
//        FileWriter fileWriter = null;
//        String str = "java真好";
//        try {
//            fileWriter = new FileWriter("E:\\test\\java.txt", true);
//            //写文件
//            fileWriter.write(str);
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            if (fileWriter != null){
//                try {
//                    fileWriter.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }

    //BufferedWriter
    BufferedReader bufferedReader = null;
    BufferedWriter bufferedWriter = null;
    try {
        bufferedReader = new BufferedReader(new FileReader("E:\\test\\java.txt"));
        bufferedWriter = new BufferedWriter(new FileWriter("myCharStream\\java.txt"));

        //复制文件
        String line;
        while ((line=bufferedReader.readLine()) != null){
            bufferedWriter.write(line);
            //readLine不读换行符，因此要手动换行
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (bufferedReader != null){
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bufferedWriter != null){
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

练习

集合到文件：
把ArrayList集合中的字符串数据写入到文本文件(每一个字符串元素作为文件中的一行数据)

public static void charStreamTest(){
//        BufferedWriter bufferedWriter = null;
//
//        //创建集合
//        ArrayList<String> list = new ArrayList<>();
//
//        //存数据
//        list.add("hello");
//        list.add("world");
//        list.add("java");
//        list.add("python");
//
//        //创建字符缓冲流对象
//        try {
//            bufferedWriter = new BufferedWriter(new FileWriter("E:\\test\\java.txt"));
//
//            //遍历集合
//            for (String str : list) {
//                //写数据
//                bufferedWriter.write(str);
//                bufferedWriter.newLine();
//                bufferedWriter.flush();
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            if (bufferedWriter != null){
//                try {
//                    bufferedWriter.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }

   //升级款，格式:学号,姓名,年龄,居住地
    //举例: 1,张三,30,广州
    BufferedWriter bufferedWriter = null;
    ArrayList<Student> list = new ArrayList<>();

    Student stu01 = new Student(001, "张三", 18, "广州南");
    Student stu02 = new Student(002, "李四", 28, "广州东");
    Student stu03 = new Student(003, "王五", 38, "广州北");

    list.add(stu01);
    list.add(stu02);
    list.add(stu03);

    //创建字符缓冲流对象
    try {
        bufferedWriter = new BufferedWriter(new FileWriter("E:\\test\\java.txt"));

        //遍历集合
        for (Student student : list) {
            //规定写入格式
            StringBuffer sb = new StringBuffer();
            sb.append(student.getStu_id()).append(",").append(student.getName()).append(",")
                    .append(student.getAge()).append(",").append(student.getAddress());
            bufferedWriter.write(sb.toString());
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (bufferedWriter != null){
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件到集合：
把文本文件中的数据读取到集合中，并遍历集合(文件中每一行数据是一个集合元素)

public static void charStreamTest2(){
//        BufferedReader bufferedReader = null;
//        ArrayList<String> list = new ArrayList<>();
//
//        try {
//            bufferedReader = new BufferedReader(new FileReader("E:\\test\\java.txt"));
//
//            String line;
//            while ((line=bufferedReader.readLine()) != null){
//                list.add(line);
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            if (bufferedReader != null){
//                try {
//                    bufferedReader.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//        }
//        //遍历集合
//        for (String str : list) {
//            System.out.println(str);
//        }

    //升级款，按格式切分文件中的数据并读入集合中
    //举例: itheima001,林青霞,30,西安
    BufferedReader bufferedReader = null;
    ArrayList<Student> list = new ArrayList<>();

    try {
        bufferedReader = new BufferedReader(new FileReader("E:\\test\\java.txt"));

        String line;
        while ((line=bufferedReader.readLine()) != null){
            //分割字符串
            String[] str = line.split(",");
            //赋值
            Student student = new Student();
            student.setStu_id(Integer.parseInt(str[0]));
            student.setName(str[1]);
            student.setAge(Integer.parseInt(str[2]));
            student.setAddress(str[3]);

            list.add(student);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (bufferedReader != null){
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //遍历集合
    for (Student str : list) {
        System.out.println(str.getStu_id()+","+str.getName()+","+str.getAge()+","+str.getAddress());
    }
}

点名器
有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名器

public static void charStreamTest3(){
    BufferedReader bufferedReader = null;
    ArrayList<String> list = new ArrayList<>();

    try {
        bufferedReader = new BufferedReader(new FileReader("E:\\test\\java.txt"));

        String line;
        while ((line=bufferedReader.readLine()) != null){
            list.add(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (bufferedReader != null){
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //取随机数
    Random random = new Random();
    int index = random.nextInt(list.size());

    //根据随机数索引去list中取值
    String name = list.get(index);
    System.out.println("幸运者是：" + name);
}

标准输入输出流

1.标准输入流

读取来自【键盘的输入】或【指定源的输入】
（是Scanner的底层）

BufferedReader bufferedReader2 = new BufferedReader(new InputStreamReader(System.in));
//实现输入字符串
System.out.println("请输入内容");
String strLine = bufferedReader2.readLine();
System.out.println("您输入的内容为：" + strLine);
//实现输入整数类型
System.out.println("请输入整数");
int i = Integer.parseInt(strLine);
System.out.println("您输入的内容为：" + i);

2.标准输出流

显示输出
（是System.out,println的底层）

PrintStream ps =  System.out;
ps.println("hh");
ps.print(100);

System.out.println("hh");
System.out.println(100);

3.字节打印流

PrintStream

PrintStream ps = new PrintStream("E:\\test\\java.txt");
ps.println(97);

4.字符打印流

PrintWriter

PrintWriter pw = new PrintWriter(new FileWriter("myPrintWriter\\java.txt"), true);
pw.writer("hello");
pw.writer("\r\n");
pw.flush();
//相当于
pw.println("hello");

pw.close();

练习

BufferedReader bufferedReader = null;
PrintWriter printWriter = null;

try {
    bufferedReader = new BufferedReader(new FileReader("myStream\\java.txt"));
    printWriter = new PrintWriter(new FileWriter("myStream\\copy.txt"));

    String strLint;
    while ((strLint=bufferedReader.readLine()) != null){
        printWriter.println(strLint);
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if (bufferedReader != null){
        try {
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if (printWriter != null){
        try {
            printWriter.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.对象序列化流

对象序列化：将对象保存在磁盘或网络传输对象中
对象序列化流：ObjectOutputStream，对象反序列化流：ObjectInputStream

6.Properties

Properties作为集合使用(Map)

Properties prop = new Properties( );

prop.put("001", "张三");
prop.put("002", "李四");
prop.put("003", "王五");
//遍历集合
Set<Object> keySet = prop.keySet();
for (object key : keySet) {
	Object value = prop.get( key );
	system.out.print1n(key + "," + value);
}
//Properties作为集合使用所特有的方法
prop.setProperty("004","赵六");		//setProperties()底层是调用Hashtable的put()
System.out.println(prop.getProperty("002"));		//根据键取值
Set<String> names = prop.stringProprtyNames();		//获取键的集合
for(String key:names){
	String value = prop.getProperty(key);
	System.out.println(key + "," + "value");
}

Properties与IO流结合使用

//从文件中读集合内容
    private static void PropertyIO_Load() {
        FileReader fileReader = null;
        Properties properties = new Properties();

        try {
            fileReader = new FileReader("myStream\\java.txt");

            properties.load(fileReader);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //把集合的内容写入文件
    private static void PropertyIO_Store() {
        FileWriter fileWriter = null;
        Properties properties = new Properties();

        properties.setProperty("001", "张三");
        properties.setProperty("002", "李四");
        properties.setProperty("003", "王五");

        try {
            fileWriter = new FileWriter("myStream\\java.txt");

            //store()：将属性列表(键值对)写入Properties表中；load()：从字节/字符流读取属性列表
            //store(param1, param2)，param1：输出流对象，param2：对输出流对象的说明
            properties.store(fileWriter, null);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

练习：游戏次数

//GuessNumber类
public class GuessNumber {
    public GuessNumber() {}

    public static void start() {
        Random r = new Random( ) ;
        int number = r.nextInt(100)+1;

        while (true){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入你要猜的数字：");
            int guessNumber = scanner.nextInt( );

            if (guessNumber > number){
                System.out.println("你猜的数字"+ guessNumber +"大了");
            } else if (guessNumber < number) {
                System.out.println("你猜的数字" + guessNumber +"小了");
            } else {
                System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}
//game.txt文件
count=0;
//Game_Test测试类
private static void Game_Test() {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        Properties properties = new Properties();

        try {
            //读取记录次数的文件
            fileReader = new FileReader("myStream\\game.txt");
            properties.load(fileReader);

            //获取游戏次数
            String count = properties.getProperty("count");
            int number = Integer.parseInt(count);

            //判断次数
            if (number >= 3){
                System.out.println("游戏试玩已结束");
            } else {
                //玩游戏
                GuessNumber.start();

                number++;
                //更新次数
                properties.setProperty("count", String.valueOf(number));
                //将次数写回记录次数的文件
                fileWriter = new FileWriter("myStream\\game.txt");
                properties.store(fileWriter, null);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

线程

1.线程简介

进程：可以理解为一个程序(进程是静态的)
线程：可以理解为程序的各个方法(线程是动态的，是CPU调度和执行的基本单位，一个进程中可以由很多个线程)

2.多线程的创建方法

方式一：继承Thread类
由于Java仅支持单继承，故不推荐使用

// 1.继承Thread类
public class Thread_Test extends Thread{
	// 2.重写run()方法
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我在学代码" + i);
        }
    }

    //main线程(主线程)
    public static void main(String[] args) {
        //开启多线程
        Thread_Test threadTest = new Thread_Test();
		// 3.调用start()方法开启线程(主线程与其它线程会同时运行)
        threadTest.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学多线程" + i);
        }
    }
}

方式二：实现Runnable接口（推荐）
因为java是单继承机制，故使用Runnable更好

// 1.实现Runnable接口
public class Runnable_Test implements Runnable{
    // 2.重写run()
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我在学代码" + i);
        }
    }

    //main线程(主线程)
    public static void main(String[] args) {
        // 3.开启多线程
        // (1)创建runnbale接口的实现类对象
        Runnable_Test runnableTest = new Runnable_Test();
        // (2)创建线程对象，通过线程对象调用实现类对象，开启多线程
        /*Thread thread = new Thread(runnableTest);
        thread.start();     //等价于下面的写法*/
        new Thread(runnableTest).start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学多线程" + i);
        }
    }
}

//小练习：龟兔赛跑，谁先走100步谁赢
public class Race implements Runnable{
    //定义胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
        }
    }

    //判断是否结束比赛
    private boolean gameOver(int step){
        //判断是否由胜利者
        if (winner != null){
            return true;
        }
        //代码块
        {
            if (step >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is：" + winner);
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

3.实现Callable接口
好处：1.可以定义返回值；2.可以抛出异常
略

3.线程安全问题

线程不同步

public class Runnable_Test implements Runnable{
    //定义票数
    private int ticketNum = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNum <= 0)
                break;
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "张票");
        }
    }

    public static void main(String[] args) {
        Runnable_Test ticket = new Runnable_Test();

        new Thread(ticket, "张三").start();
        new Thread(ticket, "李四").start();
        new Thread(ticket, "王五").start();
    }
}

4.静态代理模式

真实对象和代理对象要实现同一个接口，代理对象代理真实对象
思想：代理对象替真实对象完成一系列操作，而真实对象专注实现自己的操作即可

public class StaticProxy {
    public static void main(String[] args) {
        Who who = new Who();
        new WeddingCompany(who).getMarry();
    }
}
interface Marry{
    void getMarry();
}
//真实对象
class Who implements Marry{
    @Override
    public void getMarry() { System.out.println("张三要跟李四结婚了"); }
}
//代理对象
class WeddingCompany implements Marry{
    //代理对象要代理的真实对象
    private Marry target;

    public WeddingCompany(Marry target) { this.target = target; }

    @Override
    public void getMarry() {
        marryBefore();
        this.target.getMarry();
        marryAfter();
    }

    private void marryBefore() { System.out.println("订酒店，摆宴席"); }

    private void marryAfter() { System.out.println("数礼金"); }
}

5.Lambda表达式

作用：1.避免匿名内部类使用过多，2.让代码更简洁
只适用于函数式接口
函数式接口：一个接口中只有一个抽象方法(可以用Lambda表达式来创建该类接口的对象)

public class Lambda_Test {
    //局部内部类
    static class FITtest implements FunctionItf{
        @Override
        public void lambda(int test) {
            System.out.println("局部内部类：lambda->>>" + test);
        }
    }

    public static void main(String[] args) {
        //调用局部内部类输出
        FITtest fiTtest = new FITtest();
        fiTtest.lambda(1);

        //匿名内部类
        FunctionItf functionItf = new FunctionItf() {
            @Override
            public void lambda(int test) {
                System.out.println("匿名内部类：lambda->>>" + test);
            }
        };
        functionItf.lambda(2);          //调用匿名内部类输出

        //Lambda表达式
        FunctionItf functionItf_lambda = (int test)->{
            System.out.println("lambda表达式：lambda->>>" + test);
        };
        functionItf_lambda.lambda(3);   //使用Lambda表达式输出

        //简化版的Lambda表达式
        functionItf_lambda = (test)->{
            System.out.println("简化的lambda表达式(去掉了类型)：lambda->>>" + test);
        };
        functionItf_lambda.lambda(4);   //使用简化的Lambda表达式输出

        //二次简化的Lambda表达式
        functionItf_lambda = test->{
            System.out.println("二次简化的lambda表达式(去掉了类型和()，有多个参数时得加括号)：lambda->>>" + test);
        };
        functionItf_lambda.lambda(5);   //使用二次简化的Lambda表达式输出

        //三次简化的Lambda表达式
        functionItf_lambda = test->System.out.println("三次简化的lambda表达式(去掉了类型、()、{}，使用于单行操作的)：lambda->>>" + test);
        functionItf_lambda.lambda(6);   //使用三次简化的Lambda表达式输出

        //四次简化的Lambda表达式
        functionItf_lambda.lambda(7);   //使用四次简化的Lambda表达式输出

    }
}

// 定义一个函数式接口
interface FunctionItf{
    void lambda(int test);
}