20200804-1, JAVA-String, FileInputStream, FileOutputStream 2, juego Doudizhu.
Las reglas son las siguientes:
1. Hay tres jugadores, puede asignar nombres de jugadores desde la consola, los jugadores tendrán los atributos de la colección de cartas y si son propietarios
2. Las cartas tienen dos atributos: palos y puntos. Hay 4 tipos de palos: lado ciruela negro y rojo (enumeración disponible) puntos correspondientes a 13 más dos cartas de triunfo (enumeración disponible).
3. Gestión de naipes: se utiliza para generar 54 cartas en orden aleatorio (colección de cartas, 54 cartas permanecen sin cambios y se vuelven secuenciales), tratar con jugadores, generar propietarios aleatoriamente y dar las 3 cartas restantes a Propietario y mostrar las manos de tres jugadores. Al mismo tiempo, guarde la información de la tarjeta en el archivo
Reclamación:
1. Puede producir una colección de 54 tarjetas
2. Puede generar una colección aleatoria de 54 cartas o puede realizar la función de distribución aleatoria de cartas
3. Asigne el nombre de la clase de jugador y los tres objetos de jugador.
4. Capaz de generar propietarios aleatoriamente y asignar un juego de cartas a tres jugadores (
5. Darse cuenta de guardar los resultados de la colección en un archivo
Sugerencia: las clases de enumeración pueden tener propiedades y constructores comunes, y los objetos de enumeración pueden ser objetos constructores.
1. Notas de clase:
String
es un tipo final y no se puede heredar. La capa inferior es una constante de matriz de tipo char y no se puede cambiar
. El proceso de reasignación de un objeto String es en realidad un proceso de creación de un nuevo objeto.
Si necesita asignar valores a los objetos String con frecuencia, no se recomienda utilizar String
thread safety: synchronized Asegure el aislamiento entre subprocesos.
Cadena: no se puede cambiar y es seguro en el verdadero sentido. En el caso de empalmes frecuentes de cadenas, la velocidad es muy lenta.
StringBuffer: Thread-safe
StringBuilder: Thread-unsafe
Ruta absoluta y ruta relativa: la ruta absoluta generalmente comienza desde el directorio raíz y la ruta completa
está escrita, la ruta relativa generalmente comienza desde el directorio del proyecto.
FileInputStream lee el proceso de archivo:
1. Objeto FileInputStream y declaración de objeto String
2. Crear objeto fileInputStream (ruta de archivo y objeto File)
3. Leer un solo byte o la lectura completa en la matriz de bytes
4. Convertir a cadena
5. Cerrar flujo FileInputStream
6. Devolver resultados
Proceso de archivo de escritura FileOutputStream:
1. Ruta del archivo de carga del objeto de archivo
2. Determine si el directorio principal del archivo existe, créelo si no existe
3. Declare el objeto FileOutputSteam
4. Cree el objeto fileOutputStream (objeto de archivo, si desea agregarlo)
5. Escriba el archivo La cadena se convierte en una matriz de bytes y se escribe en el flujo de salida
6. Cierre el flujo FileOutputSream
2. El juego del propietario
Clase de jugador:
package homework2;
import java.util.ArrayList;
/*
* @ClassName: Player
* project name: 20200802-homework
* @Description:
*/
public class Player {
public String name;
public ArrayList<String> list = new ArrayList();
public ArrayList<String> getList() {
return list;
}
public void setList(ArrayList<String> list) {
this.list = list;
}
public Player() {
}
public Player(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String nameOfDiZhu(int i){
String j = String.valueOf(i);
return "player"+j+".txt";
}
}
clase de cartas:
package homework2;
import java.io.*;
import java.util.*;
/**
* @ClassName: Cards
* Date: 2020/8/2 21:44
* project name: 20200802-homework
* @Description:
*/
public class Cards {
// ArrayList<String> players = new ArrayList();
Player[] player = new Player[3]; //创建一个包含三个玩家的player对象
public void xiCard(){
Scanner input = new Scanner(System.in);
for (int i = 0; i < player.length; i++) {
System.out.println("请输入第"+(i+1)+"位玩家的姓名：");
player[i] = new Player(input.next());//以此循环输入每一轮三位玩家的姓名
writeFile("玩家姓名："+player[i].name+"\n", "D:/myDoc/"+player[i].nameOfDiZhu(i+1), true);
//再将玩家的姓名存入文件夹中
}
List<String> Card = new ArrayList(); //将54张牌存入Card集合中
String[] card = {
"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String[] color = {
"♠","♥","♣","♦"};
for (String cards : card){
//双重循环实现数字与花色的字符串叠加
for (String colors : color){
Card.add(colors + cards);
}
}
Card.add("小王"); //最后单独加入两张大小王
Card.add("大王");
Collections.shuffle(Card); //洗牌
for (int i = 0; i<Card.size()-3;i=i+3){
//依此给3位玩家发牌
player[0].getList().add(Card.get(i));
player[1].getList().add(Card.get(i+1));
player[2].getList().add(Card.get(i+2));
}
System.out.println("随机产生地主！");
int diZhu;
diZhu = (int)(Math.random()*3); //随机数，随机产生地主的编号
System.out.println("恭喜"+player[diZhu].name+"成为地主！获得三张底牌！");
writeFile("此轮是地主\n", "D:/myDoc/"+player[diZhu].nameOfDiZhu(diZhu+1), true);
//将地主信息存入文件夹中
for (int i = 51; i <54 ; i++) {
//再给产生的地主发放最后的三张底牌
player[diZhu ].getList().add(Card.get(i));
}
for (int i = 0; i <3 ; i++) {
//将三位玩家的牌存入文件夹中
for (Object j:player[i].getList()) {
writeFile(j+" ", "D:/myDoc/"+player[i].nameOfDiZhu(i+1), true);
} /*以-----------作为分割线，切分每一轮比赛，将每一轮比赛发放的牌存入数组中的一个元素，这样，指定都一轮比赛，即选定数组的下标，
以此来输入某一轮比赛玩家的手牌。其中文件夹的路径使用了字符串拼接，因为不同的玩家信息存入不同的文件夹，文件夹的名称不相同。
（在player中定义了文件夹名称的方法）
*/
writeFile("\n--------------------\n", "D:/myDoc/"+player[i].nameOfDiZhu(i+1), true);
}
int i =0;
Scanner sc = new Scanner(System.in);
System.out.println("请输入您想展示第几次手牌？");
i = sc.nextInt();
System.out.println(readByOne("D:/myDoc/player1.txt",i));
System.out.println(readByOne("D:/myDoc/player2.txt",i));
System.out.println(readByOne("D:/myDoc/player3.txt",i));
}
public static void writeFile(String str,String path,boolean isAppend){
File f = new File(path);
if (!f.getParentFile().exists()) {
f.getParentFile().mkdir();
}
FileOutputStream fos = null;
try {
fos = new FileOutputStream(f,isAppend);
byte[] b=str.getBytes();
fos.write(b);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public String readByOne(String path, int i) {
FileInputStream fis = null;
String str = null;
String print = null;
String[] printword =new String[100];
try {
fis = new FileInputStream(path);
StringBuffer sb = new StringBuffer();
byte[] b = new byte[fis.available()]; //创建byte类型数据流数组
fis.read( b); //是读取文件里的字符串，然后给byte类型的数组b赋值，读取文件里的字符串放入b数组缓冲区内。
str = new String(b);
printword = str.split("\n--------------------\n");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return printword[i-1];
}
}
Categoría de prueba:
package homework2;
/**
* @ClassName: TestCards
* Date: 2020/8/2 21:44
* project name: 20200802-homework
* @Description:
*/
public class TestCards {
public static void main(String[] args) {
Cards cards = new Cards();
cards.xiCard();
}
}
resultado:
