java学习笔记9

作者: 海洋_5ad4 | 来源:发表于2018-11-18 21:56 被阅读0次

序列流

1.什么是序列流
- 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
2.使用方式
- 整合两个: SequenceInputStream(InputStream, InputStream)
- 整合多个: SequenceInputStream(Enumeration)

package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class Demo1_SequenceInputStream {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileInputStream fis2 = new FileInputStream("b.txt");
        FileInputStream fis3 = new FileInputStream("c.txt");
        
        Vector<FileInputStream> v = new Vector<>();     //创建集合对象
        v.add(fis1);                                    //将流对象存储进来
        v.add(fis2);
        v.add(fis3);
        
        Enumeration<FileInputStream> en = v.elements();
        SequenceInputStream sis = new SequenceInputStream(en);  //将枚举中的输入流整合成一个
        FileOutputStream fos = new FileOutputStream("d.txt");
        
        int b;
        while((b = sis.read()) != -1) {
            fos.write(b);
        }
        
        sis.close();
        fos.close();
    }

    public static void demo2() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileInputStream fis2 = new FileInputStream("b.txt");
        SequenceInputStream sis = new SequenceInputStream(fis1, fis2);
        FileOutputStream fos = new FileOutputStream("c.txt");
        
        int b;
        while((b = sis.read()) != -1) {
            fos.write(b);
        }
        
        sis.close();        //sis在关闭的时候，会将构造方法中传入的流对象也都关闭
        fos.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");//创建字节输入流关联a.txt
        FileOutputStream fos = new FileOutputStream("c.txt");   //创建字节输出流关联c.txt
        //是创建字节输出流关联文件的时候将文件内容清空
        int b1;
        while((b1 = fis1.read()) != -1) {
            fos.write(b1);
        }
        fis1.close();
        
        FileInputStream fis2 = new FileInputStream("b.txt");
        int b2;
        while((b2 = fis2.read()) != -1) {
            fos.write(b2);
        }
        
        fis2.close();
        fos.close();
    }

}

内存输出流

package com.heima.otherio;

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

public class Demo2_ByteArrayOutputStream {

    /**
     * ByteArrayOutputStream内存输出流
     * FileInputStream读取中文的时候出现了乱码
     * 解决方案
     * 1，字符流读取
     * 2，ByteArrayOutputStream
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("e.txt");
        ByteArrayOutputStream baos = new ByteArrayOutputStream();   //在内存中创建了可以增长的内存数组
        
        int b;
        while((b = fis.read()) != -1) {
            baos.write(b);      //将读取到的数据逐个写到内存中(内存数组)
        }
        
        /*byte[] arr = baos.toByteArray();      //将缓冲区的数据全部获取出来，并赋值给arr数组
        System.out.println(new String(arr));*/
        
        System.out.println(baos.toString());    //将缓冲区的内容转换为了字符串
        fis.close();                            //toString方法可以省略，打印的时候会自动调用
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("e.txt");
        byte[] arr = new byte[3];
        int len;
        while((len = fis.read(arr)) != -1) {
            System.out.println(new String(arr, 0, len));
        }
        
        fis.close();
    }

}

内存输出流之黑马面试题

package com.heima.test;

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

public class Test1 {

