Java基础（七）——模拟斗地主、File、递归遍历目录、字节流读存数据

最新推荐文章于 2022-04-12 14:56:56 发布

空城机

最新推荐文章于 2022-04-12 14:56:56 发布

阅读量310

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_36171287/article/details/104754346

版权

Java 专栏收录该内容

25 篇文章 5 订阅

订阅专栏

模拟斗地主练习

需求:通过程序实现斗地主过程中的洗牌,发牌和看牌
思路:

①创建-个牌盒,也就是定义一个集合对象，用ArrayList集合实现
②往牌盒里面装牌
③洗牌，也就是把牌打撒，用Collections的shuffle(方法实现
④发牌,也就是遍历集合,给三个玩家发牌
⑤看牌，也就是三个玩家分别遍历自己的牌

代码：

package cn.itcast.day6.demo1;

import java.util.ArrayList;
import java.util.Collections;

public class DouDiZhu {
    public static void main(String[] args) {
        //创建一个牌盒，也就是定义一个集合对象，用Arraylist集合实现
        ArrayList<String> array = new ArrayList<String>();

        //往牌盒里面装牌
        /*
            ◆2,◆3,◆4...◆K,◆A
            ♣2,...
            ♠2....
            ♥2....
            小王，大王
        */
        //定义花色数组
        String[] colors = {"♦", "♣", "♠", "♥"};
        //定义点数数组
        String[] numbers = {"A", "2", "3", "4", "5", "6", "7", "8", "9","10", "J", "Q", "K"};
        for (String color : colors) {
            for (String number : numbers) {
                array.add(color + number);
            }
        }
        array.add("小王");
        array.add("大王");

        //洗牌
        Collections.shuffle(array);
//        System.out.println(array);
        //发牌，创建三个玩家集合，和底牌集合
        ArrayList<String> ccArray = new ArrayList<String>();
        ArrayList<String> lbArray = new ArrayList<String>();
        ArrayList<String> sqArray = new ArrayList<String>();
        ArrayList<String> dpArray = new ArrayList<String>();
        for(int i=0;i< array.size();i++){
            String poker = array.get(i);
            if(i>= (array.size()-3)){
                dpArray.add(poker);
            }else if(i%3 == 0){
                ccArray.add(poker);
            }else if(i%3 == 1){
                lbArray.add(poker);
            }else if(i%3 == 2){
                sqArray.add(poker);
            }
        }
        showPoker("曹操",ccArray);
        showPoker("刘备",lbArray);
        showPoker("孙权",sqArray);
        showPoker("底牌",dpArray);
    }
    //看牌方法  参数：人名，牌堆
    public static void showPoker(String name,ArrayList<String> array){
        Collections.sort(array);
        System.out.println(name+"的牌："+array);
    }
}

结果:

模拟斗地主升级版

需求:通过程序实现斗地主过程中的洗牌，发牌和看牌。要求:对牌进行排序
思路:

①创建HashMap,键是编号,值是牌
②创建ArrayList, 存储编号
③创建花色数组和点数数组
④从0开始往HashMap里面存储编号,并存储对应的牌。同时往ArrayList里面存储编号
⑤洗牌(洗的是编号),用Collections的shuffle0方法实现
⑥发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
⑦定义方法看牌(遍历TreeSet集合,获取编号，到HashMap集合找对应的牌)
⑧调用看牌方法

代码：

package cn.itcast.day6.demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class DouDiZhu {
    public static void main(String[] args) {
        //创建HashMap,键是编号,值是牌
        HashMap<Integer,String> array = new HashMap<Integer,String>();
        //创建ArrayList, 存储编号
        ArrayList<Integer> nums = new ArrayList<Integer>();

        //定义花色数组
        String[] colors = {"♦", "♣", "♠", "♥"};
        //定义点数数组
        String[] numbers = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10","J", "Q", "K"};
        //从0开始往HashMap里面存储编号,并存储对应的牌。同时往ArrayList里面存储编号
        int index = 0;
        for (String n : numbers) {
            for (String color : colors) {
                array.put(index,color+n);
                nums.add(index);
                index++;
            }
        }
        array.put(index,"小王");
        nums.add(index);
        index++;
        array.put(index,"大王");
        nums.add(index);
//        System.out.println(array);
        //洗牌(洗的是编号),用Collections的shuffle0方法实现
        Collections.shuffle(nums);
//        System.out.println(array);
        //发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)，创建三个玩家集合，和底牌集合
        TreeSet<Integer> ccArray = new TreeSet<Integer>();
        TreeSet<Integer> lbArray = new TreeSet<Integer>();
        TreeSet<Integer> sqArray = new TreeSet<Integer>();
        TreeSet<Integer> dpArray = new TreeSet<Integer>();
        for(int i=0;i< nums.size();i++){
            Integer pokerIndex = nums.get(i);
            if(i>= (array.size()-3)){
                dpArray.add(pokerIndex);
            }else if(i%3 == 0){
                ccArray.add(pokerIndex);
            }else if(i%3 == 1){
                lbArray.add(pokerIndex);
            }else if(i%3 == 2){
                sqArray.add(pokerIndex);
            }
        }
//        System.out.println(ccArray);
        showPoker("曹操",ccArray,array);
        showPoker("孙权",sqArray,array);
        showPoker("刘备",lbArray,array);
        showPoker("底牌",dpArray,array);
    }
    //定义方法看牌(遍历TreeSet集合,获取编号，到HashMap集合找对应的牌)
    public static void showPoker(String name,TreeSet<Integer> ts,HashMap<Integer,String> array){
        System.out.print(name+"的牌：[");
        for(Integer key:ts){
            String poker = array.get(key);
            System.out.print(poker+" ");
        }
        System.out.println("]");
    }
}

结果：

File

public class File
extends Object
implements Serializable, Comparable<File>

文件和目录路径名的抽象表示。

用户界面和操作系统使用依赖于系统的路径名字符串命名文件和目录。这个类提供了一个抽象的，独立于系统的层次化路径名的视图。 抽象路径名有两个组件：

可选系统有关的前缀字符串，如磁盘驱动器符， "/"为UNIX根目录，或"\\\\"的Microsoft Windows UNC路径，并
零个或多个字符串名称的序列。

抽象路径名中的第一个名称可能是目录名称，或者在Microsoft Windows UNC路径名的情况下是主机名。抽象路径名中的每个后续名称表示一个目录; 姓氏可以表示目录或文件。空的抽象路径名没有前缀和空名称序列。

File：它是文件和目录路径名的抽象表示

文件和目录是可以通过File封装成对象的
对于File而言，其封装的并不是一个真正存在的文件, 仅仅是一个路径名而已。它可以是存在的,也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

方法名	说明
File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的File实例
File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的File实例

例子：File的简单描述和构造方法

import java.io.File;

public class FileDemo {
    public static void main(String[] args) {
        //File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
        File f1 = new File("D:\\eclipse\\API文档\\File.txt");
        System.out.println(f1);

        //File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的File实例
        File f2 = new File("D:\\eclipse\\API文档","File.txt");
        System.out.println(f2);

        //File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的File实例
        File f3 = new File("D:\\eclipse\\API文档");
        File f4 = new File(f3,"File.txt");
        System.out.println(f4);
    }
}

结果：

File类创建功能:

public boolean createNewFile(): 当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
- 如果文件不存在，就创建文件，并返回true
- 如果文件存在，就不创建文件，并返回false
public boolean mkdir():创建由此抽象路径名命名的目录
- 如果目录不存在，就创建文件，并返回true
- 如果目录存在，就不创建文件，并返回false
public boolean mkdirs(): 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

public class FileDemo {
    public static void main(String[] args) throws IOException {
        //需求1:我要在E:llitcast目录下创建一个文件File.txt
        File f1 = new File("D:\\eclipse\\API文档\\File.txt");
        System.out.println(f1.createNewFile());
        System.out.println("-------");
        //需求2:我要在E:\litcast目录 下创建一个目录JavaSE
        File f2 = new File("D:\\eclipse\\API文档\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("-------");
        //需求3:我要在E:llitcast目录 下创建一个多级目录JavaWEB\ \HTML
        File f3 = new File("D:\\eclipse\\API文档\\JavaWEB\\HTML");
        //System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs());

    }
}

File类的判断和获取功能:

public boolean isDirectory(): 测试此抽象路径名表示的File是否为目录
public boolean isFile(): 测试此抽象路径名表示的File是否为文件
public boolean exists(): 测试此抽象路径名表示的File是否存在
public String getAbsolutePath(): 返回此抽象路径名的绝对路径名字符串
public String getPath(): 将此抽象路径名转换为路径名字符串
public String getName():返回由此抽象路径名表示的文件或目录的名称
public String[] list(): 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles(): 返回此抽象路径名表示的目录中的文件和目录的File对象数组

File类的删除功能

public boolean delete():删除由此抽象路径名表示的文件或目录

递归遍历目录

需求:给定一个路径(E:\itcast), 请通过递归完成遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台
思路:

①根据给定的路径创建一个File对象
②定义一个方法，用于获取给定目录下的所有内容,参数为第1步创建的File对象
③获取给定的File目录下所有的文件或者目录的File数组
④遍历该File数组，得到每一个File对象
⑤判断该File对象是否是目录
- 是:递归调用
- 不是:获取绝对路径输出在控制台
⑥调用方法

代码：

import java.io.File;
import java.io.IOException;

public class FileDemo {
    public static void main(String[] args) throws IOException {
        //根据给定的路径创建一 个File对象
        File srcFile = new File("D:\\eclipse\\API文档");
        //调用方法
        getFilePath(srcFile);
    }
    //定义一个方法，用于获取给定目录下的所有内容,参数为第1步创建的File对象
    public static void getFilePath(File srcFile){
        //获取给定的File目录下所有的文件或者目录的File数组
        File[] files = srcFile.listFiles();
        //遍历该File数组，得到每一个File对象
        if(files != null){
            for(File i:files){
                //判断该File对象是否是目录
                if(i.isDirectory()){
                    //是:递归调用
                    getFilePath(i);
                }else {
                    //不是:获取绝对路径输出在控制台
                    System.out.println(i.getAbsolutePath());
                }
            }
        }

    }
}

结果：

字节流

字节流读数据

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ZiJie {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\eclipse\\API文档\\File.txt");
        //调用字节输入流对象的读数据方法
        //int read (byte[] b): 从该输入流读取最多b. length个字节的数据到一个字节数组
        byte[] bys = new byte[1024];
        //第一次读取数据
        int len;
        while ((len=fis.read(bys))!=-1){
            System.out.println(len);
            System.out.println(new String(bys,0,len));
        }

        //释放资源
        fis.close();
    }
}

结果：

字节缓冲流

public class BufferedOutputStream
extends FilterOutputStream

该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。

public class BufferedInputStream
extends FilterInputStream

A BufferedInputStream为另一个输入流添加了功能，即缓冲输入和支持mark和reset方法的功能。当创建BufferedInputStream时，将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次有多个字节。 mark操作会记住输入流中的一点，并且reset操作会导致从最近的mark操作之后读取的所有字节在从包含的输入流中取出新的字节之前重新读取。

字节缓冲流:

BufferOutputStream: 该类实现缓冲输出流。通过设置这样的输出流,应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，- 次很多字节

构造方法:

字节缓冲输出流: BufferedOutputStream(OutputStream out)
字节缓冲输入流: BufferedInputStream(InputStreamin)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢?

字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

例子：

public class ZiJie {
    public static void main(String[] args) throws IOException {
        /*//字节缓冲输出流: BufferedOutputStream(OutputStream out)
        FileOutputStream fos = new FileOutputStream("D:\\eclipse\\API文档\\File.txt",true);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //写数据
        bos.write("什么事情\r\n".getBytes());
        bos.write("hi\r\n".getBytes());
        bos.close();
        fos.close();*/

        //字节缓冲输入流: BufferedInputStream(InputStreamin) 
//        InputStreamReader reader = new InputStreamReader(new FileInputStream("D:\\eclipse\\API文档\\File.txt"),"utf-8");
//        BufferedReader bis = new BufferedReader(reader);
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\eclipse\\API文档\\File.txt"));
        //一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1){
//            System.out.print((char)by);
//        }
        //一次读取一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            System.out.print(new String(bys,0,len));
        }
        bis.close();
    }
}

