Java实战项目演示代码及流的使用

project

准备牌->洗牌->发牌

java 复制代码

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

public class PokerGameplus {
    static HashMap<Integer,String> hs = new HashMap<>();
    static ArrayList<Integer> list = new ArrayList<>();
    static {
        //准备牌
        //"3","4","5","6","7","8","9","10","J","Q","K","A","2"
        //"梅花","方片","红桃","黑桃"
        String[] color = {"梅花","方片","红桃","黑桃"};
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //牌盒
        int seriaNum = 1;
        for (String n : number) {
            //依次表示每个数字
            for (String c : color) {
                //依次表示每个花色
                hs.put(seriaNum,c + n);
                list.add(seriaNum);
                seriaNum++;
            }
        }
        hs.put(seriaNum,"小王");
        list.add(seriaNum);
        seriaNum++;
        hs.put(seriaNum,"大王");
        list.add(seriaNum);
    }
    PokerGameplus(){
        //洗牌
        Collections.shuffle(list);
        //发牌
        TreeSet<Integer> lord = new TreeSet<>();
        TreeSet<Integer> p1 = new TreeSet<>();
        TreeSet<Integer> p2 = new TreeSet<>();
        TreeSet<Integer> p3 = new TreeSet<>();
        for(int i = 0;i<list.size();i++){
            if (i<=2){
                lord.add(list.get(i));
                continue;
            } else if (i%3==0) {
                p1.add(list.get(i));
            } else if (i%3==1) {
                p2.add(list.get(i));
            } else if (i%3==2) {
                p3.add(list.get(i));
            }

        }
        lookpoker("底牌",lord);
        lookpoker("玩家1",p1);
        lookpoker("玩家2",p2);
        lookpoker("玩家3",p3);
    }
    public void lookpoker(String name,TreeSet<Integer> ts){
        System.out.println(name+"的牌是：");
        for (int seriaNum : ts) {
            String poker = hs.get(seriaNum);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

java 复制代码

public class APP {
    public static void main(String[] args) {
        //准备牌->洗牌->发牌->看牌
        new PokerGameplus();
    }
}

stream 流的中间方法

stream 流的终结方法

方法引用

this and super 只能用在非静态方法当中

异常就是程序代码出现问题

捕获异常

抛出处理

文件File的概述和构造方法

创建、删除

createnewfile此方法创建一个新的空的文件夹

创建成功，返回值为true，表示此文件没有创建过

重点一定是一个文件，如果创建路径不含后缀名，则创建一个没有后缀名的文件名

此代码的格式输入

File f1 = new File(文件路径)；

boolean b = f1.mkdir();

System.out.println(b);

false表示创建失败，windows中路径是唯一的，如果当前路径已存在，则创建失败，返回false

mkdir只能创建单极文件夹，而mkdirs可以创建多级文件夹，mkdirs也可以创建单极文件夹
删除文件、空文件夹

delete方法（不走回收站）输出格式

//创建删除对象

File f1 = new File(文件路径);

//删除

boolean b = f1.delete();

//打印结果

System.out.println(b);

//返回true or false

细节1：如果删除的是文件，则直接删除，不走回收站

如果删除的是空文件夹，则直接删除，不走回收站

如果删除的是有内容的文件夹、则删除失败

File中常见成员方法获取并遍历

ListFiles输出格式

//1.创建File对象

File f = new File(文件路径);

//2.ListFiles方法

//作用：获取当前文件路径下的，所有内容，把所有的内容放到数组中返回

File[] files = f.ListFiles();

for(File file : files){

//file代指当前文件路径下的每一个文件或者文件夹

System.out.println(file);

}

重点细节：

当调用者File表示的路径不存在时，返回null

当调用者File表示的路径是文件时，返回null

当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组

当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和路径放在File数组中返回

当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹放在File数组中返回，包含隐藏文件

当调用者File表示的路径是需要权限才能访问的文件夹时，返回null

ListRoots()方法获取系统中的所有盘符

输出格式

File[] arr = File.listRoots();

System.out.println(Arrays.to.String(arr));

偶尔会用ListRoots方法

list()方法获取当前路径下的所有内容（仅仅能获取名字）

list方法输出格式

File f1 = new File(文件路径);

String[] arr2 = f1.list();

for(String s : arr2){

System.out.println(s);

}

list(FilenameFilter fliter) 利用文件名过滤器获取当前路径下所有内容

accept方法的形参，依次表示aaa文件夹里面每一个文件或者文件夹的路径

//参数1：父级路径

//参数2: 子级路径

//返回值：如果返回值为false，就表示当前路径舍弃不要

如果返回值为true，就表示当前路径保留

list(FilenameFilter fliter)输出格式

File f1 = new File(文件路径);

File f2 = new File(过滤文件或存留文件的文件路径);

String[] arr3 = f2. list(new FilenameFilter){

@Overriade

public boolean accept(File dir,String name){

return false; // 过滤此文件，不保留

//return true;//保留此文件，保留下来

}

});

System.out.println(Arrays.toString(arr3));

listfiles方法为主要掌握方法，主要作为文件名过滤器的方法

dir表示父级路径

name表示子级路径
IO流

IO流表示存储和读取数据的解决方案

存档，保存到文件当中，加载数据

File表示系统中的文件或文件夹的路径

input读
IO流的分类

纯文本文件用windows记事本可以自动打开的文件

并且能读的懂的文件

word非纯文本文件

字节输出流FileOutputStream

实现需求：写一段文字到本地文件当中（暂时不写中文）

实现步骤：

创建对象

写出数据

释放资源

//1.创建对象

//写出输出流 OutputStream

//本地文件 File

FileOutputStream fos = new FileOutputStream("name指定文件路径");

必须要alt+enter实现throw做抛出处理

//2.写出数据

fos.write(sth);

//3.释放资源

fos.close();

必须要alt+enter实现throw做抛出处理

字节输出流对象

细节1：参数是字符串或者是File对象都是可以的

细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的

细节3：如果文件存在，则会创建清空文件

写数据

write方法的参数是整数，但是实际上写到本地文件中是整数在ASCII上对应的字符

释放资源

每次使用完成都必须释放资源

个人理解为PPT or WORD 使用完之后必须关闭释放栈内存

FileOutputStream写数据的3种方式

void write(int b) 一次字节数据

void write(byte[] b)一次写一个字节数组

//创建对象

FileOutputStream fos = new FileOutputStream(本地文件路径);

//写出数据

byte[] bytes = {12,37,32,10,80};

fos.write(bytes);

//释放资源

fos.close();

void

void write(byte[] b, int off,int len)一次写一个字节数组的部分数据

此方法有三个参数

参数1：数组

参数2：起始索引

参数3：个数

//创建对象

FileOutputStream fos = new FileOutputStream(本地文件路径);

//写出数据

byte[] bytes = {12,37,32,10,80};

fos.write(bytes,off:1,len:2);

//写入的数据为 37 32
换行写

//创建对象

FileOutputStream fos = new FileOutputStream(本地文件路径);

//写出数据

String str = "abc";

byte[] bytes1= str.getbytes();

fos.write(bytes1);

复制代码

      String wrap = "/r/n";
      byte[] bytes2 = wrap.getbytes();
      fos.write(bytes2);
 
      String arr = "666";
      byte[] bytes3 = arr.getbytes();
      fos.write(bytes3);
     //释放资源
     fos.close();
   **ctrl+alt+V自动补充前面的开头代码
   /r/n换行写**
   **续写**
   FileOutputStream fos = new FileOutputStream(本地文件路径，true);//true表示打开续写开关

//创建对象

FileInputStream fis = new FileInputStream();

//读取数据

int b1 = fis.read();

System.out.println(b1);

//释放资源

fis.close();

强转可以用char

创建输入流对象：

细节：如果文件不存在，就直接报错

写数据：

细节：一次读一个字节的数据是在ASCII上所对应的数据

如果读到文件末尾了，read方法返回-1

释放资源：每次·1使用完流之后必须把资源释放掉

FileInputStream的循环读取

字节输入流中的循环读取

//创建对象

FileInputStream fis = new FileInputStream();

//循环读取

int b;

while( (b = fis.read()) != -1){

System.out.println(char(b))//print可以打印成一行，println打印一个换一行

}

//释放资源

fis.close();

read方法读取一次移动一次指针
文件拷贝

FileInputStream fis = new FileInputStream();

FileOutputStream fos = new FileOutputStream(本地文件路径);

int b;

while( (b = fis.read()) != -1){

fos.write(b);

}

//释放资源

//规则：先开的流后关闭

fos.close();

fis.close();

FileInputStream的读取问题

FileInputStream一次只能读取一个字节

弊端：一次只读了一个字节public int read（byte[] buffer）

一次读取多个字节

演示代码

//创建对象

FileInputStream fis = new FileInputStream(文件路径name:);

//读取数据

byte[] bytes = new byte[2];

int len = fis.read(bytes);

String str = new String(bytes);

System.out.println(str);

//释放资源

fis.close();

把数据c用e覆盖后，打印ed，接下来无法读出数据，所以打印ed数据

加上0和len，加上覆盖范围
多线程&JUC

线程是操作系统能够进行运算调度的最小单位，它被包含在进程当中

单线程程序，从上往下运行

多线程程序，提高运行效率

并发和并行

并发：在同一时刻，有多个指令在单个CPU上交替执行

并行：在同一时刻，有多个指令在单个CPU上同时执行

并发和并行可能在同时存在
多线程的实现方式

多线程的第一种启动方式继承Thread

My Thread

public void run() {

//书写线程需要的代码

...

}

public static void main(String[] args){

//多线程的第一种启动方式

//1.自己定义一个类继承Thread

//2.重写run方法

//3.创建子类对象,并启动线程

MyThread t1 = new MyTread();

t1.start();

}

start()方法才是用来开启多线程的正确调用

如果加上t2并书名getName就可以实现交替运行

多线程的第二种实现方式

pubic class MyThread2{

public static void main(String[] args){

多线程的第二种实现方式

1.自己定义一个类实现Runable接口

2.重写里面的run方法

3.创建自己的类的对象

4.创建一个Thread类，并开启线程
/
//创建Myrun对象
//表示多线程的执行任务
Myrun mr = new Myrun();
//创建线程对象
MyThread2 T1 = new MyThread(mr);
//开启线程
T1.start();
//给线程设置Name
T1.setName("线程1");
}
}
public class Myrun implements Runable{
@override
public void run() {
//书写线程所需要的代码
...
}
}
注意Thread.currentThread()表示当前线程
多线程的第三种实现方式
pubic class MyThread3{
public static void main(String[] args){
/

多线程的第三种实现方式

特点：获取多线程的运行结Callable接口

2.重写call（是有返回值的，表示多线程运行的结果）

3.创建MyCallable的对象（表示多线程要执行的任务）

4.创建FutureTask的对象（管理多线程的运行结果）

5.创建Thread类的对象，并启动（表示线程）

**/

MyCallable mc = new MyCallable();

FutureTask ft = new FutureTask(mc);

Thread t1 = new Thread(ft);

t1.start();

Integer result = ft.get();

System.out.println(result);

}}

public class MyCallable implements Callable{

@override

public Integer call() throws Exception{

//开启线程

多线程所要执行的代码

return null

}

}
Thread常见的成员方法