java-创建一个包含0和1（大小为n）的所有可能组合的文本文件

我通过java创建了一个文本文件。该文件应包含长度为n的0和1的所有可能组合

例如，n＝3的组合为：

000001010011100101110111

文件应包含：

000001010011110

而不是：

000001010011100101110111

因为算法检查每个组合是否已经在文件中

我已经开发了一种算法，可以做到这一点，但是速度非常慢，因为有一种方法可以检查文件中是否已经存在组合（infle（））

我不能使用可能包含组合的字符串，因为如果我尝试生成长度为20的字符串，字符串的长度将是2^20*20，eclipse需要时间来分析它

算法：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test
{
    public static String FileName = "file.txt";
    public static int size = 20;
    public static FileReader fr;
    public static BufferedReader br;
    public static FileWriter fw;
    public static BufferedWriter bw;
    public static void main(String[] args) {
        try
        {
            fw = new FileWriter(FileName, true);
            bw = new BufferedWriter(fw);

            try
            {
                fr = new FileReader(FileName);
                br = new BufferedReader(fr);
                doit(size);
                System.out.println("\n>> finished");
                br.close();
            }
            catch(FileNotFoundException e)
            {
                System.out.println("File was not found!");
            }
            catch(IOException e)    
            {
                System.out.println("No file found!");
            }

            bw.close();
        }
        catch(FileNotFoundException e)
        {
            System.out.println("Error1!");
        }
        catch(IOException e)    
        {
            System.out.println("Error2!");
        }
    }

    public static void doit(int l) {
        String s="",c="";
        for(int i=0;i<l;s+="0",c+="1",i++);
        write(s);
        while(!s.equals(c)) {
            for(int z=l-1;z>=0;z--) {
                if(s.charAt(z) == '1')
                    continue;
                s = s.substring(0,z);
                s += "1";
                for(int b=0;b<l-z-1;b++) {
                    s+="0";
                }
                z=-1;
            }
            if(!inFile(s)) {
                write(s);
            }
        }
    }

    public static boolean inFile(String sub) {
        try
        {
            br = new BufferedReader(new FileReader(FileName));
            String line = br.readLine();
            if(line.indexOf(sub) != -1)
                return true;
            return false;
        }
        catch (FileNotFoundException e)
        {
            System.out.println("Error: file to read from not found");
            return false;
        }
        catch (IOException e)
        {
            System.out.println("Error: file to read from not found - 2");
            return false;
        }
    }

    public static void write(String s) {
        try
        {
            bw.write(s);
            bw.flush();
        }
        catch (IOException e)
        {
            System.out.println("Error3!");
        }
    }
}

导入java.io.BufferedReader；
导入java.io.BufferedWriter；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.FileWriter；
导入java.io.IOException；
公开课考试
{
公共静态字符串FileName=“file.txt”；
公共静态int size=20；
公共静态文件阅读器；
公共静态缓冲读取器br；
公共静态文件编写器；
公共静态缓冲写入程序bw；
公共静态void main（字符串[]args）{
尝试
{
fw=新文件编写器（文件名，true）；
bw=新的缓冲写入程序（fw）；
尝试
{
fr=新文件读取器（文件名）；
br=新的缓冲读取器（fr）；
doit（大小）；
System.out.println（“\n>>完成”）；
br.close（）；
}
catch（filenotfounde异常）
{
System.out.println（“未找到文件！”）；
}
捕获（IOE异常）
{
System.out.println（“找不到文件！”）；
}
bw.close（）；
}
catch（filenotfounde异常）
{
System.out.println（“Error1！”）；
}
捕获（IOE异常）
{
System.out.println（“Error2！”）；
}
}
公共静态void doit（int l）{
字符串s=“”，c=“”；
对于（int i=0；i=0；z--）{
如果（s.charAt（z）='1'）
继续；
s=s.子串（0，z）；
s+=“1”；
对于（int b=0；b文件应包含：00000 1010011110或000010011110？（对于..1111…，也可以包含相同的内容）

如果您知道要打印什么，则无需检查：

 public static void main(String []args){
    int n = 4;

    print(n,0);
    for (int i=0;i<n;i++){
        print(i,1);
        print(i,0);
    }
    print(n,1);
    System.out.println("");

 }
    static void print(int max, int number){
        for (int j=0;j<max;j++){
            System.out.print(number);
        }
    }

publicstaticvoidmain（字符串[]args）{
int n=4；
打印（n，0）；
对于（int i=0；i当生成长度为n的所有位字符串时，将有n^2种可能性。要通过算法生成所有这些可能性，可以为小于n^2的每个整数生成位字符串

在你的n=3的例子中，3^2是8，所以我们需要使用所有小于8的整数：
0的长度为3的位字符串为000。
1的长度为3的位字符串为001。
2的长度为3的位字符串为010。
3的长度为3的位字符串为011。
4的长度为3的位字符串为100。
5的长度为3的位字符串为101。
6的长度为3的位字符串为110。
7的长度为3的位字符串为111

我们可以使用以下java方法生成这些：

Integer.toBitString(4)

将返回“100”。但是，有一个问题，这将不会用零填充数字，使其达到适当的长度

Integer.toBitString(1)

将返回“1”。要解决此问题，我们可以使用java方法将整数填充为适当数量的空格，然后将空格替换为0，如下所示：

String.format("%3s", Integer.toBinaryString(1)).replace(' ', '0')

使用for循环，可以生成这些字符串并将其打印到文件中

for(int i = 0; i < math.Pow(n, 2); i++) {
    String poss = String.format("%*s", n, Integer.toBinaryString(i)).replace(' ', '0')
    filePrintStream.print(poss);
}

for（inti=0；i

这将按顺序生成所有可能的位字符串，无重复。
可能的重复首先，在内存中构造字符串，对该字符串执行检查，并在完成该操作后仅涉及文件IO。除此之外，我认为这将朝着渐进复杂性的方向发展……这不是双重检查，也许您没有理解。它执行此检查是因为在第三次写入之后，可能在其他组合之间已经存在组合。001和101也包含110Siguza，如果我创建一个字符串并将组合插入字符串，并且长度很长（超过15）字符串的大小将是2^15*15，这是一个很大的数目。要分析它需要花费很多时间time@freedev但是当你创建
001
和
100
时，你如何从中得出
010
已经存在？该文件应该以任何顺序包含所有可能的组合。我只是想避免重复，为了节省内存。请检查以下n=3的答案：000101100111 n=4:000010110011100011111 n=5:00000101100111000111111问题不在于内存是为了避免生成您不需要的组合…我希望实际代码会保存
Math.pow（n，2）
在某个地方，不要为每个循环迭代重新计算它。我认为java会优化它，而不是每次迭代都对它进行评估，但它应该是
Math.pow（2，n）
而不是相反。