结果：

字节流复制视频

思路:

1：根据数据源创建字节输入流对象
2:根据目的地创建字节输出流对象
3:读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
4:释放资源

四种方式实现复制视频，并记录每种方式复制视频的时间

1:基本字节流一次读写一个字节 --- 最慢
2:基本字节流一次读写一个字节数组
3:字节缓冲流一次读写一个字节
4:字节缓冲流一次读写一个字节数组 ---- 最快

代码：

public class ZiJie {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();
        //复制视频
        method1();
        method2();
        method3();
        method4();
        
        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时: " + (endTime - startTime) + "毫秒");
    }

    //基本字节流一次读写一个字节
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节 流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\\字节 流复制图片.avi");
        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
    //基本字节流一次读写一个字节数组
    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节 流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\\字节 流复制图片.avi");
        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys,0,len);
        }
        fos.close();
        fis.close();
    }
    //字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节 流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("myByteStream\\字节 流复制图片.avi"));
        int by;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        bis.close();
        bos.close();
    }
    //字节缓冲流一次读写一个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节 流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("myByteStream\\字节 流复制图片.avi"));
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}

一起学习，一起进步 -.- ，如有错误，可以发评论

空城机

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java基础（七）——模拟斗地主、File、递归遍历目录、字节流读存数据

模拟斗地主练习需求:通过程序实现斗地主过程中的洗牌,发牌和看牌思路:①创建-个牌盒,也就是定义一个集合对象，用ArrayList集合实现 ②往牌盒里面装牌 ③洗牌，也就是把牌打撒，用Collections的shuffle(方法实现 ④发牌,也就是遍历集合,给三个玩家发牌 ⑤看牌，也就是三个玩家分别遍历自己的牌代码：package cn.itcast.day6.dem...
复制链接

扫一扫