    /**
     * @param args
     * 定义一个文件输入流，调用read(byte[] b)方法，将a.txt文件中的内容打印出来（byte数组大小限制为5）
     * 分析：
     * 1，read(byte[] b)是字节输入流的方法，创建FileInputStream,关联a.txt
     * 2,创建内存输出流，将读到的数据写到内存输出流中
     * 3，创建字节数组，长度为5
     * 4，将内存输出流的数据全部转换为字符串打印
     * 5，关闭输入流
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //1，read(byte[] b)是字节输入流的方法，创建FileInputStream,关联a.txt
        FileInputStream fis = new FileInputStream("a.txt");
        //2,创建内存输出流，将读到的数据写到内存输出流中
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //3,创建字节数组，长度为5
        byte[] arr = new byte[5];
        int len;
        
        while((len = fis.read(arr)) != -1) {
            baos.write(arr, 0, len);
        }
        //4，将内存输出流的数据全部转换为字符串打印
        System.out.println(baos);       //即使没有调用，底层也会默认帮我们toString()方法
        //5，关闭输入流
        fis.close();
    }

}

随机访问流概述和读写数据

A:随机访问流概述
- RandomAccessFile概述
- RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
- 支持对随机访问文件的读取和写入。
B:read(),write(),seek()

package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Demo8_RandomAccessFile {

    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("g.txt", "rw");
        //raf.write(97); //写
        //int x = raf.read(); //读
        //System.out.println(x);
        raf.seek(10);       //在指定位置设置指针，初始值为0
        raf.write(98);
        raf.close();
    }

}

对象操作流ObjecOutputStream

1.什么是对象操作流
* 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.

2.使用方式
- 写出: new ObjectOutputStream(OutputStream), writeObject()
  注意：该对象必须实现Serializable接口，表示这个类可以序列化

package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

import com.heima.bean.Person;

public class Demo3_ObjectOutputStream {

    public static void main(String[] args) throws FileNotFoundException, IOException {
        Person p1 = new Person("张三", 23);
        Person p2 = new Person("李四", 24);
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
        oos.writeObject(p1);
        oos.writeObject(p2);
        
        oos.close();
    }

}

对象操作流ObjectInputStream

读取: new ObjectInputStream(InputStream), readObject()

package com.heima.otherio;

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

import com.heima.bean.Person;

public class Demo4_ObjectInputStream {

    /**
     * @param args
     * @throws IOException 
     * @throws FileNotFoundException 
     * @throws ClassNotFoundException 
     * 对象输入流，反序列化
     */
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        
        Person p1 = (Person) ois.readObject();
        Person p2 = (Person) ois.readObject();
        //Person p3 = (Person) ois.readObject();            //当文件读取到了末尾时出现EOFException
        
        System.out.println(p1);
        System.out.println(p2);
        
        ois.close();
    }

}

对象操作流优化

package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo3_ObjectOutputStream {

    public static void main(String[] args) throws FileNotFoundException, IOException {
        Person p1 = new Person("张三", 23);
        Person p2 = new Person("李四", 24);
        Person p3 = new Person("王五", 25);
        Person p4 = new Person("赵六", 26);
        
        ArrayList<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
        oos.writeObject(list);                  //把整个集合对象一次写出
        oos.close();
    }

    public static void demo1() throws IOException, FileNotFoundException {
        Person p1 = new Person("张三", 23);
        Person p2 = new Person("李四", 24);
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
        oos.writeObject(p1);
        oos.writeObject(p2);
        
        oos.close();
    }

}

package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo4_ObjectInputStream {

    /**
     * @param args
     * @throws IOException 
     * @throws FileNotFoundException 
     * @throws ClassNotFoundException 
     * 对象输入流，反序列化
     */
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        ArrayList<Person> list = (ArrayList<Person>) ois.readObject();  //将集合对象一次读取
        
        for (Person person : list) {
            System.out.println(person);
        }
        
        ois.close();
    }

    public static void demo1() throws IOException, FileNotFoundException,
            ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        
        Person p1 = (Person) ois.readObject();
        Person p2 = (Person) ois.readObject();
        //Person p3 = (Person) ois.readObject();            //当文件读取到了末尾时出现EOFException
        
        System.out.println(p1);
        System.out.println(p2);
        
        ois.close();
    }

}

加上id号

注意
* 要写出的对象必须实现Serializable接口才能被序列化
* 不用必须加id号

数据输入输出流

1.什么是数据输入输出流
- DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据
- 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.
2.使用方式
- DataOutputStream(OutputStream), writeInt(), writeLong()
- DataInputStream(InputStream), readInt(), readLong()

package com.heima.otherio;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo9_Data {

    /**
     * @param args
     * @throws IOException
     * 00000000 00000000 00000011 11100101 //int类型997的二进制
     * 11100101
     * 00000000 00000000 00000000 11100101 //int类型229的二进制
     */
    public static void main(String[] args) throws IOException {
        DataInputStream dis = new DataInputStream(new FileInputStream("h.txt"));
        int x = dis.readInt();
        int y = dis.readInt();
        int z = dis.readInt();
        
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
        
        dis.close();
    }

    public static void demo3() throws FileNotFoundException, IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("h.txt"));
        dos.writeInt(997);
        dos.writeInt(998);
        dos.writeInt(999);
        dos.close();
    }

    public static void demo2() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("h.txt");
        int x = fis.read();
        int y = fis.read();
        int z = fis.read();
        
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
        
        fis.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileOutputStream fos = new FileOutputStream("h.txt");
        fos.write(997); //按字节读取，997超过了一个字节的范围
        fos.write(998);
        fos.write(999);
        
        fos.close();
    }

}

打印流的概述和特点

1.什么是打印流
- 该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式
- System.out就是一个PrintStream, 其默认向控制台输出信息
2.使用方式
- 打印: print(), println()
- 自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)
- 打印流只操作数据目的

package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;

import com.heima.bean.Person;

public class Demo5_PrintStream {

    /**
     * @param args
     * @throws FileNotFoundException 
     * PrintStream和PrintWriter分别是打印的字节流和字符流
     * 只操作数据目的
     */
    public static void main(String[] args) throws FileNotFoundException {
        //PrintWriter pw = new PrintWriter("f.txt");
        PrintWriter pw = new PrintWriter(new FileOutputStream("f.txt"), true);
        pw.println(97);         //自动刷出功能只针对的是println方法
        pw.write(97);
        pw.print(97);
        //pw.close();
    }

    public static void demo1() {
        System.out.println("aaa");
        PrintStream ps = System.out;    //获取标注输出流
        ps.println(97);     //底层通过Integer.toString()将97转换成字符串并打印
        ps.write(97);       //查找码表,找到对应的a并打印
        
        Person p1 = new Person("张三",23);
        ps.println(p1);     //默认调用p1的toString方法
        
        Person p2 = null;   //打印引用数据类型，如果是null,就打印null,如果不是null就打印对象的toString方法
        ps.println(p2);
        ps.close();
    }

}

标准输入输出流概述和输出语句

1.什么是标准输入输出流(掌握)
- System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
- System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
2.修改标准输入输出流(了解)
- 修改输入流: System.setIn(InputStream)
- 修改输出流: System.setOut(PrintStream)

package com.heima.otherio;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

public class Demo6_SystemInOut {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("a.txt"));     //改变标准输入流
        System.setOut(new PrintStream("b.txt"));        //改变标准输出流
        
        InputStream is = System.in;     //获取标准的键盘输入流，默认指向键盘，改变后指向文件
        PrintStream ps = System.out;    //获取标准的输入流，默认指向的是控制台，改版后就指向文件
        
        int b;
        while((b = is.read()) != -1) {
            ps.write(b);
        }
        //System.out.println(); //也是一个标准输出流，不用关，因为i没有和硬盘上的文件产生关联的管道
        is.close();
        ps.close();
    }

    public static void demo1() throws IOException {
        InputStream is = System.in;
        int x = is.read();
        System.out.println(x);
        
        is.close();
        
        InputStream is2 = System.in;    //Stream closed，输入流只有一个
        int y = is2.read();
        System.out.println(y);
    }

}

修改标准输入输出流拷贝图片

package com.heima.test;

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

public class Test2 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("双元.jpg"));    //改变标准输入流
        System.setOut(new PrintStream("copy.jpg"));     //改变标准输出流
        
        InputStream is = System.in;
        PrintStream ps = System.out;
        
        byte[] arr = new byte[1024];
        int len;
        
        while((len = is.read(arr)) != -1) {
            ps.write(arr, 0, len);
        }
    }

}

两种方式实现键盘录入

package com.heima.otherio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class Demo7_SystemIn {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        /*BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //InputStreamReader转换流
        String line = br.readLine();
        System.out.println(line);   //只能读入字符串，System.in的流可以不用关闭
*/      
        Scanner sc = new Scanner(System.in);    //更推荐下面这一种，功能更强大
        String line = sc.nextLine();
        System.out.println(line);
    }

}

Properties的概述和作为Map集合的使用

A:Properties的概述
- Properties 类表示了一个持久的属性集。
- Properties 可保存在流中或从流中加载。
- 属性列表中每个键及其对应值都是一个字符串。
A:Properties的特殊功能
- public Object setProperty(String key,String value)
- public String getProperty(String key)
- public Enumeration<String> stringPropertyNames()
A:Properties的load()和store()功能

package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;

public class Demo10_Properties {

    /**
     * @param args
     * Properties是Hashtable的子类
     * @throws IOException 
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Properties prop = new Properties();
        System.out.println("读取前：" + prop);
        prop.load(new FileInputStream("config.properties"));
        System.out.println("读取后：" + prop);
        prop.setProperty("tel","18988888888");
        System.out.println("修改后：" + prop);
        prop.store(new FileOutputStream("config.properties"),"文件内可以用=号也可以用冒号"); //第二个参数是用来描述文件的，可以传null
        System.out.println("写入文件后" + prop);
    }

    public static void demo2() {
        Properties prop = new Properties();
        prop.setProperty("name", "张三");
        prop.setProperty("tel", "17764075112"); //setProperty的值不能是数字
        
        System.out.println(prop);
        Enumeration<String> en = (Enumeration<String>) prop.propertyNames();
        while(en.hasMoreElements()) {
            String key = en.nextElement();      //获取Properties中的每一个键
            String value = prop.getProperty(key);   //根据键获取值
            System.out.println(key + "=" + value);
        }
    }

    public static void demo1() {
        Properties prop = new Properties();
        prop.put("abc",123);
        System.out.println(prop);
    }

}

一些练习

package com.heima.test;

import java.io.File;
import java.util.Scanner;

public class Test1 {

    /**
     * @param args
     * 需求：1，从键盘接收一个文件夹路径，统计该文件夹大小
     * 
     * 从键盘接收一个文件夹路径
     * 1，创建键盘录入对象
     * 2，定义一个无限循环
     * 3，将键盘录入的结果存储并封装成File对象
     * 4，对File对象判断
     * 5，将文件夹路径对象返回
     * 
     * 统计该文件夹大小
     * 1，定义一个求和变量
     * 2，获取该文件夹下所有的文件和文件夹listFiles();
     * 3，遍历数组
     * 4，判断是文件就计算大小并累加
     * 5，判断是文件夹，递归调用
     */
    public static void main(String[] args) {
        File dir = getDir();
        System.out.println(getFileLength(dir));
        //File dir = new File("D:\\develop");   //直接计算文件夹大小没有意义，返回值是0
        //System.out.println(dir.length());
    }
    
    /*
     * 从键盘接收一个文件夹路径
     * 1，返回值类型File
     * 2，参数列表无
    */
    public static File getDir() {
        //1,创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个文件夹路径");
        //2,定义一个无限循环
        while(true) {
            //3,将键盘录入的结果存储并封装成File对象
            String line = sc.nextLine();
            File dir = new File(line);
            //4,对File对象判断
            if(!dir.exists()) {
                System.out.println("您录入的文件夹路径不存在，请输入一个文件夹路径:");
            }else if(dir.isFile()) {
                System.out.println("您录入的是文件路径，请输入一个文件夹路径:");
            }else {
                //5,将文件夹路径对象返回
                return dir;
            }
        }
    }
    
