蓝蓝站点

博客

发表于 更新于 分类于 ， ， Waline： 本文字数： 1.8k 阅读时长 ≈ 2 分钟

——–读字符：——————-
I am groot
I am groot!

1
`test.txt`文件中的内容：

I am groot
I am groot!

1
2
3
需要注意的是，写文件的时候`test.txt`文件可以不存在，OutputStreamWriter会自动创建这文件，然后写入该文件中。但前提是可以找到`test.txt`这个文件的父路径。如果父路径不存在，会抛出异常：`FileNotFoundException`。

例如把上面main中的代码改为：

String fileName = “\new1\test222.txt”;
System.out.println(“写文件结束…”);
writeByOutputStreamWriter(fileName);
System.out.println(“写文件结束…”);

1
2
因为当前工作目录下没有`new1`这个文件夹,所以无法在`new1`目录下创建`test222.txt`这个文件。
运行部分结果入下：

Exception in thread “main” java.io.FileNotFoundException: \new1\test222.txt (系统找不到指定的路径。)

1
2
3
4
5
6
7
# 应用：复制字符文件#

我们可以从一个文件中读取字符，然后再把这些字符写入到另一个文件中，然后再读，再写，一直循环知道读取结束。从而实现文件的复制操作。

但是只能复制存放字符的文件(.txt,.c,.java等)，不能复制二进制文件(如音频，视屏，音乐)

关键代码：

while((size=in.read(cbuf, 0, cbuf.length))!=-1)
{
//然后把数字中读取到的字符写入到输出流中，注意读多少写多好，不要整个数组都写进去
out.write(cbuf, 0, size);
}

1
完整的代码：

public static void copy(String from, String to)
{
InputStreamReader in=null;
OutputStreamWriter out=null;
try
{
in = new InputStreamReader(new FileInputStream(from),”gbk”);
//如果可以读了
if(in.ready())
{
out=new OutputStreamWriter(new FileOutputStream(to), “gbk”);
//缓存字符数组
char[] cbuf=new char[20];
int size;
//从输入流中读取一个数组的字符到数组中
while((size=in.read(cbuf, 0, cbuf.length))!=-1)
{
//然后把数字中读取到的字符写入到输出流中，注意读多少写多好，不要整个数组都写进去
out.write(cbuf, 0, size);
}
}
} catch (UnsupportedEncodingException | FileNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if(in!=null)
{
try{in.close();}
catch (IOException e)
{e.printStackTrace();}
}
if(out!=null)
{
try{out.close();}
catch (IOException e)
{e.printStackTrace();}
}
}
}

1
源文件：

I am groot
I am groot!

1
测试：

String from = “test.txt”;
String to = “copy.txt”;
copy(from, to);

1
运行后，当前工程目录下创建了一个`copy.txt`文件，文件中的内容如下：

I am groot
I am groot!

发表于 更新于 分类于 ， ， Waline： 本文字数： 1k 阅读时长 ≈ 1 分钟

删除一个或多个空行

正则表达式

1
^\s*$(?:\n|\r\n)

(?m)表示开启多行匹配模式，^是行开始，\\s*代表任意个空格，$代表行结束。
所以这句话的意思是:
    所有空行(包括有任意空格的行)都会被替换为空字符串，即空行被从字符串中移除。

但是这样还是存在一个问题，那就是如果最后一行如果是空行的话，上面的正则是无法删除的。

所以还要再执行一步正则替换，把最后一行的换行符给删除掉:

匹配空行正则2

1
(?:\n|\r\n)^\s*$

匹配效果:

这两个正则一起使用就可以删除掉所有空行了，两个正则的顺序可以随意。

删除所有空行Java代码

1
2
3
4
5
6
public static String deleteEmptyLine(String input)
{
    input=input.replaceAll("(?m)(?:\\n|\\r\\n)(?:^\\s*$)", "");
    input=input.replaceAll("(?m)(?:^\\s*$(?:\\n|\\r\\n))", "");
    return input;
}

移除多余的连续空格，只留下一个空格。

1
string.replaceAll("[ ]+", " ");

[ ]+表示一个或多个空格，" "表示一个空格。这句话的意思就是把多个空格替换为一个空格。
原文:https://blog.csdn.net/kaukiyou/article/details/46829375

在线正则图形化工具

https://regexper.com/这个在线工具支持javascirpt类型的正则表达式。(?:(?:^\s*$(?:\n|\r\n))|(?:(?:\n|\r\n)^\s*$))的图形如下:

https://www.debuggex.com/,这个在线工具支持javascript,python,pcre这三种方式，同时还支持在线匹配测试,(?:(?:^\s*$(?:\n|\r\n))|(?:(?:\n|\r\n)^\s*$))的图形如下:

https://jex.im/regulex/这个在线工具和第一个差不多，也可以绘图。(?:(?:^\s*$(?:\n|\r\n))|(?:(?:\n|\r\n)^\s*$))的图形如下:

发表于 更新于 分类于 ， ， Waline： 本文字数： 1.3k 阅读时长 ≈ 1 分钟

本文内容已丢失

所以平常使用的时候为了不分割到空字符串，还是设置limit=0比较好，可以就是直接调用String.split(regex)就行了。

replaceFirst()方法

String replaceFirst(String regex, String replacement)
    使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 调用此方法的 str.replaceFirst(regex, repl) 形式与以下表达式产生的结果完全相同：
    Pattern.compile(regex).matcher(str).replaceFirst(repl)

源码如下：

1
2
3
4
public String replaceFirst(String regex, String replacement) 
{
    return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
}

这个方法简直人如其名，我不知道该怎么详细些了。

实例

1
2
String text="aaa:hahaha...";
System.out.println(text.replaceFirst("aaa", "I am groot"));

运行结果：

1
I am groot:hahaha...

replaceAll()方法

public String replaceAll(String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
调用此方法的 str.replaceAll(regex, repl) 形式与以下表达式产生的结果完全相同：     Pattern.compile(regex).matcher(str).replaceAll(repl)

源码：

1
2
3
4
5
public String replaceAll(String regex, String replacement) 
{
    return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}

实例

1
2
3
String text="A:你好\nGtoot:_\nA:额，听不懂\nGroot:_\nA:。。。";
text=text.replaceAll("A", "Tony Stark");
System.out.println(text.replaceAll("_", "I am groot"));

运行结果：

1
2
3
4
5
6
Tony Stark:你好
Gtoot:I am groot
Tony Stark:额，听不懂
Groot:I am groot
Tony Stark:。。。

发表于 更新于 分类于 ， ， Waline： 本文字数： 2.5k 阅读时长 ≈ 2 分钟

文件内容丢失

来解释一下这个(.)\\1+正则表达还是的意思，

  • (.):捕获一个任意字符
  • \1反向引用,表示前面捕获的字符
  • +表示前面的字符出现1此或多次
    这句话的意思就是,匹配两个或者两个以上的重复的字符

然后$1表示第一个捕获组中的内容，也就是捕获到的这个字符。
所以temp.replaceAll("(.)\\1+", "$1");这句话的意思就是，把temp字符串中两个或者两个以上的重复字符替换成该字符本身，换句话说就是删除所有重复到的字符。

对IP地址进行排序

原文：https://blog.csdn.net/sinat_36713319/article/details/53463120

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void sortIPAddress()
{
    String temp = "192.168.1.200 10.10.10.10 10.10.10.11 11.10.10.10 3.3.50.3 127.0.0.1";
    // 对所有的数字全部都在前面补上两个0
    temp = temp.replaceAll("(\\d+)", "00$1");
    System.out.println("ip地址:-->"+temp);
    // 因为ip地址占3位(\d{3})捕获后三位,
    // 把多余的0删除掉
    temp = temp.replaceAll("0+(\\d{3})", "$1");// 将ip地址补成同样位数
    System.out.println("ip地址:-->"+temp);
    // 用空格割
    String[] str = temp.split(" +");
    // 排序从大到小排序
    Arrays.sort(str);
    System.out.println("从小到大排序:");
    for (String string : str)
    {
        System.out.println(string);
    }
    System.out.println("去掉加上的辅助0");
    for (String ips : str)
        //删除多余的0
        System.out.println(ips.replaceAll("0+(\\d+)", "$1"));
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ip地址:-->00192.00168.001.00200 0010.0010.0010.0010 0010.0010.0010.0011 0011.0010.0010.0010 003.003.0050.003 00127.000.000.001
ip地址:-->192.168.001.200 010.010.010.010 010.010.010.011 011.010.010.010 003.003.050.003 127.000.000.001
从小到大排序:
003.003.050.003
010.010.010.010
010.010.010.011
011.010.010.010
127.000.000.001
192.168.001.200
去掉加上的辅助0
3.3.50.3
10.10.10.10
10.10.10.11
11.10.10.10
127.0.0.1
192.168.1.20

  • 首先来看temp.replaceAll("(\\d+)", "00$1");这句，(\\d+)将捕获到ip地址中除了点号之外的所有数字串，因为ip地址每一位可以是1位数，2位数，3位数，这里先不管使用00$1进行替换，这样每一位就是3位数到5位数。
  • temp.replaceAll("0+(\\d{3})", "$1");这句，首先\d{3}表示正好匹配3位数，0+一个或者多个0，0+(\\d{3})这个表达式的意思就是，匹配多个0开头，然后后面正好有3位数，把这3位数捕获出来，temp.replaceAll("0+(\\d{3})", "$1");这句话的意思就是捕获最后的3位数，然后用这3位数，替换掉原来的3到5位的数
  • 经过上面两步之后，所有的ip地址都会变成3位数表示的，不足的前面会补0，这样转换的好处就是可以方便的使用Array.sort()方法对这些字符串进行排序。
  • 注意排序后的字符，都是我们高位补0后的ip地址这与平时的ip地址表示方式不同所以，要把高位的0去掉。
  • ips.replaceAll("0+(\\d+)", "$1")这句话实现去掉高位的0,高位的0不会被捕获到，高位的0不包含在捕获组$1,这样在进行替换的时候就等于删除了高位的0

小结

**使用替换进行删除或添加元素，就是拿出来又放回去**，如果少放了就相当于删除一部分了，如果多方了就是新增了一部分。

  • 替换删除，以少换多：我们匹配较多的字符，然后只捕获其中较少的一部分，再用捕获到的少量字符替换匹配的较多的字符，这样就等同于删除掉那些没有捕获的部分。这就好比从果篮里拿出几个水果，例如拿出苹果和香蕉，然后我再把苹果放回去，香蕉丢掉。这样果篮里的香蕉就没有了，相当于被删除掉了。
  • 替换添加，以多换少：我么匹配较少的字符,并且捕获这些字符，然后捕获到的字符加上一些新的字符替换回去。这样等效于添加了字符。例如我现在只拿出雪梨，然后我变出一个芒果，然后雪梨和芒果一起放回果篮里，这样果篮里就多出了一个芒果，而雪梨还是原来的雪梨。

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 683 阅读时长 ≈ 1 分钟

一、建立空文件的几种方法

使用cd命令

1、cd.>a.txt
cd.表示改变当前目录为当前目录，即等于没改变；而且cd命令不会有输出。
“>”表示把命令输出写入到文件。后面跟着a.txt，就表示写入到a.txt。
而此例中命令不会有输出，所以就创建了没有内容的空文件。

当然不用写地址也是可以的，也就是说cd >1.txt也是可以的。

使用copy命令

2、copy nul a.txt
nul表示空设备，从概念上讲，它不可见，存在于每个目录中，可以把它看成一个特殊的“文件”，它没有内容；一般可把输出写入到nul，来达到屏蔽输出的目的，如pause>nul，此命令执行效果是暂停，并且不会显示“请按任意键继续…”。
此例子表示将空设备复制到a.txt，同样创建了没有内容的空文件。

使用type命令

3、type nul>a.txt
此例子表示显示空设备的内容，并写入到a.txt。空目录没有内容，所以也就是创建了一个空文件。

使用echo命令

4、echo a 2>a.txt
“2”表示错误输出的句柄，此例中没有错误输出，所以创建了没有内容的空文件。
其实**>默认都是重定向了句柄1，即标准输出句柄**。比如cd.>a.txt，其实就是cd. 1>a.txt。
同样，句柄3到9也可以使用在本例中，它们是未经定义的句柄，也不会有输出，如
echo a 3>a.txt。

使用fsutil命令

5、fsutil file createnew d:\a.txt 0
使用fsutil创建了一个空文件。

关键点

只要没有输出，并重定向到文件就可以了

百度知道-cmd 如何新建文件

发表于 更新于 分类于 ， ， Waline： 本文字数： 5.1k 阅读时长 ≈ 5 分钟

本文转自：https://www.cnblogs.com/hellowhy/p/7238570.html

java获取文件大小的方法

目前Java获取文件大小的方法有两种：

  • 1、通过file的length()方法获取；

  • 2、通过流式方法获取；

通过流式方法又有两种，分别是旧的java.io.*中FileInputStream的available()方法和新的java.nio.*中的FileChannel

下面依次介绍这几种方法：

首先选择一个文件并查看这个文件在windows中显示的大小，为了测试准确性，我这里选取了一个大文件（超过2GB）

查看这个文件在windows中显示的大小：
![图片描述][img_2018/07/30_19:46:37]

可以看出这个文件的实际大小是2588266496Byte(2527604KB)，下面通过代码来获取文件大小，并进行比较：

一、通过File类的length()方法获取文件的大小

1、创建一个文件：

1
2
File bigFile=new File("F:\\软件\\安装包_office2016\\Office2016.iso");

2、获取文件大小：File.length()方法可以获取文件的大小(占用的字节数)

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 获取文件长度
* @param file
*/
public static void getFileSize1(File file) 
{
    if (file.exists() && file.isFile()) 
    {
      
        System.out.println("文件"+file.getName()+"的大小是："+file.length()\1024+"KB");
    }
}

3.运行结果：

1
文件Office2016.iso的大小是：2588266496(Byte)=2527604(KB)

可见，使用length方法获取的文件大小与windows中显示的大小一致！

二、通过file.io.*中的流式方法获取

使用FileInputStream.available方法获取：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 根据java.io.*的流获取文件大小
 * @param file
 */
public static void getFileSize2(File file){
    FileInputStream fis  = null;
    try {
        if(file.exists() && file.isFile()){
            String fileName = file.getName();
            fis = new FileInputStream(file);
            System.out.println("文件"+fileName+"的大小是："+fis.available()+"(Byte)="+fis.available()/1024+"(KB)");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally{
        if(null!=fis){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3、查看结果：

1
文件Office2016.iso的大小是：2147483647(Byte)=2097151(KB)

通过这种方法获取的文件大小是2147483647(Byte)，很明显，这是int类型所能表示的最大值(2^31-1)=2147483647，究其原因是因为文件的大小超过了int所能表示的最大值！！！

而上面file.length()方法计算没有问题是因为，file.length()方法返回的是long,而available()方法返回的类型是int类型。

三、通过file.nio.*中的FileChannel工具来获取文件大小：

使用FileChannel获取文件大小：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
   * 根据java.nio.*的流获取文件大小
   * @param file
   */
  public static void getFileSize3(File file){
      FileChannel fc = null;
      try {
          if(file.exists() && file.isFile()){
              String fileName = file.getName();
              FileInputStream fis = new FileInputStream(file);
              fc = fis.getChannel();
              System.out.println("文件"+fileName+"的大小是："+fc.size()+"\n");
          }
      } catch (Exception e) {
          e.printStackTrace();
      }finally{
          if(null!=fc){
              try {
                  fc.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  }

该方法运行结果。

1
文件Office2016.iso的大小是：2588266496(Byte)=2527604KB

这里的size()方法的返回值类型也是long,通过这种方法获取的文件大小和第一种一样，都能获取文件实际大小。

四、使用小文件测试以上三种方法：

以上情况中文件大小超过了available()返回类型int的最大值，下面使用一个没有超过int最大值的文件测试，来验证通过这三种方法获取的大小是否和windows中显示的一致：

1、获取文件，查看其在windows中的大小：

![图片描述][img_2018/07/30_19:54:42]

可见该文件总共有1345个字节。

3、查看通过三种方法获取的结果：

1
2
3
4
文件CodeFormat.jar的大小是：1345(Byte)=1(KB)
文件CodeFormat.jar的大小是：1345(Byte)=1(KB)
最大的int值=2147483647
文件CodeFormat.jar的大小是：1345(Byte)=1KB

java获取文件大小总结

1、三种方法获取小文件(小于int能表示的最大范围:2147483647(Byte)=2097151(KB))时结果一样。
2、获取大文件时，为避免文件长度大于方法返回值类型的最大值，尽量使用File.length()或FileChannel.size()方法获取；
最大的long值=9223372036854775807，9223372036854775807(Byte)转换为TB大小如下图，我想没有这么大的文件吧。使用long表示绝对是够了。
![图片描述][img_2018/07/30_20:01:38]

完整的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package lan.base;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

public class GetFileLength
{
    public static void getFileSize1(File file) 
    {
        if (file.exists() && file.isFile()) 
        {
          
            System.out.println("文件"+file.getName()+"的大小是："+file.length()+"(Byte)="+file.length()/1024+"(KB)");
        }
    }
    /**
     * 根据java.io.*的流获取文件大小
     * @param file
     */
    public static void getFileSize2(File file){
        FileInputStream fis  = null;
        try {
            if(file.exists() && file.isFile()){
                String fileName = file.getName();
                fis = new FileInputStream(file);
                System.out.println("文件"+fileName+"的大小是："+fis.available()+"(Byte)="+fis.available()/1024+"(KB)");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(null!=fis){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 根据java.nio.*的流获取文件大小
     * @param file
     */
    public static void getFileSize3(File file){
        FileChannel fc = null;
        try {
            if(file.exists() && file.isFile()){
                String fileName = file.getName();
                FileInputStream fis = new FileInputStream(file);
                fc = fis.getChannel();
                System.out.println("文件"+fileName+"的大小是："+fc.size()+"(Byte)="+fc.size()/1024+"KB");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(null!=fc){
                try {
                    fc.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args)
    {
        File bigFile=new File("F:\\软件\\安装包_office2016\\Office2016.iso");
//        File smallFile=new File("D:\\dev\\java\\my\\tools\\CodeFormat.jar");
        getFileSize1(bigFile);
        getFileSize2(bigFile);
        System.out.println("最大的int值="+Integer.MAX_VALUE);
        getFileSize3(bigFile);
    }
}