编程语言
首页 > 编程语言> > Java笔记第七弹

Java笔记第七弹

作者：互联网

案例：复制Java文件（打印流改进版）
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));

        PrintWriter pw=new PrintWriter(new FileWriter("myOtherStream\\Copy.java"),true);//可以自动更新
        
        String line;
        while((line=br.readLine())!=null){
           pw.println(line);
        }

        pw.close();
        br.close();
    }
}
对象序列化流
ObjectOutputStream//将Java对象的原始数据类型和图形写入OutputStream，可以使用ObjectOutputStream读取对象
    //构造方法
    ObjectOutputStream(OutputStream out);
//序列化对象的方法
void writeObject(Object obj);//将指定的对象写入ObjectOutputStream
//类的序列化由实现java.io.Serializable接口的类启用，不实现此接口将不会使任何状态序列化或反序列化
//实现该接口，不需要重写任何方法
相关应用：
//Main.java
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));

        Student s=new Student("lili",18);

        oos.writeObject(s);

        oos.close();
    }
}
//Student.java
import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;
    private int yuwen;
    private int math;
    private String id;
    public Student(){}
    public Student(String name, int age){
    this.name=name;
    this.age=age;
    }
    public Student(String name,int yuwen,int math){
        this.name=name;
        this.yuwen=yuwen;
        this.math=math;
    }
    public Student(String id,String name){
        this.id=id;
        this.name=name;
    }
     public void setName(String name){
        this.name=name;
     }

     public String getName(){
        return name;
     }

     public void setAge(int age){
        this.age=age;
     }

     public int getAge(){
        return age;
     }

     public void setYuwen(int yuwen){
        this.yuwen=yuwen;
     }

     public int getYuwen(){
        return yuwen;
     }

     public void setMath(int math){
        this.math=math;
     }

     public int getMath(){
        return math;
     }
     public void setId(String id){
        this.id=id;
     }
     public String getId(){
        return id;
     }


}
相关问题：
//类的串行版本与从流中读取的类描述符的类型不匹配
//该类包含未知的数据类型
//该类没有可访问的无参数构造函数

//解决方法--在Student.java里面添加:
private static final long serialVersionUID=42L;

//如果一个对象中的某个成员值不想被序列化，如何解决？

//解决方法：
//在对象所属的类中，将成员变量用transient修饰
对象反序列化流
ObjectInputStream
    //构造方法
    ObjectInputStream(InputStream in);
//反序列化对象的方法
ObjectreadObject();//读取
相关应用：
//Main.java
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
        
        Object obj=ois.readObject();
        
        Student s=(Student) obj;

        System.out.println(s.getName()+","+s.getAge());
        
        ois.close();
    }
}
//Student.java已省略

Properties

是一个Map体系的集合类

可以保存到流中或从流中加载

练习：Properties作为Map集合的使用
import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Properties prop=new Properties();

        prop.put("1001","lili");
        prop.put("1002","wangwu");
        prop.put("1003","lisi");

        Set<Object> keySet=prop.keySet();

        for(Object key:keySet){
           Object value= prop.get(key);
            System.out.println(key+","+value);
        }

    }
}
特有方法：
Object setProperty(String key,String value);//设置集合的键和值，都是String类型，底层调用Hashtable方法put
String getProperty(String key);//使用此属性列表中指定的键搜索属性
Set<String> stringPropertyNames();//从该属性列表返回一个不可修改的键集，其中键及其对应的值是字符串
相关应用：
import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Properties prop=new Properties();

        prop.setProperty("1001","lili");
        prop.setProperty("1002", "wangwu");
        prop.setProperty("1003","lisi");

        System.out.println(prop.getProperty("1001"));//lili
        System.out.println(prop.getProperty("0006"));//null

        Set<String> names=prop.stringPropertyNames();
        for(String key:names){
           String value=prop.getProperty(key);
            System.out.println(key+","+value);
        }
    }
}
与IO流结合的方法：
void load(InputStream inStream);//从输入字节流读取属性列表
void load(Reader reader);//从输入字节流读取属性列表*******
void store(OutputStream out,String comments);
void store(Writer writer,String comments);//*******
相关应用：
//将集合中的数据保存到文件
import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        myStore();
    }
    
    private static void myStore() throws IOException {
        Properties prop=new Properties();
        
        prop.setProperty("1001","lili");
        prop.setProperty("1002","wangwu");
        prop.setProperty("1003","lisi");
        
        FileWriter fw=new FileWriter("myOtherStream\\fw.txt");
        
        prop.store(fw,null);
        fw.close();
    }
}

//将文件中的数据加载到集合
import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        
        myLoad();
    }
    
    private static void myLoad() throws IOException {
        Properties prop=new Properties();
        
        FileReader fr=new FileReader("myOtherStream\\fw.txt");
        
        prop.load(fr);
        fr.close();

        System.out.println(prop);
    }
}
案例：游戏次数
//Main.java
import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Properties prop=new Properties();
        
        FileReader fr=new FileReader("myOtherStream\\game.txt");
        
        String count=prop.getProperty("count");
        int i=Integer.parseInt(count);
        
        if(i>=3){
            System.out.println("游戏试玩已结束，想玩请充值www.itcast.cn");
        }else{
            GuessNumber.start();
            i++;
            prop.setProperty("count",String.valueOf(i));
            FileWriter fw=new FileWriter("myOtherStream\\game.txt");
            prop.store(fw,null);
            fw.close();
        }
    }
}
//GuessNumber.java已经省略

实现多线程

进程和线程

进程：正在运行的程序

线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则成为单线程程序

多线程：一个进程如果有多条执行路径，则成为单线程程序

多线程的实现方式
//创建一个新的执行线程
1、将一个类声明为一个Thread的子类，这个子类应该重写Thread类的方法run（继承Thread类）
    //相关应用：
    //Main.java
    import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        DateTest d1=new DateTest();

        DateTest d2=new DateTest();

        d1.start();
        d2,start();

    }
}

//DateTest.java
public class DateTest extends Main{

    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(i);
        }
    }
}

标签：java,String,void,笔记,prop,new,Java,public,第七
来源： https://www.cnblogs.com/liuzijin/p/16529330.html