    /*
     * 统计该文件夹大小
     * 1，返回值类型long
     * 2，参数列表File dir
     */
    public static long getFileLength(File dir) {
        //1，定义一个求和变量
        long len = 0;
        //2，获取该文件夹下所有的文件和文件夹listFiles();
        File[] subFiles = dir.listFiles();
        //3，遍历数组
        for (File subFile : subFiles) {
            //4，判断是文件就计算大小并累加
            if(subFile.isFile()) {
                len = len + subFile.length();
            //5，判断是文件夹，递归调用
            }else {
                len = len + getFileLength(subFile);
            }
        }
        return len;
    }
}

package com.heima.test;

import java.io.File;

public class Test2 {

    /**
     * 需求：2，从键盘接收一个文件夹路径，删除该文件夹
     * 
     * 删除该文件夹
     * 分析：
     * 1,获取该文件夹下的所有的文件和文件夹
     * 2,遍历数组
     * 3,判断是文件直接删除
     * 4,如果是文件夹，递归调用
     * 5,循环结束后，把空文件夹删掉
     */
    public static void main(String[] args) {
        File dir = Test1.getDir();
        deleteFile(dir);
    }
    
    /*
     * 删除该文件夹
     * 1,返回值类型void
     * 2,参数列表File dir
     */
    public static void deleteFile(File dir) {
        //1,获取该文件夹下的所有的文件和文件夹
        File[] subFiles = dir.listFiles();
        //2,遍历数组
        for (File subFile : subFiles) {
            //3,判断是文件直接删除
            if(subFile.isFile()) {
                subFile.delete();
            //4,如果是文件夹，递归调用
            }else {
                deleteFile(subFile);
            }
        }
        //5,循环结束后，把空文件夹删掉
        dir.delete();   //如果上面的for循环里面没有递归调用，则会删除文件夹。
    }
}

package com.heima.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test3 {

    /**
     * 需求：3,从键盘接收两个文件夹路径，把其中一个文件夹(包含内容)拷贝到另一个文件夹中
     * 
     * 把其中一个文件夹(包含内容)拷贝到另一个文件夹中
     * 分析:
     * 1，在目标文件夹中创建原文件夹
     * 2，获取原文件夹中所有的文件和文件夹，存储在File数组中
     * 3，遍历数组
     * 4，如果是文件就用io流读写
     * 5，如果是文件夹就递归调用
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        File src = Test1.getDir();
        File dest = Test1.getDir();
        if(src.equals(dest)) {
            System.out.println("目标文件夹是源文件夹的子文件夹");
        }else {
            copy(src, dest);
        }
        
    }
    /*
     * 把其中一个文件夹(包含内容)拷贝到另一个文件夹中
     * 1，返回类型void
     * 2，参数列表File src,File dest
     */
    public static void copy(File src, File dest) throws IOException {
        //1，在目标文件夹中创建原文件夹
        File newDir = new File(dest, src.getName());
        newDir.mkdir();
        //2，获取原文件夹中所有的文件和文件夹，存储在File数组中
        File[] subFiles = src.listFiles();
        //3，遍历数组
        for (File subFile : subFiles) {
            //4，如果是文件就用io流读写
            if(subFile.isFile()) {
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(subFile));
                BufferedOutputStream bos = new BufferedOutputStream(
                        new FileOutputStream(new File(newDir, subFile.getName())));
                int b;
                while((b = bis.read()) != -1) {
                    bos.write(b);   
                }
                
                bis.close();
                bos.close();
            //5，如果是文件夹就递归调用
            }else {
                copy(subFile, newDir);
            }       
        }
    }

}

package com.heima.test;

import java.io.File;

public class Test4 {

    /**
     * 需求:4,从键盘接收一个文件夹路径，把文件夹中的所有文件以及文件夹的名字按层级打印， 例如:
     * 把文件夹中的所有文件以及文件夹的名字按层级打印
     * 分析:
     * 1，获取所有文件和文件夹，返回File数组
     * 2，遍历数组
     * 3，无论是文件还是文件夹，都需要直接打印
     * 4，如果是文件夹，递归调用
     */
    public static void main(String[] args) {
        File dir = Test1.getDir();
        printLev(dir, 0);
    }

