标签：java String void 笔记 prop new Java public 第七

案例：复制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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。