    public static void printLev(File dir,int lev) {
        //1，获取所有文件和文件夹，返回File数组
        File[] subFiles = dir.listFiles();
        //2，遍历数组
        for (File subFile : subFiles) {
            for(int i = 0; i <= lev; i++) {
                System.out.print("\t");
            }
            //3，无论是文件还是文件夹，都需要直接打印
            System.out.println(subFile);
            //4，如果是文件夹，递归调用
            if(subFile.isDirectory()) {
                printLev(subFile, lev + 1);
            }
        }
    }

}

package com.heima.test;

public class Test5 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //demo1();
        System.out.println(fun(8));
    }

    public static void demo1() {
        //斐波那契数列
        long[] arr = new long[100];
        arr[0] = 1;
        arr[1] = 1;
        //遍历数组对其他元素赋值
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i-2] + arr[i-1];
        }
        //打印
        System.out.println(arr[arr.length - 1]);
    }
    
    /*
     * 用递归求斐波那契数列
     */
    public static int fun(int num) {
        if(num == 1 || num == 2) {
            return 1;
        }else {
            return  fun(num - 2) + fun(num - 1);
        }
    }

}

package com.heima.test;

import java.math.BigInteger;

public class Test6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("1");   //获取1000的阶乘尾部有多少个0
        for (int i = 1; i <= 1000; i++) {
            BigInteger bi2 = new BigInteger(i+"");
            bi1 = bi1.multiply(bi2);    //将bi1与bi2相乘的结果赋值给bi1
        }
        String str = bi1.toString();    //获取字符串表现形式
        StringBuilder sb = new StringBuilder(str);
        str = sb.reverse().toString();  //链式编程
        
        int i = 0;                  //定义计算器
        for (i = 0; i < str.length(); i++) {
            if('0' != str.charAt(i)) {
                break;
            }
        }
        
        System.out.println(i);
    }

    public static void demo1() {    //求1000的阶乘中所有的零
        BigInteger bi1 = new BigInteger("1");
        for (int i = 1; i <= 1000; i++) {
            BigInteger bi2 = new BigInteger(i+"");
            bi1 = bi1.multiply(bi2);    //将bi1与bi2相乘的结果赋值给bi1
        }
        String str = bi1.toString();    //获取字符串表现形式
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if('0' == str.charAt(i)) {  //如果字符串中出现了0字符
                count++;                //计算器加1
            }
        }
        System.out.println(count);
    }

}

package com.heima.test;

import java.util.ArrayList;

public class Test8 {

    /**
     * @param args
     * 约瑟夫环
     * * 幸运数字
     */
    public static void main(String[] args) {
        System.out.println(getLucklyNum(100));
    }

    /*
     * 获取幸运数字
     * 1,返回值类型int
     * 2,参数列表int num
     */
    public static int getLucklyNum(int num) {
        ArrayList<Integer> list = new ArrayList<>();        //创建集合存储1到num的对象
        for(int i = 1; i <= num; i++) {
            list.add(i);                                    //将1到num存储在集合中
        }
        
        int count = 1;                                      //用来数数的,只要是3的倍数就杀人
        for(int i = 0; list.size() != 1; i++) {             //只要集合中人数超过1,就要不断的杀
            if(i == list.size()) {                          //如果i增长到集合最大的索引+1时
                i = 0;                                      //重新归零
            }
            
            if(count % 3 == 0) {                            //如果是3的倍数
                list.remove(i--);                               //就杀人
            }
            count++;
        }
        
        return list.get(0);
    }
}

java学习笔记9

序列流

内存输出流

内存输出流之黑马面试题

随机访问流概述和读写数据

对象操作流ObjecOutputStream

对象操作流ObjectInputStream

对象操作流优化

加上id号

数据输入输出流

打印流的概述和特点

标准输入输出流概述和输出语句

修改标准输入输出流拷贝图片

两种方式实现键盘录入

Properties的概述和作为Map集合的使用

一些练习

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读